An approach to implementation of aspect-oriented programming for C

This paper describes an approach to implementation of aspect-oriented programming (AOP) frameworks for C, outlines traditional AOP facilities for different programming languages, and shows how specific features of C and a build process of C programs affect AOP implementations. Next, we consider additional requirements imposed by a practical application of AOP implementations for C programs. Existing solutions are described and possibility of their use is analyzed. The paper describes a new AOP tool for C that implements the proposed approach and demonstrates its capabilities.     

基于J2EE分布式环境的再工程方法

给出基于J2EE分布式环境的遗留系统再工程框架。应用改进的层次聚类算法提取系统组件,能够方便地将代码取出以构建分布式系统。给出适用于J2EE 分布式环境的组件接口启发式规则和模块部署策略。实现企业遗留系统到J2EE分布式系统的再设计过程,验证该框架的强壮性、实用性和通用性。     

Improving time-to-market using SDL tools and techniques

In this paper we summarize our experiences in building and integrating new generation, formal-methods based computer aided software engineering tools (CASE) to yield pragmatic improvements in software engineering processes in the telecommunication industry. We define an accelerated development methodology (ADM) for the specification, design, testing and re-engineering of telecommunications software. We identify two of the most significant barriers to adoption of tools and formal methods to speed up software development, namely the requirements engineering barrier and the legacy code re-engineering barrier, and show how the ADM methodology helps to overcome these barriers and improve time-to-market for telecommunications software.Our ADM methodology is based on the most widely accepted formal languages standardized by the International Telecommunications Union (ITU):

Full-size image

This paper emphasizes the following key components of our ADM methodology and their placement within the most common software engineering processes:

Full-size image

基于SOA的遗留系统再工程的研究与应用

遗留系统的再工程是企业信息化建设必须解决的问题,在基于SOA的企业遗留系统复用框架的基础上,给出了通过Web Services技术将遗留系统从数据层、业务层、应用层进行封装的模型,并结合B/S结构的Web应用程序开发现状,实现了SSH框架下的遗留系统再工程过程。     

A methodology to infer and refactor an object‐oriented model from C applications

When analyzing legacy code, generating a high‐level model of an application during the reverse engineering process helps the developers understand how the application is structured and how the dependencies relate the different software entities. Within the context of procedural programming languages (such as C), the existing approaches to get a model of the code require documentation and/or implicit knowledge that stakeholders acquire during the software building. These approaches use the code itself to build a syntactic model where we see the different software artifacts, such as variables, functions, and modules. However, there is no supporting methodology to detect and analyze if there are relationships/dependencies between those artifacts, such as which variable in a module is declared using an abstract data type described in another one, or which are the functions that are using parameters typed with an abstract data type; or any design decision taken by original developers, such as how the developer has implemented functions in different modules. On the other hand, current developers use object‐oriented (OO) paradigm to implement not only business applications but also useful methodologies/tools that allow semiautomatic analysis of any application. We must remark the legacy procedural code still has worth and is working in several industries, and as any evolving code, the developers have to be able to perform maintenance tasks minimizing the limitations offered by the language. Based on useful properties that the OO paradigm (and their supporting analysis tools) provide, such as UML models, we propose M2K as a methodology to generate a high‐level model from legacy procedural code, mainly written in Ansi C. To understand how C‐based applications were implemented is not a new problem in software reengineering. However, our contribution is based on building an OO model and suggesting different refactorings that help the developer to improve it and to eventually guide a new implementation of the target application. Specifically, the methodology builds cohesive software entities mapped from procedural code and makes the coupling between C entities explicit in the high‐level model. The result of our methodology is a set of refactored class candidates: a structure that groups a set of variables and a set of functions obtained from the C applications. Based on the class candidate model, we propose refactorings based on OO design principles to improve the design of the application. The most relevant design improvements were obtained with algorithm abstraction by applying the strategy pattern, attributes/methods relocalization, variables types generalization, and removing/renaming methods/attributes. Besides a methodology and the supporting tool, we provide 14 case studies based on real projects implemented in C, and we showed how the results validate our proposal.     

Case study: Re-engineering C++ component models via automatic program transformation

Automated program transformation holds promise for a variety of software life cycle endeavors, particularly where the size of legacy systems makes manual code analysis, re-engineering, and evolution difficult and expensive. But constructing highly scalable transformation tools supporting modern languages in full generality is itself a painstaking and expensive process. This cost can be managed by developing a common transformation system infrastructure re-useable by derived tools that each address specific tasks, thus leveraging the infrastructure costs. This paper describes the Design Maintenance System (DMS¹), a practical, commercial program analysis and transformation system, and discusses how it was employed to construct a custom modernization tool being applied to a large C++ avionics system. The tool transforms components developed in a 1990s-era component style to a more modern CORBA-like component framework, preserving functionality.     

Using Meta-Model Transformation to Model Software Evolution

Understanding how software systems evolve is useful from different perspectives: reverse engineering, empirical studies etc.. For an effective understanding we need an explicit meta-model. We introduce Hismo, a meta-model which is centered around the notion of history and we show how we can obtain it from a snapshot meta-model. Based on our experience in developing the Hismo reverse engineering system, we show how we can transform a snapshot meta-model in a history meta-model.     

AspectMaps: Extending Moose to visualize AOP software

When using aspect-oriented programming the application implicitly invokes the functionality contained in the aspects. Consequently program comprehension of such a software is more intricate. To alleviate this difficulty we developed the AspectMaps visualization and tool. AspectMaps extends the Moose program comprehension and reverse engineering platform with support for aspects, and is implemented using facilities provided by Moose. In this paper we present the AspectMaps tool, and show how it can be used by performing an exploration of a fairly large aspect-oriented application. We then show how we extended the FAMIX meta-model family that underpins Moose to also provide support for aspects. This extension is called ASPIX, and thanks to this enhancement Moose can now also treat aspect-oriented software. Finally, we report on our experiences using some of the tools in Moose; Mondrian to implement the visualization, and Glamour to build the user interface. We discuss how we were able to implement a sizable visualization tool using them and how we were able to deal with some of their limitations.Note: This paper uses colors extensively. Please use a color version to better understand the ideas presented here.     

Design recovery for distributed systems

Two factors limit the utility of reverse engineering technology for many distributed software systems. First, with the exception of tools that support Ada and its explicit tasking constructs, reverse engineering tools fail to capture information concerning the flow of information between tasks. Second, relatively few reverse engineering tools are available for programming languages in which many older legacy applications were written (e.g., Jovial, CMS-2, and various assembly languages). We describe approaches that were developed for overcoming these limitations. In particular, we have implemented an approach for automatically extracting task flow information from a command and control system written in CMS-2. Our approach takes advantage of a small amount of externally provided design knowledge in order to recover design information relevant to the distributed nature of the target system     

基于动态行为和模糊识别的Aspect挖掘方法

横切关注点是指分布在多个单元模块的功能代码,面向方面的编程是解决传统编程过程中横切问题的重要方法之一,其中一个重要问题是如何从现有系统中发现横切关注点。该文提出一种基于动态行为和模糊模式识别的Aspect挖掘方法,通过引入Aspect获取运行时方法调用的信息,使程序具有自动收集动态信息的能力,并利用模糊理论识别系统中的横切关注点。实验验证了该方法的有效性和实现的简洁性。     

逆向工程发展现状研究

随着软件产业的发展，越来越多的遗产系统需要维护和改善，逆向工程已经成为遗产系统维护与演化的关键技术之一。介绍了逆向工程的定义，综述了逆向工程的研究进展。通过对现有工具的分析探讨了逆向工程研究中的不足之处，给出了未来的发展趋势。     

GEMLCA: Running Legacy Code Applications as Grid Services

There are many legacy code applications that cannot be run in a Grid environment without significant modification. To avoid re-engineering of legacy code, we developed the Grid Execution Management for Legacy Code Architecture (GEMLCA) that enables deployment of legacy code applications as Grid services. GEMLCA implements a general architecture for deploying legacy applications as Grid services without the need for code re-engineering, or even access to the source files. With GEMLCA, only a user-level understanding is required to run a legacy application from a standard Grid service client. The legacy code runs in its native environment using the GEMLCA resource layer to communicate with the Grid client, thus hiding the legacy nature of the application and presenting it as a Grid service. GEMLCA as a Grid service layer supports submitting jobs, getting their results and status back. The paper introduces the GEMLCA concept, its life cycle, design and implementation. It also presents as an example a legacy simulation code that has been successfully transformed into a Grid service using GEMLCA.     

On the Automatic Recovery of Style-Specific Architectural Relations in Software Systems

The cost of maintaining a software system over a long period of time far exceeds its initial development cost. Much of the maintenance cost is attributed to the time required by new developers to understand legacy systems. High-level structural information helps maintainers navigate through the numerous low-level components and relations present in the source code. Modularization tools can be used to produce subsystem decompositions from the source code but do not typically produce high-level architectural relations between the newly found subsystems. Controlling subsystem interactions is one important way in which the overall complexity of software maintenance can be reduced.We have developed a tool, called ARIS (Architecture Relation Inference System), that enables software engineers to define rules and relations for regulating subsystem interactions. These rules and relations are called Interconnection Styles and are definedusing a visual notation. The style definition is used by our tool to infer subsystem-level relations in designs being reverse engineered from source code.In this paper we describe our tool and its underlying techniques and algorithms. Using a case study, we describe how ARIS is used to reverse engineer high-level structural information from a real application.     

基于AOP技术的重构方法研究与实现

对面向 Aspect这种新的编程技术进行了分析 ,阐述了如何利用 AOP技术进行重构 .通过与传统方法进行分析对比 ,AOP可为软件工程技术提供一流的、可重用的解决方案 .通过对 Java Web应用的用户访问控制模块的研究和实现 ,提出了一种新的基于 AOP的重构方法     

Converting legacy code into Ada: a cognitive approach

Describes a code conversion tool that helps programmers visualize and understand system design. The author first reviews current software reengineering tools and then describe a new cognitive approach to system (re)engineering based on code comprehension tools that provide a visual representation of code containing less cognitive noise. This better enables programmers to understand system design. The approach integrates code comprehension tools with current reengineering methodologies to create an integrated reengineering workbench for converting legacy code into newer languages such as Ada or C/C++     

Software reuse through re-engineering the legacy systems

Software reuse is widely considered to be a way to increase the productivity and improve the quality and reliability of new software systems. Identifying, extracting and re-engineering software components that implement abstractions within existing systems is a promising cost-effective way to create reusable assets and re-engineer legacy systems. This paper summarizes our experiences with using computer-supported methods to develop a software architecture to support the re-engineering of the Janus Combat Simulation System. In this effort, we have developed an object-oriented architecture for the Janus Combat Simulation Subsystem, and validated the architecture with an executable prototype. In this paper, we propose methods to facilitate the reuse of the software components of the legacy systems by recovering the behavior of the systems using systematic methods, and illustrate their use in the context of the Janus System.     

Reverse engineering 4.7 million lines of code

The ITC‐Irst Reverse Engineering group was charged with analyzing a software application of approximately 4.7 million lines of C code. It was an old legacy system, maintained for a long time, on which several successive adaptive and corrective maintenance interventions had led to the degradation of the original structure. The company decided to re‐engineer the software instead of replacing it, because the complexity and costs of re‐implementing the application from scratch could not be afforded, and the associated risk could not be run. Several problems were encountered during re‐engineering, including identifying dependencies and detecting redundant functions that were not used anymore. To accomplish these goals, we adopted a conservative approach. Before performing any kind of analysis on the whole code, we carefully evaluated the expected costs. To this aim, a small but representative sample of modules was preliminarily analyzed, and the costs and outcomes were extrapolated so as to obtain some indications on the analysis of the whole system. When the results of the sample modules were found to be useful as well as affordable for the entire system, the resources involved were carefully distributed among the different reverse engineering tasks to meet the customer's deadline. This paper summarizes that experience, discussing how we approached the problem, the way we managed the limited resources available to complete the task within the assigned deadlines, and the lessons we learned. Copyright © 2000 John Wiley & Sons, Ltd.     

Case study: an incremental approach to re-engineering a legacy FORTRAN Computational Fluid Dynamics code in C++

This article describes a practical approach to the manual re-engineering of numerical software systems. The strategy has been applied to re-develop a medium sized FORTRAN-77 Computational Fluid Dynamics (CFD) code into C++. The motivation for software reverse-engineering is described, as are the special problems which influence the re-use of a legacy numerical code. The aim of this case study was to extract the implicit logical structure from the legacy code to form the basis of a C++ version using an imposed object-oriented design. An important secondary consideration was for the preservation of tried and tested numerical algorithms without excessive degradation of run-time performance. To this end an incremental re-engineering strategy was adopted that consisted of nine main stages, with extensive regression testing between each stage. The stages used in this development are described in this paper, with examples to illustrate the techniques employed and the problems encountered. This paper concludes with an appraisal of the development strategy used and a discussion of the central problems that have been addressed in this case study.