Generic language technology and compiler construction techniques are a prerequisite to build analysis and conversion tools that are needed for the re-engineering of large software systems. We argue that generic language technology is a crucial means to do fundamental re-engineering. Furthermore, we address the issue that the application of compiler construction techniques in re-engineering generates new research questions in the field of compiler construction.

Building models to understand software systems is an important part of reverse engineering. Formal and explicit model building is important because it focuses attention on modeling as an aid to understanding and results in artifacts that may be useful to others. The representation used to build models has great influence over the success and value of the result. Choosing the proper representation during reverse engineering is the representation problem. This paper examines the representation problem by presenting a taxonomy of solutions. It also illustrates the issues involved in choosing a representation through an example reverse engineering task. 1 Introduction Chikofsky and Cross define reverse engineering to be "the process of analyzing a subject system to identify the system's components and their interrelationships and create representations of the system in another form or at a higher level of abstraction [CC90]." They go on to describe six key objectives of reverse engineer...

Most software reuse research has ignored the role of the software engineer. However, software engineers tend to be better reasoners and have more experiences to recall than tool-based reuse mechanisms. This paper argues for integrating software engineers into existing reuse paradigms and providing tool support to assist problem description and component understanding, selection and adaptation. However, empirical studies indicate that these reuse tasks are difficult, even for experienced software engineers. Therefore, guidelines and a high-level architecture for design of tool support are based on reports of behaviour and problems arising during reuse. 1: Introduction Many technical solutions to software reuse problems have failed to result in widespread reuse. One reason may be that these solutions ignore human involvement. This paper investigates specific problems which arise from excluding software developers from the reuse process and proposes solutions based on human involvement fo...

Understanding the behaviour of distributed applications is a very challenging task, due to the complexity of these applications. To manage complexity, the top-down use of suitable abstraction hierarchies is frequently proposed. Given the complexity of distributed applications, manually deriving such abstraction hierarchies is not realistic. This paper discusses one tool that groups more primitive events into abstract events to derive a hierarchy of abstract events automatically. Ideally, these abstractions should reveal logical units of an application and their relations. To explore the abstraction hierarchies visualizations. A user can navigate through these abstraction hierarchies, displaying an execution at various levels of abstraction. Examples of such abstract visualizations are given and discussed. In general, the abstractions derived automatically represent meaningful parts of the application: they can be interpreted using terms of the application domain. While the abstraction tool not necessarily derives the best possible abstraction hierarchies in all cases, it does the bulk of work and provides good initial abstractions.

In this report, we present an overview of the existing software re-engineering process and its related concepts. We also classify existing software reuse techniques and we propose how to integrate such techniques into the software re-engineering process by following a component-based approach. In addition, we demonstrate how our methodology can be applied on a client-server legacy system.

advanced architectural features, such as explicit instruction-level parallelism, instruction predication, and speculative loads from memory. However, compiler optimizations that take advantage of these features can profoundly restructure the program’s code, making it potentially difficult to reconstruct the original program logic from an optimized Itanium executable. This paper describes techniques to undo some of the effects of such optimizations and thereby improve the quality of reverse engineering such executables.

Abstract — Application source code protection is a major concern for software architects today. Secure platforms have been proposed that protect the secrecy of application algorithms and enforce copy protection assurances. Unfortunately, these capabilities incur a sizeable performance overhead. Partitioning an application into secure and insecure regions can help diminish these overheads but invalidates guarantees of code secrecy and copy protection. This work examines one of the problems of partitioning an application into public and private regions, the ability of an adversary to recreate those private regions. To our knowledge, it is the first to analyze this problem when considering application operation as a whole. Looking at the fundamentals of the issue, we analyze one of the simplest attacks possible, a “Memoization Attack. ” We implement an efficient Memoization Attack and discuss necessary techniques that limit storage and computation consumption. Experimentation reveals that certain classes of real-world applications are vulnerable to Memoization Attacks. To protect against such an attack, we propose a set of indicator tests that enable an application designer to identify susceptible application code regions. I.