Modularity analysis of use case implementations

A component-based decomposition can result in implementations having use cases code tangled with other concerns and scattered across components. Modularity mechanisms such as aspects, mixins, and virtual classes have been proposed to address this kind of problem. One can use such mechanisms to group together code related to a single use case. This paper quantitatively analyzes the impact of this kind of use case modularization. We apply one specific technique, aspect oriented programming, to modularize the use case implementations of two information systems that conform to the layered architecture pattern. We extract traditional and contemporary metrics - including cohesion, coupling, and separation of concerns - to analyze modularity in terms of quality attributes such as changeability, support for independent development, and pluggability. Our findings indicate that the results of a given modularity analysis depend on other factors beyond the chosen system, metrics, and the applied modularity technique.

[1]  Chris F. Kemerer,et al.  A Metrics Suite for Object Oriented Design , 2015, IEEE Trans. Software Eng..

[2]  Carlos José Pereira de Lucena,et al.  Modularizing design patterns with aspects: a quantitative study , 2005, AOSD '05.

[3]  Klaus Schmid,et al.  Software product lines in action - the best industrial practice in product line engineering , 2007 .

[4]  Gary T. Leavens,et al.  Ptolemy: A Language with Quantified, Typed Events , 2008, ECOOP.

[5]  Alfred V. Aho,et al.  Do Crosscutting Concerns Cause Defects? , 2008, IEEE Transactions on Software Engineering.

[6]  Peter Sommerlad,et al.  Pattern-Oriented Software Architecture Volume 1: A System of Patterns , 1996 .

[7]  William G. Griswold,et al.  An Overview of AspectJ , 2001, ECOOP.

[8]  Cláudio Sant'Anna,et al.  On the Impact of Aspectual Decompositions on Design Stability: An Empirical Study , 2007, ECOOP.

[9]  H. D. Rombach,et al.  The Goal Question Metric Approach , 1994 .

[10]  Stephan Herrmann,et al.  Object Teams: Improving Modularity for Crosscutting Collaborations , 2002, NetObjectDays.

[11]  Peter Sommerlad,et al.  Pattern-Oriented Software Architecture: A System of Patterns: John Wiley & Sons , 1987 .

[12]  G.C. Murphy,et al.  Identifying, Assigning, and Quantifying Crosscutting Concerns , 2007, First International Workshop on Assessment of Contemporary Modularization Techniques (ACoM '07).

[13]  Sven Apel,et al.  How AspectJ is Used: An Analysis of Eleven AspectJ Programs , 2010, J. Object Technol..

[14]  Stephan Herrmann,et al.  Mapping Use Case Level Aspects to ObjectTeams/Java , 2004 .

[15]  Paulo Borba,et al.  Distribution and persistence as aspects , 2006 .

[16]  Carlos José Pereira de Lucena,et al.  Quantifying the Effects of Aspect-Oriented Programming: A Maintenance Study , 2006, 2006 22nd IEEE International Conference on Software Maintenance.

[17]  Cecília M. F. Rubira,et al.  Exceptions and aspects: the devil is in the details , 2006, SIGSOFT '06/FSE-14.

[18]  Carlos José Pereira de Lucena,et al.  On the Reuse and Maintenance of Aspect-Oriented Software: An Assessment Framework , 2003, SBES.

[19]  Stephen N. Zilles,et al.  Programming with abstract data types , 1974 .

[20]  Sérgio Soares,et al.  Implementing distribution and persistence aspects with aspectJ , 2002, OOPSLA '02.

[21]  Ivar Jacobson,et al.  Use Cases and Aspects-Working Seamlessly Together , 2003, J. Object Technol..

[22]  Jonathan Aldrich,et al.  Open Modules: Modular Reasoning About Advice , 2005, ECOOP.

[23]  Sven Apel,et al.  Types and modularity for implicit invocation with implicit announcement , 2010, TSEM.

[24]  簡聰富,et al.  物件導向軟體之架構(Object-Oriented Software Construction)探討 , 1989 .

[25]  Edsger W. Dijkstra,et al.  Notes on structured programming , 1970 .

[26]  George T. Heineman,et al.  Component-Based Software Engineering: Putting the Pieces Together , 2001 .

[27]  Gregor Kiczales,et al.  Aspect-oriented programming , 1996, CSUR.

[28]  Matthias Felleisen,et al.  Classes and mixins , 1998, POPL '98.

[29]  Mira Mezini,et al.  An Overview of CaesarJ , 2006, LNCS Trans. Aspect Oriented Softw. Dev..

[30]  Ivica Crnkovic,et al.  Building Reliable Component-Based Software Systems , 2002 .

[31]  Ruzanna Chitchyan,et al.  Persistence as an aspect , 2003, AOSD '03.

[32]  David Lorge Parnas,et al.  The Modular Structure of Complex Systems , 1984, IEEE Transactions on Software Engineering.