We describe a general technique for identifying modules in legacy code. The method is based on concept analysis --- a branch of lattice theory that can be used to identify similarities among a set of objects based on their attributes. We discuss how concept analysis can identify potential modules using both "positive" and "negative" information. We present an algorithmic framework to construct a lattice of concepts from a program, where each concept represents a potential module. 1 Introduction Many existing software systems were developed using programming languages and paradigms that do not incorporate object-oriented features and design principles. In particular, these systems often lack a modular style, making maintenance and further enhancement an arduous task. The software engineer's job would be less difficult if there were tools that could transform code that does not make explicit use of modules into functionally equivalent object-oriented code that does make use of modules...

Legacy software systems present a high level of entropy combined with imprecise documentation. This makes their maintenance more difficult, more time consuming, and costlier. In order to address these issues, many organizations have been migrating their legacy systems to new technologies. In this paper, we describe a computer-supported approach aimed at supporting the migration of procedural software systems to the objectoriented (OO) technology, which supposedly, fosters reusability, expandability, flexibility, encapsulation, information hiding, modularity, and maintainability. Our approach relies heavily on the automatic formation of concepts based on information extracted directly from code to identify objects. The approach tends, thus, to minimize the need for domain application experts. We also propose rules for the identification of OO methods from routines. A well-known and self-contained example is used to illustrate the approach. We have applied the approach on medium/large procedural software systems, and the results show that the approach is able to find objects and to identify their methods from procedures and functions.

Java is a relatively new programming language that is gaining popularity due to its network-centric features and platform independence (`Write Once, Run Anywhere'). This popularity has caused rapid evolution in the libraries that are available for Java applications. This evolution, in combination with Java's run-time linking, may cause incompatibilities between an application and the library it depends on: an application may execute with a different library version than the one it was compiled for. This paper presents techniques to automatically detect change in a library from its bytecode (binary) representation, and to apply the impact of those changes to any Java application. This paper also includes results of change detection experiments performed on the standard Java library (JDK). 1 Introduction Most software applications depend on a set of library functions which are either generic (e.g. Unix C libraries) or specific to an application (e.g. matrix manipulation libraries). Appl...

The design and evaluation of appropriate software architectures is key to the eective development, management, evolution, and reuse of software systems. However, current software engineering practice has generally led to architectural designs that are informal, ad hoc, and dicult to analyse and maintain. One consequence is that most existing systems have little or no documented architectural information, and the information that does exist is often an inaccurate representation of the implemented architecture. All too often, architectural information about an unfamiliar system needs to be extracted directly from the implemented software artifacts. This is a very demanding process commonly referred to as architecture recovery. Although architecture recovery can be signicantly facilitated with the help of current reverse engineering techniques and tools, many issues remain to be properly addressed, particularly regarding recovery of the runtime abstractions (client, servers, communication protocols, etc.) that are typical to the design of distributed systems. This dissertation presents a static reverse engineering approach, called X-ray, to

Object-oriented re-architecting (OORA) concerns identification of objects in procedural code with the goal to transform a procedural into an object-oriented program. We have developed a method to address the problem of object identification from two different directions: 1) building an object model of the application based on system documentation to ensure the creation of application-semantic classes; and 2) analyzing the source code to identify potential class candidates on the basis of compound data types and data flow analysis. Object model classes are bound to class candidates to prepare a forward biased and thus semantically meaningful program transformation at the source code level. In this paper, we define a similarity measure for classes to enables the binding process. We also describe the constraints and benefits of human intervention in this process. We have applied this method to a real-world embedded software system to identify potential classes; results from the case study are given in the paper. 1.

Legacy software systems present a high level of entropy combined with imprecise documentation. This makes their maintenance more difficult, more time consuming, and costlier. In order to address these issues, many organizations have been migrating their legacy systems to emerging technologies. In this paper, we describe a computer-supported approach aimed at supporting the migration of procedural software systems to the object-oriented (OO) technology. Our approach is based on the automatic formation of concepts, and uses information extracted directly from code to identify objects. The approach tends, thus, to minimize the need for domain application experts.

Software industry has a huge amount of legacy programs needing modernization and re-engineering. We are especially interested in re-engineering legacy programs via language conversion. In language conversion, the source and target languages can be either from the same programming paradigm or from di#erent ones. Thus, we consider program modernization from two aspects. If the source and target languages share the same programming paradigm, we can modernize programs via source-to-source translation. If the languages are from di#erent paradigms, for example procedural and object-oriented, we need re-engineering means in modernization, particularly in identifying objects from procedural code. After finding objects and their operations, we need again source-to-source translation methods in the actual conversion. As a constructive part of this thesis, we have implemented a converter translating PL/M programs into C. As an implementation tool of that converter, we have used TaLE (Tampere Language Editor). Because of the nature of the legacy software and PL/M language, we have been forced to extend TaLE. Since legacy systems are typically large, we have developed a technique to reduce the space requirements of the converter. In addition, conditional compilation of the source language may cause parsing problems in source-to-source translation. As a solution for this problem, we introduce multi-branch parsing. Both of these techniques are implemented in TaLE. We also show how to exploit the existing features of TaLE in information passing. We have extended the PL/M-to-C converter with object identification methods as a first step to enable translation from a procedural language into an objectoriented one (for example, C++). We introduce new methods to identify objectoriented f...

In order to translate a non-object-oriented (procedural) program into an object-oriented one, objects must be identified from the procedural program. Object-oriented programs (compared with procedural ones) are considered to be easier to reuse and maintain. Thus, object identification followed by translation from a non-object-oriented language into an object-oriented language is one way to re-engineer legacy programs. This paper gives an overview of re-engineering in general and of object identification especially. Associated with objectorientation, identification of (design) patterns is discussed, too.