René Klösch

Software evolution observations based on product release history

Large software systems evolve slowly but constantly. In this paper, we examine the structure of several releases of a telecommunication switching system (TSS) based on information stored in a database of product releases. We tracked the historical evolution of the TSS structure and related the adaptations made (e.g. addition of new features, etc.) to the structure of the system. Such a systematic examination can uncover potential shortcomings in the structure of the system and identify modules or subsystems that should be subject to restructuring or reengineering. Further, we have identified additional information that would be useful for such investigations but is currently lacking in the database

Finding objects in procedural programs: an alternative approach

Effective software maintenance requires a detailed knowledge of the systems artifacts, the way these artifacts are used or modified and their interrelationships. Based on some useful characteristics of the object-oriented paradigm the identification of objects within procedural programs has become a promising approach to reduce the effort in program understanding and, hence, the maintenance cost. In this paper we present a new approach to object identification in procedural programs that not only relies on information exclusively extractable from source code but integrates human expertise and external domain- and application-specific knowledge.

Architecture recovery in ARES

Recovering the architecture of legacy systems requires more than just reverse engineering tools to generate some higherlevel descriptions of the system under study. Design decisions and logical groupings of functions have to be balanced with informal domain knowledge, domain standards and coding guidelines of the developers. Therefore, we combine domain aspects with coding aspects and use reverse engineering tools as one means of recovering the requested information to reason about the underlying architecture of the system. This reasoning is an alternating top-down and bottom-up approach. The’architecture recovery process we introduce is one part of the ESPRIT project ARES (Architectural Reasoning for Embedded Systems).’

Capsule Oriented Reverse Engineering for Software Reuse

Much research effort concerning the reuse of software components has been invested on questions such as classification, attribution and organization of modules in software components libraries. Further problems like the obtaining of reusable components and their interconnection to form new software systems have been discovered. Reverse engineering can be used for different purposes, like maintenance effort reduction, documentation improvement, etc., but also for software reuse. In the process of software reuse, reverse engineering can be used to extract reusable components from existing software systems.

Object-Oriented Re-Architecturing

Many organizations face the problem of improving the value of their legacy systems. Modernizing the architecture of old software helps to gain control over maintenance cost, to improve system performance, and it supports moving to a distributed or more efficient environment. We propose a re-architecturing of old procedural software to an object-oriented architecture. To overcome limits of classical reverse engineering approaches building exclusively on information extractable from source code we integrate domain knowledge in the process. The resulting object-oriented software helps reduce future maintenance cost, since modern (and more calculable) maintenance technology can then be applied. In this paper, we point out the basic concepts of the re-architecturing process, the generation of design documents at different levels of abstraction, and the necessary syntactic adaptations of the source code.

USING DOMAIN KNOWLEDGE TO IMPROVE REVERSE ENGINEERING

Integrating application domain knowledge into reverse engineering is an important step to overcome the shortcomings of conventional reverse engineering approaches that are based exclusively on information derivable from source code. In this paper, we show the basic concepts of a program transformation process from a conventional to an object-oriented architecture which incorporates extraneous higher-level knowledge in its process. To which degree this knowledge might stem from some general domain knowledge, and to which extent it needs to be introduced as application dependent knowledge by a human expert is discussed. The paper discusses these issues in the context of the architectural transformation of legacy systems to an object-oriented architecture.

Research directions in software reuse: where to go from here?

Software reuse is no longer in its infancy. We are able to look back at more than 15 years of research and should use the opportunity of such a symposium to critically evaluate the past research in order to identify promising future research areas in software reuse. In this paper, we give a broader view of reuse and some of the so far less-considered areas, which we believe may support software reuse to get off the ground. We mention our ongoing research in software reuse, discussing reuse experiments in the areas of long-term software evolution and component programming. Furthermore, we indicate the critical importance of interactions among the reuse and related communities within software engineering, such as the object-oriented and the software maintenance communities.

Program transformation to enhance the reuse potential of procedural software

Object-oriented concepts seem to be useful concerning the reuse of ~xlsting soRwarc. Therefore a transformation of procedural programs to object-oriented programs becomes an important process to enhance the reuse potentiai of procedural programs. In this paper we describe a program transformation process, which transforms originally procedural systems to object-oriented systems. The objects of the resulting systcrn may then be used for further object-oriented systems engineering, avoiding many problems arising in connection with procedural software reuse (i.e. module interconnectionl etc.).

Software architecture recovery of embedded software

The complexity of embedded software systems has increased substantially in the last years. The concept of software architecture provides methods and notations to handle the increased size and complexity. These concepts provide a higher level of abstraction than common analysis and design methods. The architecture of existing legacy systems is of high interest for the development of successors of such systems. However, architectural information of legacy systems is often not available. The architecture recovery process we discuss is research work within the ESPRIT project ARES (Architectural Reasoning for Embedded Systems). 1

Reuse engineering: software construction from reusable components

The authors describe a comprehensive approach that supports reuse in the software development process, especially the production of software from reusable components. For this purpose well-known strategies like reverse engineering and design recovery are combined with a generalization mechanism to develop the reuse engineering process. This process includes both the phase of isolating reusable modules from existing software and the phase of retrieving such modules from a software component library and combining them to new software. The definition of a reuse engineering life-cycle, which integrates reuse into the conventional software life-cycle is considered.<<ETX>>