Representing concerns in source code

A software modification task often addresses several concerns. A concern is anything a stakeholder may want to consider as a conceptual unit, including features, nonfunctional requirements, and design idioms. In many cases, the source code implementing a concern is not encapsulated in a single programming language module, and is instead scattered and tangled throughout a system. Inadequate separation of concerns increases the difficulty of evolving software in a correct and cost-effective manner. To make it easier to modify concerns that are not well modularized, we propose an approach in which the implementation of concerns is documented in artifacts, called concern graphs. Concern graphs are abstract models that describe which parts of the source code are relevant to different concerns. We present a formal model for concern graphs and the tool support we developed to enable software developers to create and use concern graphs during software evolution tasks. We report on five empirical studies, providing evidence that concern graphs support views and operations that facilitate the task of modifying the code implementing scattered concerns, are cost-effective to create and use, and robust enough to be used with different versions of a software system.

[1]  Bjørn N. Freeman-Benson,et al.  Visualizing dynamic software system information through high-level models , 1998, OOPSLA '98.

[2]  Mark Chu-Carroll,et al.  Supporting aggregation in fine grained software configuration management , 2002, SIGSOFT '02/FSE-10.

[3]  Gunther Schmidt,et al.  Relations and Graphs: Discrete Mathematics for Computer Scientists , 1993 .

[4]  Martin P. Robillard,et al.  Automatically inferring concern code from program investigation activities , 2003, 18th IEEE International Conference on Automated Software Engineering, 2003. Proceedings..

[5]  R. Stallman EMACS the extensible, customizable self-documenting display editor , 1981, SIGPLAN SIGOA Symposium on Text Manipulation.

[6]  Lori Pollock,et al.  Testing with Respect to Concerns , 2003 .

[7]  Carl F. Schaefer,et al.  Static analysis of exception handling in Ada , 1993, Softw. Pract. Exp..

[8]  Tibor Gyimóthy,et al.  An efficient relevant slicing method for debugging , 1999, ESEC/FSE-7.

[9]  Daniel Jackson,et al.  A new model of program dependences for reverse engineering , 1994, SIGSOFT '94.

[10]  Martin P. Robillard,et al.  Static analysis to support the evolution of exception structure in object-oriented systems , 2003, TSEM.

[11]  Barry W. Boehm,et al.  Quantitative evaluation of software quality , 1976, ICSE '76.

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

[13]  Darrel C. Ince,et al.  An introduction to discrete mathematics , 1988 .

[14]  Wei Zhao,et al.  SNIAFL: towards a static non-interactive approach to feature location , 2004, Proceedings. 26th International Conference on Software Engineering.

[15]  Keith Brian Gallagher,et al.  Visual impact analysis , 1996, 1996 Proceedings of International Conference on Software Maintenance.

[16]  S Letovsky,et al.  Strategies for documenting delocalized plans , 1986 .

[17]  Kent L. Beck,et al.  Embracing Change with Extreme Programming , 1999, Computer.

[18]  Swapna S. Gokhale,et al.  Locating program features using execution slices , 1999, Proceedings 1999 IEEE Symposium on Application-Specific Systems and Software Engineering and Technology. ASSET'99 (Cat. No.PR00122).

[19]  Jong-Deok Choi,et al.  Slicing class hierarchies in C++ , 1996, OOPSLA '96.

[20]  Ted J. Biggerstaff,et al.  Program understanding and the concept assignment problem , 1994, CACM.

[21]  Steven P. Reiss,et al.  Support for Maintaining Object-Oriented Programs , 1992, IEEE Trans. Software Eng..

[22]  David Grove,et al.  Optimization of Object-Oriented Programs Using Static Class Hierarchy Analysis , 1995, ECOOP.

[23]  Karl J. Ottenstein,et al.  The program dependence graph in a software development environment , 1984 .

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

[25]  Giuliano Antoniol,et al.  Variable precision reaching definitions analysis for software maintenance , 1997, Proceedings. First Euromicro Conference on Software Maintenance and Reengineering.

[26]  Anthony Finkelstein,et al.  A Foolish Consistency: Technical Challenges in Consistency Management , 2000, DEXA.

[27]  Jason E. Robbins,et al.  Argo: A Design Environment for Evolving Software Architectures , 1997, Proceedings of the (19th) International Conference on Software Engineering.

[28]  Cristina V. Lopes,et al.  Aspect-oriented programming , 1999, ECOOP Workshops.

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

[30]  Thomas W. Reps,et al.  The use of program dependence graphs in software engineering , 1992, International Conference on Software Engineering.

[31]  Meir M. Lehman,et al.  A Model of Large Program Development , 1976, IBM Syst. J..

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

[33]  Elliot Soloway,et al.  Designing documentation to compensate for delocalized plans , 1988, CACM.

[34]  David Eichmann,et al.  Program and interface slicing for reverse engineering , 1993, [1993] Proceedings Working Conference on Reverse Engineering.

[35]  Mark Weiser,et al.  Programmers use slices when debugging , 1982, CACM.

[36]  A. J. Hoane,et al.  Design and Analysis in Software Engineering Part 1 : The Language of Case Studies and Formal Experiments , 2004 .

[37]  Mark Weiser,et al.  Program Slicing , 1981, IEEE Transactions on Software Engineering.

[38]  Stanley M. Sutton,et al.  Modeling of software concerns in Cosmos , 2002, AOSD '02.

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

[40]  Janice Singer Practices of software maintenance , 1998, Proceedings. International Conference on Software Maintenance (Cat. No. 98CB36272).

[41]  H. Ossher,et al.  Concern modeling in the concern manipulation environment , 2005, MACS@ICSE.

[42]  William G. Griswold,et al.  Design Recommendations for Concern Elaboration Tools , 2005 .

[43]  David F. Bacon,et al.  Fast and effective optimization of statically typed object-oriented languages , 1997 .

[44]  Joseph Robert Horgan,et al.  Dynamic program slicing , 1990, PLDI '90.

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

[46]  J.A. Gomez,et al.  Locating user functionality in old code , 1992, Proceedings Conference on Software Maintenance 1992.

[47]  Rainer Koschke,et al.  Derivation of feature component maps by means of concept analysis , 2001, Proceedings Fifth European Conference on Software Maintenance and Reengineering.

[48]  Stanley M. Sutton,et al.  Hyper/J™: multi-dimensional separation of concerns for Java™ , 2001, ICSE '02.

[49]  Keith Brian Gallagher,et al.  Improving visual impact analysis , 1998, Proceedings. International Conference on Software Maintenance (Cat. No. 98CB36272).

[50]  Norman Wilde,et al.  TraceGraph: immediate visual location of software features , 2000, Proceedings 2000 International Conference on Software Maintenance.

[51]  Harold Ossher,et al.  Multi-Dimensional Separation of Concerns and the Hyperspace Approach , 2002 .

[52]  Magne Jørgensen,et al.  Can you Trust a Single Data Source Exploratory Software Engineering Case Study? , 2002, Empirical Software Engineering.

[53]  Amir Michail Browsing and searching source code of applications written using a GUI framework , 2002, ICSE '02.

[54]  Martin P. Robillard,et al.  How effective developers investigate source code: an exploratory study , 2004, IEEE Transactions on Software Engineering.

[55]  Gregor Snelting,et al.  Concept analysis—a new framework for program understanding , 1998, PASTE '98.

[56]  Alfred V. Aho,et al.  Pattern Matching in Strings , 1980 .

[57]  Rainer Koschke,et al.  Locating Features in Source Code , 2003, IEEE Trans. Software Eng..

[58]  Anthony Finkelsteiin A Foolish Consistency: Technical Challenges in Consistency Management , 2000 .

[59]  Martin L. Griss,et al.  Implementing Product-Line Features with Component Reuse , 2000, ICSR.

[60]  Walter F. Tichy,et al.  Rcs — a system for version control , 1985, Softw. Pract. Exp..

[61]  C. M. Sperberg-McQueen,et al.  eXtensible Markup Language (XML) 1.0 (Second Edition) , 2000 .

[62]  P RobillardMartin,et al.  Representing concerns in source code , 2007 .

[63]  C. V. Ramamoorthy,et al.  The C Information Abstraction System , 1990, IEEE Trans. Software Eng..

[64]  Martin P. Robillard,et al.  Analyzing exception flow in Java programs , 1999, ESEC/FSE-7.

[65]  Martin P. Robillard,et al.  A Study of Program Evolution Involving Scattered Concerns , 2003 .

[66]  James H. Cross,et al.  Reverse engineering and design recovery: a taxonomy , 1990, IEEE Software.

[67]  William G. Griswold,et al.  Exploiting the map metaphor in a tool for software evolution , 2001, Proceedings of the 23rd International Conference on Software Engineering. ICSE 2001.

[68]  Gail C. Murphy,et al.  Conceptual module querying for software reengineering , 1998, Proceedings of the 20th International Conference on Software Engineering.

[69]  Donglin Liang,et al.  Slicing objects using system dependence graphs , 1998, Proceedings. International Conference on Software Maintenance (Cat. No. 98CB36272).

[70]  Jay Earley,et al.  An efficient context-free parsing algorithm , 1970, Commun. ACM.

[71]  Doron A. Peled,et al.  Software Reliability Methods , 2001, Texts in Computer Science.

[72]  Meir M. Lehman,et al.  Program evolution: processes of software change , 1985 .

[73]  Jan Bosch,et al.  Design erosion: problems and causes , 2002, J. Syst. Softw..

[74]  Elliot Soloway,et al.  Delocalized Plans and Program Comprehension , 1986, IEEE Software.

[75]  L HeitmeyerConstance,et al.  Automated consistency checking of requirements specifications , 1996 .

[76]  Hausi A. Müller,et al.  Rigi: a system for programming-in-the-large , 1988, Proceedings. [1989] 11th International Conference on Software Engineering.

[77]  Jack C. Wileden,et al.  Foundations for the Arcadia environment architecture , 1989, SDE 3.

[78]  Keith Brian Gallagher,et al.  Using Program Slicing in Software Maintenance , 1991, IEEE Trans. Software Eng..

[79]  Gregor Kiczales,et al.  Overcoming the Prevalent Decomposition in Legacy Code , 2001 .

[80]  Wolfgang Emmerich,et al.  Flexible consistency checking , 2003, TSEM.

[81]  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).

[82]  Arie van Deursen,et al.  Identifying objects using cluster and concept analysis , 1999, Proceedings of the 1999 International Conference on Software Engineering (IEEE Cat. No.99CB37002).

[83]  Stephen S. Yau,et al.  Some Stability Measures for Software Maintenance , 1980, IEEE Trans. Software Eng..

[84]  Frank Tip,et al.  A survey of program slicing techniques , 1994, J. Program. Lang..

[85]  Adele Goldberg,et al.  Smalltalk-80 - the interactive programming environment , 1984 .

[86]  Marc J. Rochkind,et al.  The source code control system , 1975, IEEE Transactions on Software Engineering.

[87]  Siobhán Clarke,et al.  Subject-oriented design: towards improved alignment of requirements, design, and code , 1999, OOPSLA '99.

[88]  Martin P. Robillard,et al.  Separating features in source code: an exploratory study , 2001, Proceedings of the 23rd International Conference on Software Engineering. ICSE 2001.

[89]  Wolfgang Emmerich,et al.  Consistency management with repair actions , 2003, 25th International Conference on Software Engineering, 2003. Proceedings..

[90]  Paolo Tonella,et al.  Concept Analysis for Module Restructuring , 2001, IEEE Trans. Software Eng..

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

[92]  Bjarne Stroustrup,et al.  C++ Programming Language , 1986, IEEE Softw..

[93]  Daniel C. Halbert,et al.  The Trellis programming environment , 1987, OOPSLA 1987.

[94]  William F. Opdyke,et al.  Refactoring object-oriented frameworks , 1992 .

[95]  Jong-Deok Choi,et al.  Efficient and precise modeling of exceptions for the analysis of Java programs , 1999, PASTE '99.

[96]  Robert S. Arnold,et al.  Software Change Impact Analysis , 1996 .

[97]  Lori A. Clarke,et al.  Consistency management for complex applications , 1998, Proceedings of the 20th International Conference on Software Engineering.

[98]  Steven P. Reiss,et al.  Simplifying data integration: the design of the Desert software development environment , 1996, Proceedings of IEEE 18th International Conference on Software Engineering.

[99]  Bent Bruun Kristensen,et al.  Consistency in software system development: framework, model, techniques & tools , 1992 .

[100]  David Notkin,et al.  An empirical study of static call graph extractors , 1998, TSEM.

[101]  Tom Mens,et al.  Maintaining software through intentional source-code views , 2002, SEKE '02.

[102]  James Martin,et al.  Software Maintenance: The Problem and Its Solutions , 1983 .

[103]  Als-Nscort Eclipse Platform Technical Overview , 2003 .

[104]  Edsger W. Dijkstra,et al.  A Discipline of Programming , 1976 .

[105]  Flemming Nielson,et al.  Principles of Program Analysis , 1999, Springer Berlin Heidelberg.

[106]  C Haythornwaite,et al.  Gamma, E., Helm, R., Johnson, R. & Vlissides, J. Design Patterns: Elements of Reusable Object Oriented Software. New York: Addison-Wesley, 1995. , 2002 .

[107]  Patrick Borras,et al.  Centaur: the system , 1988, Software Development Environments.

[108]  David W. Binkley,et al.  Interprocedural slicing using dependence graphs , 1990, TOPL.

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

[110]  Shari Lawrence Pfleeger,et al.  Design and analysis in software engineering: the language of case studies and formal experiments , 1994, SOEN.

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

[112]  Václav Rajlich,et al.  Case study of feature location using dependence graph , 2000, Proceedings IWPC 2000. 8th International Workshop on Program Comprehension.

[113]  Thomas Fritz,et al.  Refactoring to aspects: an interactive approach , 2003, eclipse '03.

[114]  Eduardo Valido-Cabrera Software reliability methods , 2006 .

[115]  Norman Wilde,et al.  Early field experience with the Software Reconnaissance technique for program comprehension , 1996, Proceedings of WCRE '96: 4rd Working Conference on Reverse Engineering.

[116]  Norman Wilde,et al.  A comparison of methods for locating features in legacy software , 2003, J. Syst. Softw..

[117]  Norman Wilde,et al.  Software reconnaissance: Mapping program features to code , 1995, J. Softw. Maintenance Res. Pract..

[118]  Michael Hind,et al.  Which pointer analysis should I use? , 2000, ISSTA '00.

[119]  Mark Chu-Carroll,et al.  Coven: brewing better collaboration through software configuration management , 2000, SIGSOFT '00/FSE-8.

[120]  Bashar Nuseibeh,et al.  Leveraging Inconsistency in Software Development , 2000, Computer.

[121]  David Lorge Parnas,et al.  Software aging , 1994, Proceedings of 16th International Conference on Software Engineering.

[122]  Giuliano Antoniol,et al.  Recovering code to documentation links in OO systems , 1999, Sixth Working Conference on Reverse Engineering (Cat. No.PR00303).

[123]  Martin P. Robillard,et al.  Concern graphs: finding and describing concerns using structural program dependencies , 2002, Proceedings of the 24th International Conference on Software Engineering. ICSE 2002.

[124]  Martin P. Robillard,et al.  Does aspect-oriented programming work? , 2001, CACM.

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

[126]  Gail C. Murphy,et al.  Managing crosscutting concerns during software evolution tasks: an inquisitive study , 2002, AOSD '02.

[127]  Mary Beth Rosson,et al.  Proceedings of the 15th ACM SIGPLAN conference on Object-oriented programming, systems, languages, and applications , 2000, Conference on Object-Oriented Programming Systems, Languages, and Applications.

[128]  Joe D. Warren,et al.  The program dependence graph and its use in optimization , 1987, TOPL.

[129]  Saurabh Sinha,et al.  Analysis of programs with exception-handling constructs , 1998, Proceedings. International Conference on Software Maintenance (Cat. No. 98CB36272).

[130]  Martin P. Robillard,et al.  FEAT a tool for locating, describing, and analyzing concerns in source code , 2003, 25th International Conference on Software Engineering, 2003. Proceedings..

[131]  Stanley M. Sutton,et al.  Concern modeling in the concern manipulation environment , 2005, ACM SIGSOFT Softw. Eng. Notes.

[132]  Robert Moreton A process model for software maintenance , 1990, J. Inf. Technol..

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

[134]  William G. Griswold,et al.  Getting started with ASPECTJ , 2001, CACM.

[135]  Doris L. Carver,et al.  Identification of data cohesive subsystems using data mining techniques , 1998, Proceedings. International Conference on Software Maintenance (Cat. No. 98CB36272).

[136]  Harold Ossher,et al.  Hyper/J/sup TM/: multi-dimensional separation of concerns for Java/sup TM/ , 2000, Proceedings of the 2000 International Conference on Software Engineering. ICSE 2000 the New Millennium.

[137]  Donglin Liang,et al.  Efficient points-to analysis for whole-program analysis , 1999, ESEC/FSE-7.

[138]  Jason E. Robbins,et al.  Extending Design Environments to Software Architecture Design , 2004, Automated Software Engineering.

[139]  Hausi A. Müller,et al.  Rigi: A Visualization Environment for Reverse Engineering , 1997, Proceedings of the (19th) International Conference on Software Engineering.

[140]  Harold Ossher,et al.  Workshop on advanced separation of concerns in software engineering , 2001, Proceedings of the 23rd International Conference on Software Engineering. ICSE 2001.

[141]  Gregor Kiczales,et al.  Aspect-oriented programming , 2001, ESEC/FSE-9.

[142]  João Araújo,et al.  Modularisation and composition of aspectual requirements , 2003, AOSD '03.

[143]  Shari Lawrence Pfleeger,et al.  Preliminary Guidelines for Empirical Research in Software Engineering , 2002, IEEE Trans. Software Eng..

[144]  C. M. Sperberg-McQueen,et al.  Extensible Markup Language (XML) , 1997, World Wide Web J..

[145]  Stephen G. Eick,et al.  Seesoft-A Tool For Visualizing Line Oriented Software Statistics , 1992, IEEE Trans. Software Eng..

[146]  Kris De Volder,et al.  Navigating and querying code without getting lost , 2003, AOSD '03.

[147]  Barbara G. Ryder Dimensions of Precision in Reference Analysis of Object-Oriented Programming Languages , 2003, CC.

[148]  Magne Jørgensen,et al.  The prediction ability of experienced software maintainers , 2000, Proceedings of the Fourth European Conference on Software Maintenance and Reengineering.

[149]  Martin P. Robillard,et al.  Efficient mapping of software system traces to architectural views , 2000, CASCON.

[150]  D. Gabbay,et al.  Inconsistency Handling in Multiperspective Specifications , 1994 .

[151]  D. Ince,et al.  An introduction to discrete mathematics, formal system specification, and Z , 1993 .

[152]  Wolfgang Emmerich,et al.  Static consistency checking for distributed specifications , 2001, Proceedings 16th Annual International Conference on Automated Software Engineering (ASE 2001).

[153]  Robert Sedgewick,et al.  Algorithms in C , 1990 .

[154]  Brian W. Kernighan,et al.  The C Programming Language , 1978 .

[155]  Guy L. Steele,et al.  The Java Language Specification , 1996 .

[156]  Licia Capra,et al.  xlinkit: a consistency checking and smart link generation service , 2002, TOIT.

[157]  Thomas G. Szymanski,et al.  A fast algorithm for computing longest common subsequences , 1977, CACM.

[158]  Daniel C. Halbert,et al.  The Trellis programming environment , 1987, OOPSLA '87.

[159]  H. D. Rombach,et al.  Improving software maintenance through measurement , 1989 .

[160]  Kim Mens,et al.  Using intentional source-code views to aid software maintenance , 2003, International Conference on Software Maintenance, 2003. ICSM 2003. Proceedings..

[161]  Bent Bruun Kristensen,et al.  Consistency in software system development: framework, model, techniques & tools , 1992, SDE.

[162]  Larry Masinter,et al.  The Interlisp Programming Environment , 1981, Computer.

[163]  Qiang Yang,et al.  The program understanding problem: analysis and a heuristic approach , 1996, Proceedings of IEEE 18th International Conference on Software Engineering.

[164]  Glenn S. Fowler,et al.  Ciao: a graphical navigator for software and document repositories , 1995, Proceedings of International Conference on Software Maintenance.