Heterogeneous view integration and its automation

Software systems are characterized by unprecedented complexity. One effective means of dealing with that complexity is to consider a system from a particular perspective, or view (e.g., architecture or design diagram). Views enable software developers to reduce the amount of information they have to deal with at any given time. They enable this by utilizing a divide-and-conquer strategy that allows large-scale software development problems to be broken up into smaller, more comprehensible pieces. Individual development issues can then be evaluated without the need of access to the whole body of knowledge about a given software system. The major drawback of views is that development concerns cannot truly be investigated by themselves, since concerns tend to affect one another. Successful and precise product development supported via multiple views requires that common assumptions and definitions are recognized and maintained in a consistent fashion. In other words, having views with inconsistent assumptions about a system's expected environment reduces their usefulness and possibly renders invalid solutions based on them. Developing software systems therefore requires more than what general-purpose software development models can provide today. Development is about modeling, solving, and interpreting, and in doing so a major emphasis is placed on mismatch identification and reconciliation within and among diagrammatic and textual views. Our work introduces a view integration framework and demonstrates how its activities enable view comparison in a more scalable and reliable fashion. Our framework extends the comparison activity with mapping and transformation to define the ‘what’ and the ‘how’ of view integration. We will demonstrate the use of our framework on the Unified Modeling Language (UML), which has become a de-facto standard for object-oriented software development. In this context we will describe causes of model inconsistencies among UML views, and show how integration techniques can be applied to identify and resolve them in a more automated fashion. Our framework is tool supported.

[1]  Sergio J. Alvarado An Evaluation of Object-Oriented Architecture Models for Satellite Ground Systems , 1998 .

[2]  David Harel,et al.  Statecharts: A Visual Formalism for Complex Systems , 1987, Sci. Comput. Program..

[3]  Bashar Nuseibeh,et al.  Analysing inconsistent specifications , 1997, Proceedings of ISRE '97: 3rd IEEE International Symposium on Requirements Engineering.

[4]  Bran Selic,et al.  Using UML for Modeling Complex Real-Time Systems , 1998, LCTES.

[5]  William E. Lorensen,et al.  Object-Oriented Modeling and Design , 1991, TOOLS.

[6]  G. P. Mullery,et al.  CORE - a method for controlled requirement specification , 1979, ICSE 1979.

[7]  Edward Yourdon,et al.  Object-oriented design , 1991, Yourdon Press Computing Series.

[8]  Barry W. Boehm,et al.  Theory-W Software Project Management: Principles and Examples , 1989, IEEE Trans. Software Eng..

[9]  Nenad Medvidovic,et al.  Assessing the Suitability of a Standard Design Method for Modeling Software Architectures , 1999, WICSA.

[10]  W. W. Royce,et al.  Managing the development of large software systems: concepts and techniques , 1987, ICSE '87.

[11]  Douglas T. Ross,et al.  Structured Analysis for Requirements Definition , 1977, IEEE Transactions on Software Engineering.

[12]  John Grundy,et al.  Supporting flexible consistency management via discrete change description propagation , 1996 .

[13]  Grady Booch,et al.  Object Solutions: Managing the Object-Oriented Project , 1995 .

[14]  Merriam-Webster Merriam-Webster's Collegiate Dictionary , 1998 .

[15]  Andy Carmichael Object Development Methods , 1994 .

[16]  Stephen J. Mellor,et al.  Object Oriented Systems Analysis: Modeling the World in Data , 1988 .

[17]  Pete Sawyer,et al.  Requirements Engineering: A Good Practice Guide , 1997 .

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

[19]  Nenad Medvidovic,et al.  A Formal Approach to Heterogeneous Software Modeling , 2000, FASE.

[20]  Nenad Medvidovic,et al.  Extending Architectural Representation in UML with View Integration , 1999, UML.

[21]  Ivar Jacobson,et al.  The Unified Software Development Process , 1999 .

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

[23]  Harry S. Delugach,et al.  An approach to conceptual feedback in multiple viewed software requirements modeling , 1996, ISAW '96.

[24]  Barry W. Boehm,et al.  Using the WinWin Spiral Model: A Case Study , 1998, Computer.

[25]  J. S. McGregor Object-Oriented Software Development , 1992 .

[26]  Michael L. Begeman,et al.  gIBIS: a hypertext tool for exploratory policy discussion , 1988, CSCW '88.

[27]  Stephen Fickas,et al.  Goal-directed concept acquisition in requirements elicitation , 1991, Proceedings of the Sixth International Workshop on Software Specification and Design.

[28]  Barry Boehm,et al.  Software Lifecycle Connectors: Bridging Models across the Lifecycle , 2001 .

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

[30]  Barry Boehm,et al.  Composing heterogeneous software architectures , 1996 .

[31]  Michael E. Fagan Advances in software inspections , 1986, IEEE Transactions on Software Engineering.

[32]  Steve M. Easterbrook,et al.  Using ViewPoints for inconsistency management , 1996, Softw. Eng. J..

[33]  Ismaïl Khriss,et al.  Automating the Synthesis of UML StateChart Diagrams from Multiple Collaboration Diagrams , 1998, UML.

[34]  Richard N. Taylor,et al.  A language and environment for architecture-based software development and evolution , 1999, Proceedings of the 1999 International Conference on Software Engineering (IEEE Cat. No.99CB37002).

[35]  L. R. Gieszl Traceability for integration , 1992, Proceedings of the Second International Conference on Systems Integration.

[36]  David C. Luckham,et al.  An Event-Based Architecture Definition Language , 1995, IEEE Trans. Software Eng..

[37]  Leon J. Osterweil,et al.  Toward objective, systematic design-method comparisons , 1992, IEEE Software.

[38]  Bashar Nuseibeh,et al.  Towards a framework for managing inconsistency between multiple views , 1996, ISAW '96.

[39]  Robert A. Riemenschneider,et al.  Checking the Correctness of Architectural Transformation Steps via Proof-Carrying Architectures , 1999, WICSA.

[40]  David Garlan,et al.  Acme: an architecture description interchange language , 1997, CASCON.

[41]  Ivar Jacobson,et al.  The unified modeling language reference manual , 2010 .

[42]  Ivar Jacobson,et al.  The Unified Modeling Language User Guide , 1998, J. Database Manag..

[43]  Richard N. Taylor,et al.  A Component- and Message-Based Architectural Style for GUI Software , 1995, 1995 17th International Conference on Software Engineering.

[44]  Barry W. Boehm,et al.  Verifying and Validating Software Requirements and Design Specifications , 1989, IEEE Software.

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

[46]  Peter P. Chen The Entity-Relationship Model: Towards a unified view of Data , 1976 .

[47]  Philippe Kruchten,et al.  Rose/Architect: a tool to visualize architecture , 1999, Proceedings of the 32nd Annual Hawaii International Conference on Systems Sciences. 1999. HICSS-32. Abstracts and CD-ROM of Full Papers.

[48]  Bashar Nuseibeh,et al.  Managing inconsistent specifications: reasoning, analysis, and action , 1998, TSEM.

[49]  Barry Boehm,et al.  Detecting architectural mismatches during systems composition , 1998 .

[50]  Ken Orr,et al.  Structured requirements definition , 1981 .

[51]  Peter P. Chen The entity-relationship model: toward a unified view of data , 1975, VLDB '75.

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

[53]  Rebecca Wirfs-Brock,et al.  Designing object-oriented software , 1990 .

[54]  Dov M. Gabbay,et al.  Inconsistency Handling in Multperspective Specifications , 1994, IEEE Trans. Software Eng..

[55]  Frederick P. Brooks,et al.  No Silver Bullet: Essence and Accidents of Software Engineering , 1987 .

[56]  David S. Wile AML: an Architecture Meta-Language , 1999, 14th IEEE International Conference on Automated Software Engineering.

[57]  Rich Hilliard Views and Viewpoints in Software Systems Architecture , 2000 .

[58]  Nenad Medvidovic,et al.  Integrating architecture description languages with a standard design method , 1998, Proceedings of the 20th International Conference on Software Engineering.

[59]  Stephen J. Mellor,et al.  Object lifecycles: modeling the world in states , 1992 .

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

[61]  Tom DeMarco,et al.  Structured Analysis and System Specification (Reprint) , 2002, Software Pioneers.

[62]  Barry Boehm,et al.  Optimizing software product integrity through life-cycle process integration , 1999 .

[63]  Nenad Medvidovic,et al.  Round-Trip Software Engineering Using UML: From Architecture to Design and Back , 1999 .

[64]  Bran Selic,et al.  Real-time object-oriented modeling , 1994, Wiley professional computing.

[65]  Betty H. C. Cheng,et al.  Formalizing and Integrating the Dynamic Model within OMT , 1997, Proceedings of the (19th) International Conference on Software Engineering.

[66]  Sarah A. Sheard,et al.  2.5.1 Systems Engineering Standards and Models Compared , 1998 .

[67]  S. B. Kiselev,et al.  The capability maturity model: guidelines for improving the software process , 1995 .

[68]  John Grundy,et al.  Static and Dynamic Visualisation of Software Architectures for Component-based Systems , 1998 .

[69]  Geoff Cutts,et al.  Structured systems analysis and design methodology , 1988 .

[70]  Alexander Egyed,et al.  Automatically detecting mismatches during component-based and model-based development , 1999, 14th IEEE International Conference on Automated Software Engineering.

[71]  Edward Yourdon,et al.  Object-oriented analysis , 2012 .

[72]  Ismaïl Khriss,et al.  Algorithmic support for model transformation in object‐oriented software development , 2001, Concurr. Comput. Pract. Exp..

[73]  Alexander Egyed,et al.  Architectural Integration and Evolution in a Model World , 2000 .

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

[75]  Stefan Sigfried Understanding object-oriented software engineering , 1996, Understanding science and technology series.

[76]  Andrew P. Sage,et al.  Systems integration and architecting: An overview of principles, practices, and perspectives , 1998 .

[77]  Reiko Heckel,et al.  A Combined Reference Model- and View-Based Approach to System Specification , 1997, Int. J. Softw. Eng. Knowl. Eng..

[78]  Nenad Medvidovic,et al.  Software Connectors and Refinement in Family Architectures , 2000, IW-SAPF.

[79]  Khaled Narayanaswamy,et al.  “Lazy” consistency: a basis for cooperative software development , 1992, CSCW '92.

[80]  Bashar Nuseibeh,et al.  Viewpoints: A Framework for Integrating Multiple Perspectives in System Development , 1992, Int. J. Softw. Eng. Knowl. Eng..

[81]  Barry W. Boehm,et al.  A spiral model of software development and enhancement , 1986, Computer.

[82]  W. T. Farris,et al.  Software requirements specifications , 1993 .

[83]  Gunnar Overgaard A Formal Approach to Relationships in the Unified Modeling Language , 1998 .

[84]  Grady Booch,et al.  Object-Oriented Analysis and Design with Applications , 1990 .

[85]  Ivar Jacobson,et al.  Object-oriented software engineering - a use case driven approach , 1993, TOOLS.

[86]  Stanley M. Sutton,et al.  N degrees of separation: multi-dimensional separation of concerns , 1999, Proceedings of the 1999 International Conference on Software Engineering (IEEE Cat. No.99CB37002).

[87]  Kendall Scott,et al.  UML distilled - applying the standard object modeling language , 1997 .

[88]  Robert L. Nord,et al.  Describing Software Architecture with UML , 1999, WICSA.

[89]  Bashar Nuseibeh,et al.  Computer-Aided Inconsistency Management in Software Development , 1999 .

[90]  Fred P. Brooks,et al.  The Mythical Man-Month , 1975, Reliable Software.

[91]  Bashar Nuseibeh,et al.  Expressing the relationships between multiple views in requirements specification , 1993, ICSE '93.

[92]  Watts S. Humphrey,et al.  A discipline for software engineering , 2012, Series in software engineering.

[93]  Douglas T. Ross,et al.  Structured Analysis (SA): A Language for Communicating Ideas , 1977, IEEE Transactions on Software Engineering.

[94]  M. Jackson,et al.  Some complexities in computerbased systems and their implications for system development , 1990, COMPEURO'90: Proceedings of the 1990 IEEE International Conference on Computer Systems and Software Engineering@m_Systems Engineering Aspects of Complex Computerized Systems.

[95]  Bashar Nuseibeh,et al.  To be and not to be: on managing inconsistency in software development , 1996, Proceedings of the 8th International Workshop on Software Specification and Design.

[96]  Bashar Nuseibeh,et al.  A Multi-Perspective Framework for Method Integration , 2001 .

[97]  John C. Grundy,et al.  Support for constructing environments with multiple views , 1996, ISAW '96.

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

[99]  Robert Balzer,et al.  Tolerating Inconsistency , 1991, [1989] Proceedings of the 5th International Software Process Workshop.

[100]  Barry W. Boehm,et al.  Anchoring the Software Process , 1996, IEEE Softw..

[101]  Julie Johnson What is the Rational Unified Process ? , 1999 .

[102]  A. A. Abd Allah Composing heterogeneous software architectures , 1996 .

[103]  Erran Carmel,et al.  PD and joint application design: a transatlantic comparison , 1993, CACM.

[104]  Galal H. Galal-Edeen,et al.  Requirements engineering: A good practice , 2000, Eur. J. Inf. Syst..

[105]  Nenad Medvidovic,et al.  Enabling the Refinement of a Software Architecture into a Design , 1999, UML.

[106]  Barry W. Boehm,et al.  Software Engineering Economics , 1993, IEEE Transactions on Software Engineering.

[107]  Suzanne Robertson,et al.  Mastering the Requirements Process , 1999 .

[108]  Dov M. Gabbay,et al.  Inconsistency Handling in Multi-Perspective Specifications , 1993, ESEC.

[109]  Karl E. Wiegers,et al.  Software Requirements , 1999 .