Towards Design-by-Contract based software architecture design

Design-by-Contract (DbC) gained wide familiarity among software developers for specifying software. It aids in documenting the behaviour of class methods as contracts between clients of the methods (pre-) and their suppliers (post-condition). This not only allows developers to document software behaviour precisely at such a high-level that can more easily be communicated, but also enables the formal verification of the behaviour. In this paper, we provide a comprehensive extension to DbC so that it can also be applied to the level of software architecture design. We illustrate this through our architecture description language XCD. Components in XCD have four different types of interfaces: provided and required interfaces of methods or emitter and consumer interfaces of events where methods/events are contractually specified. Contract specification is separated into functional and interaction contracts thus modularising the functional and interaction component behaviours. Furthermore, treating interaction protocols as connectors, XCD allows to specify connectors with interaction contracts that participating components adhere to. The formal semantics of XCD are defined using Finite State Process (FSP) thus enabling formal analysis of contractually specified software architectures for quality properties, e.g., deadlock.

[1]  Corina S. Păsăreanu.  Formal Aspects of Component Software : 9th International Symposium, FACS 2012, Mountain View, CA, USA, September 12-14, 2012. Revised Selected Papers , 2013 .

[2]  Ashish B. Shah,et al.  Common Object Request Broker Architecture (CORBA) , 2015 .

[3]  Laurie A. Williams,et al.  Assessing test-driven development at IBM , 2003, 25th International Conference on Software Engineering, 2003. Proceedings..

[4]  Gary T. Leavens,et al.  Beyond Assertions: Advanced Specification and Verification with JML and ESC/Java2 , 2005, FMCO.

[5]  Jeff Magee,et al.  Concurrency - state models and Java programs (2. ed.) , 2006 .

[6]  Jeff Magee,et al.  The Koala Component Model for Consumer Electronics Software , 2000, Computer.

[7]  Dimitra Giannakopoulou,et al.  Analysing the behaviour of distributed software architectures: a case study , 1997, Proceedings of the Sixth IEEE Computer Society Workshop on Future Trends of Distributed Computing Systems.

[8]  Bertrand Meyer,et al.  Applying 'design by contract' , 1992, Computer.

[9]  Keira.  Common Object Request Broker Architecture (CORBA) , 2015 .

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

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

[12]  Alexandre Sztajnberg,et al.  Towards a Rewriting Semantics for a Software Architecture Description Language , 2004, Electron. Notes Theor. Comput. Sci..

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

[14]  Michael D. Ernst,et al.  An overview of JML tools and applications , 2003, Electron. Notes Theor. Comput. Sci..

[15]  David S. Janzen,et al.  Test-driven development concepts, taxonomy, and future direction , 2005, Computer.

[16]  Elsevier Open Archive.  A Calculus of Mobile Processes, I , 2015 .

[17]  Ralf H. Reussner,et al.  Reasoning about Software Architectures with Contractually Specified Components , 2003, Component-Based Software Quality.

[18]  C. A. R. HOARE,et al.  An axiomatic basis for computer programming , 1969, CACM.

[19]  Gary T. Leavens,et al.  A Simple and Practical Approach to Unit Testing: The JML and JUnit Way , 2002, ECOOP.

[20]  Yérom-David Bromberg,et al.  Middleware-Layer Connector Synthesis: Beyond State of the Art in Middleware Interoperability , 2011, SFM.

[21]  Gerard Florin,et al.  Design by Contract: analysis of hidden dependencies in component based application , 2004, J. Object Technol..

[22]  MeyerBertrand,et al.  Design by Contract , 1997 .

[23]  Jifeng He,et al.  Contract Oriented Development of Component Software , 2004, IFIP TCS.

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

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

[26]  Ralf H. Reussner,et al.  Trust-by-Contract: Modelling, Analysing and Predicting Behaviour of Software Architectures , 2001, Trans. SDPS.

[27]  Marco Tulio Valente,et al.  A gentle introduction to OSGi , 2008, SOEN.

[28]  Jean-Marc Jézéquel,et al.  Making Components Contract Aware , 1999, Computer.

[29]  Karl M. Göschka,et al.  Explicit Connectors in Component Based Software Engineering for Distributed Embedded Systems , 2007, SOFSEM.

[30]  Michael D. Ernst,et al.  An overview of JML tools and applications , 2003, International Journal on Software Tools for Technology Transfer.

[31]  Bertrand Meyer,et al.  EIFFEL: Object-Oriented Design for Software Engineering , 1987, ESEC.

[32]  Henry Muccini,et al.  What Industry Needs from Architectural Languages: A Survey , 2013, IEEE Transactions on Software Engineering.

[33]  Alessandro Aldini,et al.  A Process Algebraic Approach to Software Architecture Design , 2009 .

[34]  Christos Kloukinas,et al.  Xcd - Modular, Realizable Software Architectures , 2012, FACS.

[35]  Jeff Magee,et al.  Dynamic structure in software architectures , 1996, SIGSOFT '96.

[36]  Frantisek Plasil,et al.  Behavior Protocols for Software Components , 2002, IEEE Trans. Software Eng..

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

[38]  José Luiz Fiadeiro,et al.  Interconnecting Objects Via Contracts , 1999, UML.

[39]  Dines Bjørner,et al.  The Vienna Development Method: The Meta-Language , 1978, Lecture Notes in Computer Science.