Modular specification and checking of structural dependencies

Checking a software's structural dependencies is a line of research on methods and tools for analyzing, modeling and checking the conformance of source code w.r.t. specifications of its intended static structure. Existing approaches have focused on the correctness of the specification, the impact of the approaches on software quality and the expressiveness of the modeling languages. However, large specifications become unmaintainable in the event of evolution without the means to modularize such specifications. We present Vespucci, a novel approach and tool that partitions a specification of the expected and allowed dependencies into a set of cohesive slices. This facilitates modular reasoning and helps individual maintenance of each slice. Our approach is suited for modeling high-level as well as detailed low-level decisions related to the static structure and combines both in a single modeling formalism. To evaluate our approach we conducted an extensive study spanning nine years of the evolution of the architecture of the object-relational mapping framework Hibernate.

[1]  Vineet Sinha,et al.  Using dependency models to manage complex software architecture , 2005, OOPSLA '05.

[2]  Kim Mens,et al.  Co-evolving code and design with intensional views: A case study , 2005, Comput. Lang. Syst. Struct..

[3]  Thomas W. Reps,et al.  Identifying Modules via Concept Analysis , 1999, IEEE Trans. Software Eng..

[4]  Muhammad Ali Babar,et al.  An industrial case study of architecture conformance , 2008, ESEM '08.

[5]  Jens Knodel,et al.  Architecture Compliance Checking - Experiences from Successful Technology Transfer to Industry , 2008, 2008 12th European Conference on Software Maintenance and Reengineering.

[6]  Eric Wohlstadter,et al.  A static aspect language for checking design rules , 2007, AOSD.

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

[8]  Ivica Crnkovic,et al.  Analyzing Software Evolvability , 2008, 2008 32nd Annual IEEE International Computer Software and Applications Conference.

[9]  Michael Eichberg,et al.  Defining and continuous checking of structural program dependencies , 2008, 2008 ACM/IEEE 30th International Conference on Software Engineering.

[10]  Amnon H. Eden,et al.  LePUS3: An Object-Oriented Design Description Language , 2008, Diagrams.

[11]  Marwan Abi-Antoun Static extraction and conformance analysis of hierarchical runtime architectural structure , 2009, OOPSLA 2009.

[12]  Yuanfang Cai,et al.  Detecting software modularity violations , 2011, 2011 33rd International Conference on Software Engineering (ICSE).

[13]  Ivar Jacobson,et al.  Aspect-oriented software development with use cases , 2005, Addison Wesley object technology series.

[14]  Rainer Koschke,et al.  Hierarchical reflexion models , 2003, 10th Working Conference on Reverse Engineering, 2003. WCRE 2003. Proceedings..

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

[16]  Jens Knodel,et al.  Static evaluation of software architectures , 2006, Conference on Software Maintenance and Reengineering (CSMR'06).

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

[18]  Christian Bauer,et al.  Hibernate in action , 2005 .

[19]  Michael W. Godfrey,et al.  Secrets from the Monster: Extracting Mozilla’s Software Architecture , 2000 .

[20]  Bradley R. Schmerl,et al.  Evolution styles: Foundations and tool support for software architecture evolution , 2009, 2009 Joint Working IEEE/IFIP Conference on Software Architecture & European Conference on Software Architecture.

[21]  Dharini Balasubramaniam,et al.  Controlling software architecture erosion: A survey , 2012, J. Syst. Softw..

[22]  Ricardo Terra,et al.  A dependency constraint language to manage object-oriented software architectures , 2009 .

[23]  HERBERT A. SIMON,et al.  The Architecture of Complexity , 1991 .

[24]  Sebastian Herold,et al.  Checking architectural compliance in component-based systems , 2010, SAC '10.

[25]  Michael Eichberg,et al.  Automatic Incrementalization of Prolog Based Static Analyses , 2007, PADL.

[26]  H. James Hoover,et al.  Using SCL to specify and check design intent in source code , 2006, IEEE Transactions on Software Engineering.

[27]  Mikio Aoyama,et al.  Metrics and analysis of software architecture evolution with discontinuity , 2002, IWPSE '02.

[28]  David Notkin,et al.  Software reflexion models: bridging the gap between source and high-level models , 1995, SIGSOFT FSE.

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

[30]  Audris Mockus,et al.  Does Code Decay? Assessing the Evidence from Change Management Data , 2001, IEEE Trans. Software Eng..

[31]  Torbjörn Ekman,et al.  .QL: Object-Oriented Queries Made Easy , 2007, GTTSE.