A Process Algebraic Approach to Software Architecture Design

Inthe?eldofformalmethodsincomputerscience,concurrencytheoryisreceivinga constantlyincreasinginterest.Thisisespeciallytrueforprocessalgebra.Althoughit had been originally conceived as a means for reasoning about the semantics of c- current programs, process algebraic formalisms like CCS, CSP, ACP, ?-calculus, and their extensions (see, e.g., [154,119,112,22,155,181,30]) were soon used also for comprehendingfunctionaland nonfunctionalaspects of the behaviorof com- nicating concurrent systems. The scienti?c impact of process calculi and behavioral equivalences at the base of process algebra is witnessed not only by a very rich literature. It is in fact worth mentioningthe standardizationprocedurethat led to the developmentof the process algebraic language LOTOS [49], as well as the implementation of several modeling and analysis tools based on process algebra, like CWB [70] and CADP [93], some of which have been used in industrial case studies. Furthermore, process calculi and behavioral equivalencesare by now adopted in university-levelcourses to teach the foundations of concurrent programming as well as the model-driven design of concurrent, distributed, and mobile systems. Nevertheless, after 30 years since its introduction, process algebra is rarely adopted in the practice of software development. On the one hand, its technica- ties often obfuscate the way in which systems are modeled. As an example, if a process term comprises numerous occurrences of the parallel composition operator, it is hard to understand the communicationscheme among the varioussubterms. On the other hand, process algebra is perceived as being dif?cult to learn and use by practitioners, as it is not close enough to the way they think of software systems.

[1]  Steve Vestal,et al.  Mode changes in a real-time architecture description language , 1994, Proceedings of 2nd International Workshop on Configurable Distributed Systems.

[2]  C. Chambers,et al.  ArchJava: connecting software architecture to implementation , 2002, Proceedings of the 24th International Conference on Software Engineering. ICSE 2002.

[3]  Albert R. Meyer,et al.  Bisimulation can't be traced , 1988, POPL '88.

[4]  José M. Troya,et al.  Compatibility and inheritance in software architectures , 2001, Sci. Comput. Program..

[5]  Paola Inverardi,et al.  Formal Specification and Analysis of Software Architectures Using the Chemical Abstract Machine Model , 1995, IEEE Trans. Software Eng..

[6]  Domenico Ferrari.  Considerations on the insularity of performance evaluation , 1986, IEEE Transactions on Software Engineering.

[7]  Naranker Dulay,et al.  Specifying Distributed Software Architectures , 1995, ESEC.

[8]  Marco Bernardo,et al.  Non-synchronous Communications in Process Algebraic Architectural Description Languages , 2008, ECSA.

[9]  Alessandro Aldini,et al.  Handling communications in process algebraic architectural description languages: Modeling, verification, and implementation , 2010, J. Syst. Softw..

[10]  Robin Milner,et al.  A Calculus of Mobile Processes, II , 1992, Inf. Comput..

[11]  K. Mani Chandy,et al.  Computational algorithms for product form queueing networks , 1980 .

[12]  C. A. R. Hoare,et al.  Specification-oriented semantics for Communicating Processes , 1983, Acta Informatica.

[13]  Paolo Ciancarini,et al.  Architecting families of software systems with process algebras , 2002, TSEM.

[14]  David Garlan,et al.  A formal basis for architectural connection , 1997, TSEM.

[15]  K. Mani Chandy,et al.  Open, Closed, and Mixed Networks of Queues with Different Classes of Customers , 1975, JACM.

[16]  Rob J. van Glabbeek,et al.  The Linear Time - Branching Time Spectrum I , 2001, Handbook of Process Algebra.

[17]  Richard N. Taylor,et al.  A Classification and Comparison Framework for Software Architecture Description Languages , 2000, IEEE Trans. Software Eng..

[18]  C. A. R. Hoare,et al.  A Theory of Communicating Sequential Processes , 1984, JACM.

[19]  Rocco De Nicola,et al.  Testing Equivalences for Processes , 1984, Theor. Comput. Sci..

[20]  Marco Bernardo,et al.  Synthesizing Concurrency Control Components from Process Algebraic Specifications , 2006, COORDINATION.

[21]  Henry Muccini,et al.  An explorative journey from architectural tests definition downto code tests execution , 2001, Proceedings of the 23rd International Conference on Software Engineering. ICSE 2001.

[22]  J. Bergstra,et al.  Handbook of Process Algebra , 2001 .

[23]  David Garlan,et al.  A compositional formalization of connector wrappers , 2003, 25th International Conference on Software Engineering, 2003. Proceedings..

[24]  Robin Milner,et al.  Communicating and mobile systems - the Pi-calculus , 1999 .

[25]  Kim G. Larsen,et al.  Bisimulation through Probabilistic Testing , 1991, Inf. Comput..

[26]  Marco Bernardo.  Markovian Testing Equivalence and Exponentially Timed Internal Actions , 2009, QFM.

[27]  David Garlan,et al.  Exploiting style in architectural design environments , 1994, SIGSOFT '94.

[28]  Paola Inverardi,et al.  Static checking of system behaviors using derived component assumptions , 2000, TSEM.

[29]  Nenad Medvidovic,et al.  Modeling software architectures in the Unified Modeling Language , 2002, TSEM.

[30]  C. Petri.  Kommunikation mit Automaten , 1962 .

[31]  Daniel M. Yellin,et al.  Protocol specifications and component adaptors , 1997, TOPL.

[32]  Marco Bernardo,et al.  Guest editors' introduction: Special issue on Process Algebra and System Architecture , 2005, J. Log. Algebraic Methods Program..

[33]  Marco Bernardo.  Symbolic semantic rules for producing compact STGLAs from value passing process descriptions , 2004, TOCL.

[34]  Marco Bernardo,et al.  Uniform Logical Characterizations of Testing Equivalences for Nondeterministic, Probabilistic and Markovian Processes , 2009, QAPL.

[35]  Alessandro Aldini,et al.  On the usability of process algebra: An architectural view , 2005, Theor. Comput. Sci..

[36]  Raheel Ahmad,et al.  The π-Calculus: A theory of mobile processes , 2008, Scalable Comput. Pract. Exp..

[37]  Stephan Merz,et al.  Model Checking , 2000 .

[38]  Radu Mateescu,et al.  CADP 2006: A Toolbox for the Construction and Analysis of Distributed Processes , 2007, CAV.

[39]  José M. Troya,et al.  Specification and Refinement of Dynamic Software Architectures , 1999, WICSA.

[40]  Mihaela Sighireanu,et al.  A Graphical Parallel Composition Operator for Process Algebras , 1999, FORTE.

[41]  Peyman Oreizy,et al.  Using object-oriented typing to support architectural design in the C2 style , 1996, SIGSOFT '96.

[42]  Joseph Sifakis,et al.  Composition for component-based modeling , 2002, Sci. Comput. Program..

[43]  Marcel F. Neuts,et al.  Matrix-geometric solutions in stochastic models - an algorithmic approach , 1982 .

[44]  Paola Inverardi,et al.  Failure-free coordinators synthesis for component-based architectures , 2008, Sci. Comput. Program..

[45]  Paolo Ciancarini,et al.  Stochastic Process Algebra: From an Algebraic Formalism to an Architectural Description Language , 2002, Performance.

[46]  Rob J. van Glabbeek,et al.  Branching time and abstraction in bisimulation semantics , 1996, JACM.

[47]  Robin Milner,et al.  Communication and concurrency , 1989, PHI Series in computer science.

[48]  Marco Bernardo,et al.  Generating well-synchronized multithreaded programs from software architecture descriptions , 2004, Proceedings. Fourth Working IEEE/IFIP Conference on Software Architecture (WICSA 2004).

[49]  Robin Milner,et al.  Algebraic laws for nondeterminism and concurrency , 1985, JACM.

[50]  J. C. M. Baeten,et al.  Process Algebra: Bibliography , 1990 .

[51]  Alessandro Aldini,et al.  A Methodology Based on Formal Methods for Predicting the Impact of Dynamic Power Management , 2005, SFM.

[52]  Matthew Hennessy,et al.  Acceptance trees , 1985, JACM.

[53]  David Garlan,et al.  Specifying and Analyzing Dynamic Software Architectures , 1998, FASE.

[54]  Ronald A. Howard,et al.  Dynamic Probabilistic Systems , 1971 .

[55]  Rob J. van Glabbeek,et al.  The Linear Time - Branching Time Spectrum II , 1993, CONCUR.

[56]  Xiaolei Qian,et al.  Correct Architecture Refinement , 1995, IEEE Trans. Software Eng..

[57]  Antonio Brogi,et al.  A formal approach to component adaptation , 2005, J. Syst. Softw..

[58]  Thomas M. Cover,et al.  Elements of Information Theory , 2005 .

[59]  Boudewijn R. Haverkort,et al.  Specification techniques for Markov reward models , 1993, Discret. Event Dyn. Syst..

[60]  Christel Baier,et al.  Automated Performance and Dependability Evaluation Using Model Checking , 2002, Performance.

[61]  Flávio Oquendo.  π-ADL: an Architecture Description Language based on the higher-order typed π-calculus for specifying dynamic and mobile software architectures , 2004, SOEN.

[62]  Scott A. Smolka,et al.  CCS expressions, finite state processes, and three problems of equivalence , 1983, PODC '83.

[63]  Davide Sangiorgi,et al.  Communicating and Mobile Systems: the π-calculus, , 2000 .

[64]  Mario Bravetti,et al.  Performance measure sensitive congruences for Markovian process algebras , 2003, Theor. Comput. Sci..

[65]  James R. Cordy,et al.  A Syntactic Theory of Software Architecture , 1995, IEEE Trans. Software Eng..

[66]  Jeff Magee,et al.  Concurrency - state models and Java programs , 2006 .

[67]  Robin Milner,et al.  A Calculus of Mobile Processes, II , 1992, Inf. Comput..

[68]  Jeff Magee,et al.  Exposing the Skeleton in the Coordination Closet , 1997, COORDINATION.

[69]  Stephen Gilmore,et al.  Exploiting Modal Logic to Express Performance Measures , 2000, Computer Performance Evaluation / TOOLS.

[70]  Gregory D. Abowd,et al.  Formalizing style to understand descriptions of software architecture , 1995, TSEM.

[71]  Samson Abramsky,et al.  Observation Equivalence as a Testing Equivalence , 1987, Theor. Comput. Sci..

[72]  Davide Sangiorgi,et al.  The Pi-Calculus - a theory of mobile processes , 2001 .

[73]  Glynn Winskel,et al.  Events in computation , 1980 .

[74]  David Park,et al.  Concurrency and Automata on Infinite Sequences , 1981, Theoretical Computer Science.

[75]  Paola Inverardi,et al.  Proving Deadlock Freedom in Component-Based Programming , 2001, FASE.

[76]  Alessandro Aldini,et al.  A formal approach to the integrated analysis of security and QoS , 2007, Reliab. Eng. Syst. Saf..

[77]  Dana S. Scott,et al.  Data Types as Lattices , 1976, SIAM J. Comput..

[78]  Steve Vestal,et al.  The SAE Architecture Analysis & Design Language (AADL) a standard for engineering performance critical systems , 2006, 2006 IEEE Conference on Computer Aided Control System Design, 2006 IEEE International Conference on Control Applications, 2006 IEEE International Symposium on Intelligent Control.

[79]  Bernhard Steffen,et al.  Compositional Minimization of Finite State Systems , 1990, CAV.

[80]  Alexander L. Wolf,et al.  Acm Sigsoft Software Engineering Notes Vol 17 No 4 Foundations for the Study of Software Architecture , 2022 .

[81]  Edward D. Lazowska,et al.  Quantitative system performance - computer system analysis using queueing network models , 1983, Int. CMG Conference.

[82]  Paola Inverardi,et al.  Performance analysis at the software architectural design level , 2001, Perform. Evaluation.

[83]  Jeffrey P. Buzen,et al.  Computational algorithms for closed queueing networks with exponential servers , 1973, Commun. ACM.

[84]  Walter Mann,et al.  Correction to "Specification and Analysis of System Architecture Using Rapide" , 1995, IEEE Trans. Software Eng..

[85]  David Garlan,et al.  Acme: architectural description of component-based systems , 2000 .

[86]  David Garlan.  Formal Methods for Software Architectures , 2003, Lecture Notes in Computer Science.

[87]  Paola Inverardi,et al.  Formal Methods for Software Architectures , 2003 .

[88]  Daniel Le Métayer.  Describing Software Architecture Styles Using Graph Grammars , 1998, IEEE Trans. Software Eng..

[89]  William J. Stewart,et al.  Introduction to the numerical solution of Markov Chains , 1994 .

[90]  Marco Bernardo,et al.  Preserving Architectural Properties in Multithreaded Code Generation , 2005, COORDINATION.

[91]  Rob van Glabbeek,et al.  Handbook of Process Algebra , 2001 .

[92]  Rance Cleaveland,et al.  Testing equivalence as a bisimulation equivalence , 1989, Formal Aspects of Computing.

[93]  Nicolas D. Georganas,et al.  RECAL—a new efficient algorithm for the exact analysis of multiple-chain closed queuing networks , 1986, JACM.

[94]  Mary Shaw,et al.  Abstractions for Software Architecture and Tools to Support Them , 1995, IEEE Trans. Software Eng..

[95]  Henry Muccini,et al.  Deriving test plans from architectural descriptions , 2000, Proceedings of the 2000 International Conference on Software Engineering. ICSE 2000 the New Millennium.

[96]  Matthew Hennessy,et al.  Algebraic theory of processes , 1988, MIT Press series in the foundations of computing.

[97]  Rance Cleaveland,et al.  The concurrency workbench: a semantics-based tool for the verification of concurrent systems , 1993, TOPL.

[98]  Tommaso Bolognesi,et al.  Tableau methods to describe strong bisimilarity on LOTOS processes involving pure interleaving and enabling , 1994, FORTE.

[99]  C. A. R. Hoare,et al.  Communicating sequential processes , 1978, CACM.

[100]  Hans H. Kron,et al.  Programming-in-the-Large Versus Programming-in-the-Small , 1975 .

[101]  David Garlan,et al.  Architecture-Based Performance Analysis , 1998 .

[102]  S. Wittevrongel,et al.  Queueing Systems , 2019, Introduction to Stochastic Processes and Simulation.

[103]  Robert E. Tarjan,et al.  Three Partition Refinement Algorithms , 1987, SIAM J. Comput..

[104]  Mary Shaw,et al.  Software architecture - perspectives on an emerging discipline , 1996 .

[105]  Hans H. Kron,et al.  Programming-in-the-Large Versus Programming-in-the-Small , 1975, IEEE Transactions on Software Engineering.

[106]  Jan A. Bergstra,et al.  Ready-Trace Semantics for Concrete Process Algebra with the Priority Operator , 1987, Comput. J..

[107]  Shikharesh Majumdar,et al.  The Stochastic Rendezvous Network Model for Performance of Synchronous Client-Server-like Distributed Software , 1995, IEEE Trans. Computers.

[108]  Alessandro Aldini,et al.  Mixing logics and rewards for the component-oriented specification of performance measures , 2007, Theor. Comput. Sci..

[109]  Gordon D. Plotkin,et al.  A structural approach to operational semantics , 2004, J. Log. Algebraic Methods Program..

[110]  Rance Cleaveland,et al.  Equivalence and Preorder Checking for Finite-State Systems , 2001, Handbook of Process Algebra.

[111]  Stephen S. Lavenberg,et al.  Mean-Value Analysis of Closed Multichain Queuing Networks , 1980, JACM.

[112]  Hans Bekic,et al.  Towards a Mathematical Theory of Processes , 1984, Programming Languages and Their Definition.

[113]  Bernhard Steffen,et al.  Reactive, generative, and stratified models of probabilistic processes , 1990, [1990] Proceedings. Fifth Annual IEEE Symposium on Logic in Computer Science.

[114]  David Garlan,et al.  Architectural Mismatch: Why Reuse Is So Hard , 1995, IEEE Softw..

[115]  William H. Sanders,et al.  A Unified Approach for Specifying Measures of Performance, Dependability and Performability , 1991 .

[116]  Robin Milner,et al.  A Calculus of Communicating Systems , 1980, Lecture Notes in Computer Science.

[117]  Connie U. Smith,et al.  Performance Engineering of Software Systems , 1990, SIGMETRICS Perform. Evaluation Rev..

[118]  Simonetta Balsamo,et al.  Performance Evaluation at the Software Architecture Level , 2003, SFM.