Understanding the implementation of a certain feature of a system requires to identify the computational units of the system that contribute to this feature. In many cases, the mapping of features to the source code is poorly documented. In this paper, we present a semi-automatic technique that reconstructs the mapping for features that are triggered by the user and exhibit an observable behavior. The mapping is in general not injective; that is, a computational unit may contribute to several features. Our technique allows to distinguish between general and specific computational units with respect to a given set of features. For a set of features, it also identifies jointly and distinctly required computational units.

Understanding a system’s implementation without prior knowledge is a hard task for reengineers in general. However, some degree of automatic aid is possible. In this paper, we present a technique building a mapping between the system’s externally visible behavior and the relevant parts of the source code. Our technique combines dynamic and static analyses to rapidly focus on the system’s parts urgently required for a goal-directed process of program understanding. 1.

Abstract. Formal Concept Analysis (FCA) has typically been applied in the field of software engineering to support software maintenance and object-oriented class identification tasks. This paper presents a broader overview by describing and classifying academic papers that report the application of FCA to software engineering. The papers are classified using a framework based on the activities defined in the ISO12207 Software Engineering standard. Two alternate classification schemes based on the programming language under analysis and target application size are also discussed. In addition, the authors work to support agile methods and formal specification via FCA is introduced. 1

The first task of a programmer who wants to understand how a certain feature is implemented is to localize the implementation of the feature in the code. If the implementations of a set of related features are to be understood, a programmer is interested in their commonalities and variabilities. For large and badly documented programs, localizing features in code and identifying commonalities and variabilities of components and features can be difficult and time-consuming. It is useful to derive this information automatically. The feature-

A significant aspect in applying the Reflexion Method is the mapping of components found in the source code onto the conceptual components defined in the hypothesized architecture. To date, this mapping is established manually, which requires a lot of work for large software systems. In this paper, we present a new approach, in which clustering techniques are applied to support the user in the mapping activity. The result is a semi-automated mapping technique that accommodates the automatic clustering of the source model with the user’s hypothesized knowledge about the system’s architecture. This paper describes also a case study in which our semi-automated mapping technique has been applied successfully to extend a partial map of a real-world software application. 1

Atomic components are sets of related variables, types, and subprograms, e.g., abstract data types and objects. Many techniques exist to detect them automatically. However, as an evaluation has shown, none of them has the precision needed [9]. One approach to achieve a higher precision is to integrate the user into the detection cycle. This paper describes a method in which computer and human work together to find atomic components. Furthermore, it discusses how the techniques can be enhanced to work incrementally, which is needed if they are to be integrated with this method. Moreover, it proposes ways of combining the techniques within this interactive method. 1. Introduction Architecture recovery comprises detection of components (the computational parts) and connectors (the means and points of communication) of systems. The most primitive components consist of subprograms, types, and global variables. Groupings of these kinds of declarations are, for example, objects, abstract d...

Feature component maps describe which components are needed to implement a particular feature and are used early in processes to develop a product line based on existing assets. This paper describes a new technique to derive the feature component map and additional dependencies utilizing dynamic information and concept analysis. The method is simple to apply, cost-effective, largely language independent, and can yield results quickly and very early in the process. 1.

An approach to recovering design-level UML class models from C++ source code to support program comprehension is presented. A set of mappings are given that focus on accurately identifying such elements as relationship types, multiplicities, and aggregation semantics. These mappings are based on domain knowledge of the C++ language and common programming conventions and idioms. Additionally, formal concept analysis is used to detect design-level attributes of UML classes. An application implementing these mappings is used to reverse engineer a moderately sized, open source application, and the resultant class model is compared against those produced by other UML reverse engineering tools. This comparison shows that the presented mapping rules effectively produce meaningful and semantically accurate UML models.

Object-oriented software may show signs of procedural thinking because of lack of design or due to design erosion over a period of time. We refer to such a software as procedural object-oriented code. Huge classes, scarce class hierarchies and absence of classes for domain entities are hallmarks of procedural object-oriented code. Due to huge investments in such systems, software restructuring becomes necessary. To support code modularization, it is important to identify useful domain abstractions. In this paper, we present a tool-assisted technique to identify useful abstractions and class hierarchies in procedural object-oriented code. During this task, principal classes (draft classes) are identified. Afterwards, composition and association relationships are inferred for principal classes. Lastly, Formal Concept Analysis (FCA) is used to analyze hierarchical relationships between methods and attributes within principal classes. We validated our approach on several case studies and report our results on an industrial case.