A Model of Service-Oriented Architectures

Architectural styles and patterns play an important role in software engineering. Over the last years, a new style based on the notion of services emerged, which we call the service-oriented architecture style. However, this style is usually only stated informally, which may cause inherent problems such as ambiguity, wrong conclusions, and the difficulty of checking the conformance of a system to the style. We address these problems by providing a formal, denotational semantics of the service-oriented architecture style and two variants thereof: the layered architecture style and the strict architecture style. Loosely speaking, in our model of the service-oriented architecture style, services are a means of communication. Components exchange services between each other via ports. The layered architecture variant imposes a well-foundedness constraint on the communication structure, while the strict variant imposes an antitransitivity constraint. We analyze the notions of syntactic and semantic dependencies for service-oriented architectures and investigate their relationship. Moreover, the expected informal properties of the styles are formulated as theorems. Finally, we present a method for soundly analyzing instances of the style. Our rigorous approach enables building higher-quality architectures, for which properties can be mathematically stated and proven, by enforcing formal discipline on the inter-component scale.

[1]  Samson Abramsky,et al.  Introduction to Abstract Interpretation , 1987 .

[2]  David Garlan,et al.  Formal Specifications as Reusable Frameworks , 1990, VDM Europe.

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

[4]  José Luiz Fiadeiro Categories for software engineering , 2005 .

[5]  Laurent Mauborgne,et al.  On the Strength of Owicki-Gries for Resources , 2011, APLAS.

[6]  David Garlan,et al.  Formalizing Design Spaces: Implicit Invocation Mechanisms , 1991, VDM Europe.

[7]  Manfred Broy,et al.  Specification and development of interactive systems: focus on streams, interfaces, and refinement , 2001 .

[8]  Alexander Malkis,et al.  Multithreaded-Cartesian Abstract Interpretation of Multithreaded Recursive Programs Is Polynomial , 2015, RP.

[9]  David Garlan,et al.  Software architecture: a roadmap , 2000, ICSE '00.

[10]  A. Rybalchenko,et al.  Thread-Modular Verification and Cartesian Abstraction , 2006 .

[11]  Manfred Broy,et al.  SERVICE-ORIENTED SYSTEMS ENGINEERING: SPECIFICATION AND DESIGN OF SERVICES AND LAYERED ARCHITECTURES , 2005 .

[12]  Daniel Jackson,et al.  Software Abstractions - Logic, Language, and Analysis , 2006 .

[13]  Andreas Podelski,et al.  Precise Thread-Modular Verification , 2007, SAS.

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

[15]  David Garlan,et al.  Formal modeling of the Enterprise JavaBeans(TM) component integration framework , 2001, Inf. Softw. Technol..

[16]  Ivar Jacobson,et al.  Where's the Theory for Software Engineering? , 2012, IEEE Software.

[17]  Patrick Cousot,et al.  Formal language, grammar and set-constraint-based program analysis by abstract interpretation , 1995, FPCA '95.

[18]  David Garlan,et al.  Formal Modeling of the Enterprise JavaBeansTM Component Integration Framework , 1999, World Congress on Formal Methods.

[19]  Diego Marmsoler,et al.  Towards a theory of architectural styles , 2014, SIGSOFT FSE.

[20]  Andreas Podelski,et al.  Refinement with Exceptions , 2012 .

[21]  Manfred Broy Can Practitioners Neglect Theory and Theoreticians Neglect Practice? , 2011, Computer.

[22]  Paul Clements,et al.  Software architecture in practice , 1999, SEI series in software engineering.

[23]  Douglas C. Schmidt,et al.  Pattern Oriented Software Architecture: On Patterns and Pattern Languages (Wiley Software Patterns Series) , 2007 .

[24]  Paolo Ciancarini,et al.  On the formalization of architectural types with process algebras , 2000, SIGSOFT '00/FSE-8.

[25]  Neil D. Jones,et al.  Complexity of flow analysis, inductive assertion synthesis and a language due to Dijkstra , 1980, 21st Annual Symposium on Foundations of Computer Science (sfcs 1980).

[26]  Pamela Zave,et al.  Compositional Network Mobility , 2013, VSTTE.

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

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

[29]  Mary Shaw,et al.  The golden age of software architecture , 2006, IEEE Software.

[30]  Alexander Malkis,et al.  Cartesian abstraction and verification of multithreaded programs , 2010 .

[31]  David Garlan,et al.  A Formal Approach to Software Architectures , 1992, IFIP Congress.

[32]  A. Tarski A LATTICE-THEORETICAL FIXPOINT THEOREM AND ITS APPLICATIONS , 1955 .

[33]  P. Cousot,et al.  Constructive versions of tarski's fixed point theorems , 1979 .

[34]  Patrick Cousot,et al.  Introduction to abstract interpretation , 1998 .

[35]  Andreas Podelski,et al.  Thread-Modular Verification Is Cartesian Abstract Interpretation , 2006, ICTAC.

[36]  Diego Marmsoler,et al.  A Model of Layered Architectures , 2015, FESCA.

[37]  Robert J. Allen A formal approach to software architecture , 1997 .

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

[39]  Richard N. Taylor,et al.  Software architecture: foundations, theory, and practice , 2009, 2010 ACM/IEEE 32nd International Conference on Software Engineering.