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

Abstract not found

Nowadays, the majority of productivity applications are interactive and graphical in nature. In this paper, we explore the possibility of taking advantage of these two characteristics in a design recovery tool. Specifically, the fact that an application is interactive means that we can identify distinct execution bursts corresponding closely to "actions " performed by the user. The fact that the application is graphical means that we can describe those actions visually from fragments of the application display itself. Combining these two ideas, we obtain an explicit mapping from high-level actions performed by a user (similar to use case scenarios/specification fragments) to their low-level implementation. This mapping can be used for design recovery of interactive graphical applications. We demonstrate our approach using L Y X, a scientific word processor.

An important part of many software maintenance tasks is to gain a sufficient level of understanding of the system at hand. The use of dynamic information to aid in this software understanding process is a common practice nowadays. A major issue in this context is scalability: due to the vast amounts of information, it is a very difficult task to successfully navigate through the dynamic data contained in execution traces without getting lost. In this paper, we propose the use of two novel trace visualization techniques based on the massive sequence and circular bundle view, which both reflect a strong emphasis on scalability. These techniques have been implemented in a tool called Extravis. By means of distinct usage scenarios that were conducted on three different software systems, we show how our approach is applicable in three typical program comprehension tasks: trace exploration, feature location, and top-down analysis with domain knowledge.

Moving to smaller libraries can be considered as a relevant task when porting software systems to limited-resource devices (e.g., hand-helds). Library miniaturization will be particularly effective if based on both dynamic (keeping into account dependencies exploited during application execution in a given user profile) and static (keeping into account all possible dependencies) information. This

Introduction Software product line architectures promise significant benefits over traditional architectures such as shorter time-to-market, shorter and cheaper development cycles, and higher exploitation of the reuse potential at hand. While the ideas and concepts of product lines are well suited for developing new products, it is not obvious if and how one can apply this technology in the presence of legacy software. Migrating legacy software systems to a product line provides ways for extending and developing successful products and o#ers a chance to protect and preserve a company's former investments. The legacy artifacts have been designed under significantly di#erent circumstances and typically for just one single application domain. Therefore turning legacy software into a software product line requires a new design aware of the old product's key assets---assuming reuse really pays. Consequently, reengineering e#orts have to address a number of issues unique to product line de

Abstract not found

As the field of aspect-oriented software development [14] has become more firmly established certain emphasis has now been diverted to introducing the benefits of the approach to existing software where aspects were not made explicit during design or implementation. This paper proposes an automatic, dynamic analysis-based approach to aspect mining that affords the recovery of reuse aspectual views from existing software. The potential of the technique is demonstrated through a case study.

About ten years ago, the first serious applications of concept lattices in software analysis were published. Today, a wide range of applications of concept lattices in static and dynamic analysis of software artefacts is known. This overview summarizes important papers from the last ten years, and presents three methods in some detail: 1. methods to extract classes and modules from legacy software; 2. the Snelting/Tip algorithm for application-specific, semantics-preserving refactoring of class hierarchies; 3. Ball's method for infering dynamic dominators and control flow regions from program traces. We conclude with some perpectives on further uses of concept lattices in software technology.