Concern graphs: finding and describing concerns using structural program dependencies

@article{Robillard2002ConcernGF,
  title={Concern graphs: finding and describing concerns using structural program dependencies},
  author={Martin P. Robillard and Gail C. Murphy},
  journal={Proceedings of the 24th International Conference on Software Engineering. ICSE 2002},
  year={2002},
  pages={406-416}
}
  • M. Robillard, G. Murphy
  • Published 19 May 2002
  • Computer Science
  • Proceedings of the 24th International Conference on Software Engineering. ICSE 2002
Many maintenance tasks address concerns, or features, that are not well modularized in the source code comprising a system. Existing approaches available to help software developers locate and manage scattered concerns use a representation based on lines of source code, complicating the analysis of the concerns. In this paper, we introduce the concern graph representation that abstracts the implementation details of a concern and makes explicit the relationships between different parts of the… 

Figures and Tables from this paper

A representation for describing and analyzing concerns in source code
TLDR
The Concern Graph representation is introduced that abstracts the implementation details of a concern and makes explicit the relationships between different parts of the concern and allows an obvious and expensive mapping back to the corresponding source code.
Representing concerns in source code
TLDR
Evidence is provided 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.
A Program Slicing Approach for Locating Functional Concerns
TLDR
This paper describes an approach for locating the code contributing to a functional concern that is based on program slicing that uses heuristics to bound the size of the slice determined to represent the functional concern, thereby overcoming the large slice sizes that often limit the usefulness of program slicing based approaches.
A Study of Program Evolution Involving Scattered Concerns
TLDR
This paper introduces two novel analyses: navigation graphs, which support the analysis of a subject’s behavior when investigating source code, and variant analysis, which is used for evaluating the results of a program evolution task.
Exploring Code Projections as a Tool for Concern Management
TLDR
This paper explores possibilities to use projections as a tool for concern management and identifies several areas where existing solutions can be improved and proposes the concept of configurable projection that can further facilitate the program comprehension process.
Managing crosscutting concerns during software evolution tasks: an inquisitive study
TLDR
It was found that crosscutting concerns tended to emerge as obstacles that the developer had to consider to make the desired change, and the strategy used by the developer to manage the concern depended on the form of the obstacle code.
Unifying abstractions and code with concern maps
TLDR
This thesis describes a technique that works in a wide variety of circumstances that allows users to create simple diagrams that describe the concern and then annotate this diagram with query expressions which link the diagram to related development artefacts like source code or documents.
Using Language Clues to Discover Crosscutting Concerns
TLDR
The use of lexical chaining to identify crosscutting concerns, the design and implementation of an algorithm that uses lexicalChaining to expose concerns, and examples of concerns that the tool is able to discover automatically are presented.
Evolving Descriptions of Scattered Concerns
TLDR
This paper describes how the evolution of artifacts that refer to the implementation of concerns in a system is supported by combining the ideas of low-level program abstractions, tolerance to inconsistencies, and specialized tool support for inconsistency management.
An exploration of how comments are used for marking related code fragments
TLDR
It is found that developers use two basic kinds of conventions to mark related code in comments: by explicitly stating relationships in the comment and by using similar comments in related code elements.
...
1
2
3
4
5
...

References

SHOWING 1-10 OF 30 REFERENCES
Efficient mapping of software system traces to architectural views
TLDR
This paper presents an encoding technique for dynamic trace information that makes it tractable and efficient to manipulate a trace from a variety of different architecture-level viewpoints and describes two tools that use the technique: a visualization tool and a path query tool.
Generalized aliasing as a basis for program analysis tools
TLDR
The design of a system, Ajax, that addresses the problem of aliasing by using semantics-based program analysis as the basis for a number of different tools to aid Java programmers, and is the first system to address this particular task.
An Extensible System for Source Code Analysis
TLDR
This paper presents a system for developing code analyzers that uses a database to store both a no-loss fine-grained intermediate representation and the results of the analyses and compares it to other related approaches.
Locating user functionality in old code
TLDR
The authors propose a methodology for answering the question of which parts of the program the functionality X is implemented based on the use of carefully designed test cases as probes into the code.
Conceptual module querying for software reengineering
  • E. Baniassad, G. Murphy
  • Computer Science
    Proceedings of the 20th International Conference on Software Engineering
  • 1998
TLDR
It is shown how the conceptual module approach simplifies the gathering of source information for reengineering tasks, and how a tool to support the approach was built as a front-end to existing source analysis tools.
Software Change Impact Analysis
TLDR
This book identifies key impact analysis definitions and themes and illustrates the important themes to give a solid understanding for tackling impact analysis problems and shows how results from both areas can more effectively support impact analysis in software engineering repositories.
Seesoft-A Tool For Visualizing Line Oriented Software Statistics
TLDR
The Seesoft software visualization system allows one to analyze up to 50000 lines of code simultaneously by mapping each line of code into a thin row, and the user can manipulate this reduced representation of the code in order to find interesting patterns.
Compiler and tool support for debugging object protocols
TLDR
An extension to the Java programming language that supports static conformance checking and dynamic debugging of object “protocols,” i.e., sequencing constraints on the order in which methods may be called, which has a statically checkable subset embedded in richer descriptions that can be checked at run time.
Using Program Slicing in Software Maintenance
TLDR
Using the lattice of single variable decomposition slices ordered by set inclusion, it is shown how a slice-based decomposition for programs can be formed and how to delineate the effects of a proposed change by isolating those effects in a single component of the decomposition.
Exploiting the map metaphor in a tool for software evolution
TLDR
It is argued that the map metaphor can serve as an organizing principle for the design of effective tools for performing global software changes.
...
1
2
3
...