Design Rule Hierarchy and Analytical Decision Model Transformation

We present two contributions to help make design rule theory operable in software engineering practice. First, we develop an approach to automatically transform a design, expressed in the prevailing unified modeling language, into an augmented constraint network (ACN), from which a design structure matrix (DSM) can be generated. Using ACNs formalizes design rule theory and using DSMS enables option-based reasoning. Second, we design an algorithm to derive a design rule hierarchy from an ACN, revealing the impact scope of each design rule and identifying the independent modules. This hierarchy defines an order in which decisions can be made to maximize task parallelism, constrained by the dependency structure of the architecture. We evaluate the accuracy and scalability of our approaches using both small, but canonical, systems and the open-source Apache Ant system.

[1]  Yuanfang Cai,et al.  Modularity in design: formal modeling and automated analysis , 2006 .

[2]  Daniel Jackson,et al.  Alloy: a lightweight object modelling notation , 2002, TSEM.

[3]  Daniel Jackson,et al.  Using dependency models to manage software architecture , 2005, OOPSLA '05.

[4]  Yuanfang Cai,et al.  Automatic Transformation of UML Models into Analytical Decision Models , 2008 .

[5]  Pankaj Jalote,et al.  Assigning tasks in a 24-hour software development model , 2004, 11th Asia-Pacific Software Engineering Conference.

[6]  Spiros Mancoridis,et al.  On the automatic modularization of software systems using the Bunch tool , 2006, IEEE Transactions on Software Engineering.

[7]  Alexander Sverdlov Review of David L. Parnas' "Designing Software for Ease of Extension and Contraction" , 2004 .

[8]  David Lorge Parnas,et al.  Review of David L. Parnas' "Designing Software for Ease of Extension and Contraction" , 2004 .

[9]  Sushil Krishna Bajracharya,et al.  An analysis of modularity in aspect oriented design , 2005, AOSD '05.

[10]  Kim B. Clark,et al.  The power of modularity , 2000 .

[11]  Carlo Ghezzi,et al.  A Unified High-Level Petri Net Formalism for Time-Critical Systems , 1991, IEEE Trans. Software Eng..

[12]  Ralph Johnson,et al.  design patterns elements of reusable object oriented software , 2019 .

[13]  Indrakshi Ray,et al.  UML2Alloy: a challenging model transformation , 2007, MODELS'07.

[14]  J. Michael Spivey,et al.  The Z notation - a reference manual , 1992, Prentice Hall International Series in Computer Science.

[15]  Yuanfang Cai,et al.  Assessing Design Modularity and Stability using Analytical Decision Models , 2008 .

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

[17]  D. L. Parnas,et al.  On the criteria to be used in decomposing systems into modules , 1972, Software Pioneers.

[18]  Steven D. Eppinger,et al.  Model-based Approaches to Managing Concurrent Engineering , 1991 .

[19]  Xiaogang Wang,et al.  Multiple layer clustering of large software systems , 2005, 12th Working Conference on Reverse Engineering (WCRE'05).

[20]  D. V. Steward,et al.  The design structure system: A method for managing the design of complex systems , 1981, IEEE Transactions on Engineering Management.

[21]  Edsger W. Dijkstra,et al.  The structure of the “THE”-multiprogramming system , 1968, CACM.

[22]  Alan MacCormack,et al.  Exploring the Structure of Complex Software Designs: An Empirical Study of Open Source and Proprietary Code , 2006, Manag. Sci..

[23]  Tao Xie,et al.  A framework and tool supports for testing modularity of software design , 2007, ASE.

[24]  Kun Wang,et al.  Maintaining Life Perspectives During the Refinement of UML Class Structures , 2005, FASE.

[25]  Edsger W. Dijkstra,et al.  The structure of the “THE”-multiprogramming system , 1967, CACM.

[26]  Luciano Baresi,et al.  From Graph Transformation to Software Engineering and Back , 2005, Formal Methods in Software and Systems Modeling.

[27]  Bernhard Rumpe,et al.  The UML as a formal modeling notation , 1998, Comput. Stand. Interfaces.

[28]  Luciano Baresi,et al.  On Formalizing UML with High-Level Petri Nets , 2001, Concurrent Object-Oriented Programming and Petri Nets.

[29]  Yuanfang Cai,et al.  Analyzing the Evolution of Large-Scale Software Systems Using Design Structure Matrices and Design Rule Theory: Two Exploratory Cases , 2008, Seventh Working IEEE/IFIP Conference on Software Architecture (WICSA 2008).

[30]  Yuanfang Cai,et al.  Modularity Analysis of Logical Design Models , 2006, 21st IEEE/ACM International Conference on Automated Software Engineering (ASE'06).