共查询到20条相似文献，搜索用时 15 毫秒
1.
Katja Cremer Andr Marburger Bernhard Westfechtel 《Journal of Software: Evolution and Process》2002,14(4):257-292
Maintenance of legacy systems is a challenging task. Often, only the source code is still available, while design or requirements documents have been lost or have not been kept up‐to‐date with the actual implementation. In particular, this applies to many business applications which are run on a mainframe computer and are written in COBOL. Many companies are confronted with the difficult task of migrating these systems to a client/server architecture with clients running on PCs and servers running on the mainframe. REforDI (REengineering for DIstribution) is a graph‐based environment supporting this task. REforDI provides integrated code analysis, re‐design, and code transformation for COBOL applications. To prepare the application for distribution, REforDI assists in the transition to an object‐based architecture, according to which the source code is subsequently transformed into Object COBOL. Internally, REforDI makes heavy use of generators to reduce the implementation effort and thus to enhance adaptability. In particular, graph‐based tools for re‐engineering are generated from a formal specification which is based on programmed graph transformations. Copyright © 2002 John Wiley & Sons, Ltd. 相似文献
2.
Rainer Koschke 《Journal of Software: Evolution and Process》2003,15(2):87-109
Software visualization is concerned with the static visualization as well as the animation of software artifacts, such as source code, executable programs, and the data they manipulate, and their attributes, such as size, complexity, or dependencies. Software visualization techniques are widely used in the areas of software maintenance, reverse engineering, and re‐engineering, where typically large amounts of complex data need to be understood and a high degree of interaction between software engineers and automatic analyses is required. This paper reports the results of a survey on the perspectives of 82 researchers in software maintenance, reverse engineering, and re‐engineering on software visualization. It describes to which degree the researchers are involved in software visualization themselves, what is visualized and how, whether animation is frequently used, whether the researchers believe animation is useful at all, which automatic graph layouts are used if at all, whether the layout algorithms have deficiencies, and—last but not least—where the medium‐term and long‐term research in software visualization should be directed. The results of this survey help to ascertain the current role of software visualization in software engineering from the perspective of researchers in these domains and give hints on future research avenues. Copyright © 2003 John Wiley & Sons, Ltd. 相似文献
3.
Jim Buckley Andrew P. LeGear Chris Exton Ross Cadogan Trevor Johnston Bill Looby Rainer Koschke 《Journal of Software: Evolution and Process》2008,20(2):107-134
Design abstractions such as components, modules, subsystems or packages are often not made explicit in the implementation of legacy systems. Indeed, often the abstractions that are made explicit turn out to be inappropriate for future evolution agendas. This can make the maintenance, evolution and refactoring of these systems difficult. In this publication, we carry out a fine‐grained evaluation of Reflexion Modelling as a technique for encapsulating user‐targeted components. This process is a prelude to component recovery, reuse and refactoring. The evaluation takes the form of two in vivo case studies, where two professional software developers encapsulate components in a large, commercial software system. The studies demonstrate the validity of this approach and offer several best‐use guidelines. Specifically, they argue that users benefit from having a strong mental model of the system in advance of Reflexion Modelling, even if that model is flawed, and that users should expend effort exploring the expected relationships present in Reflexion Models. Copyright © 2008 John Wiley & Sons, Ltd. 相似文献
4.
5.
6.
7.
Recovery‐oriented software is built with the perspective that hardware or software failures and operation mistakes are facts to be coped with, as they are problems that cannot be fully solved while developing real complex applications. Consequently, any software will always have a non‐zero chance of failure. Some of these failures may be caused by defects that may be removed or encapsulated. From the point of view of removing or encapsulating defects, a failure is considered to be trivial, when (i) the required effort to identify and eliminate or encapsulate the causing defect is small, (ii) the risk of making mistakes in these steps is also small and (iii) the consequences of the failure are tolerable. It is highly important to design systems in such a way that most (ideally all) of the failures are trivial. Such systems are called ‘debuggable systems’. In this study, we present the results of systematic applying techniques that focus on creating debuggable software for real embedded applications. Copyright © 2008 John Wiley & Sons, Ltd. 相似文献
8.
This paper describes a component‐based framework for radio‐astronomical imaging software systems. We consider optimal re‐use strategies for packages of disparate architectures brought together within a modern component framework. In this practical case study, the legacy codes include both procedural and object‐oriented architectures. We consider also the special requirements on scientific component middleware, with a specific focus on high‐performance computing. We present an example application in this component architecture and outline future development planned for this project. Copyright © 2007 John Wiley & Sons, Ltd. 相似文献
9.
Numerous large applications that have evolved over many years are well‐functioning and reliable, but have severe problems regarding flexibility and reuse. Due to the many fixes that were applied in a system's lifetime, it is often hard to customize, change or exchange system parts. Therefore, it is problematic to migrate such systems to a more flexible architecture or to new technologies. The document archive/retrieval system, discussed in this article, is an example of a large C system that had such problems. As a solution, we will sketch an architectural pattern language that involves patterns well‐suited for a piecemeal migration process. The patterns aim at building and composing highly flexible black‐box component architectures with an object‐oriented glueing layer. We present a re‐engineering case study for the document archive/retrieval system based on these patterns. The patterns are used to wrap the existing C implementations and integrate them with an object system. Moreover, the patterns introduce flexibility hooks into the hot spots of the architecture and let components define their required environment. This enables an easier future evolution of the system. The case study demonstrates a pattern language as an approach for piecemeal legacy migration apart from implementation details. Copyright © 2002 John Wiley & Sons, Ltd. 相似文献
10.
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. 相似文献
11.
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. 相似文献
12.
JULIO CESAR SAMPAIO do PRADO LEITE MARCELO SANT'ANNA ANTONIO FRANCISCO do PRADO 《Journal of Software: Evolution and Process》1997,9(1):3-31
Transformation systems have been applied in several areas of software engineering. This paper describes the use of the transformational engine Draco-PUC in porting COBOL programs. We describe the porting strategy for going from COBOL to C/C++ and give examples of such a strategy applied to a radar application and also to a payroll system. Although targeting an object-orientated language, we do not claim to generate code that strictly follows the OO guidelines. This paper gives special attention to the knowledge structure we have been using to help guide the transformation process as well as to help in the process of design recovery. © 1997 by John Wiley & Sons, Ltd. J. Software Maintenance 9: 3–31, 1997 相似文献
13.
14.
Inclusion dependency is an important data dependency in databases. Enforcement of data dependencies is a major component in any database application. Due to the nature of software development and maintenance and the limitation of database management systems (DBMSs) in handling the enforcement of inclusion dependency, many inclusion dependencies are enforced not through the DBMS, but through the transactions that update the database. It is very difficult and time consuming to elicit (to extract or to recover) inclusion dependencies from transactions manually during the reengineering, verification and maintenance of database applications. With the use of program analysis, this paper proposes a novel approach for the automated elicitation of inclusion dependencies from the source code of transactions that update the database. The approach is based on detecting program path patterns for enforcing inclusion dependency. Copyright © 2003 John Wiley & Sons, Ltd. 相似文献
15.
The grammar of the language in which some given code is written is essential for developing automated tools for maintenance, reengineering, and program analysis. Frequently grammar is available for a language but not for its variants that are implemented by various vendors and in which the given code may be written. In this work we address the problem of obtaining the grammar from source code, which can then be used for generating tools for the programs. We propose an incremental method for obtaining grammar for a particular language variant, from a set of programs written in the language variant and an approximate grammar (presumably of the standard language) with some user interaction. We also present the design of a tool for implementing this approach and our experience in working with grammars of C, C++ and COBOL. Copyright © 2004 John Wiley & Sons, Ltd. 相似文献
16.
面向对象软件的逆向工程 总被引：7，自引：0，他引：7
在现代软件工程中,逆向工程是软件维护、软件重工程、软件重用和软件重结构中的起点,它本身是一个设计知识发现、知识抽象的过程,而面向对象软件和传统软件相比有着自己的语言特点和不同的设计知识内容．通过对面向对象程序中知识类别和逆向工程过程的分析,总结出了面向对象软件逆向工程的基本知识内容,并以此为分类线索,综述了目前此领域中具有代表性的技术、工具和研究方向．最后指出了本领域将来发展的方向． 相似文献
17.
This paper reports on our experience with a relational approach to support the analysis of existing software architectures. The analysis options provide for visualization and view calculation. The approach has been applied for reverse engineering. It is also possible to check concrete designs against architecture-related rules. The paper surveys the theory, the tools and some of the applications developed so far. © 1998 John Wiley & Sons, Ltd. 相似文献
18.
基于设计模式的软件设计恢复方法研究 总被引：1，自引：0，他引：1
从源码中抽取设计模式对于提高软件可理解性和可维护性、软件设计重用以及软件重构具有重要意义.本文研究基于设计模式的软件设计恢复方法框架,并根据该框架对设计模式实例查找过程可能遇到的关键问题予以分析解答,探讨该领域未来的研究方向和趋势. 相似文献
19.
The histories of software systems hold useful information when reasoning about the systems at hand or when reasoning about general laws of software evolution. Over the past 30 years, research has been increasingly spent on understanding software evolution. However, the approaches developed so far do not rely on an explicit meta‐model and, thus, they make it difficult to reuse or compare their results. We argue that there is a need for an explicit meta‐model for software evolution analysis. We present a survey of the evolution analyses and deduce a set of requirements that an evolution meta‐model should have. We define Hismo, a meta‐model in which history is modeled as an explicit entity. Hismo adds a time layer on top of structural information, and provides a common infrastructure for expressing and combining evolution analyses and structural analyses. We validate the usefulness of our meta‐model by presenting how different analyses are expressed on it. Copyright © 2006 John Wiley & Sons, Ltd. 相似文献
20.
C反编译控制流恢复的形式描述及算法 总被引：7，自引：0，他引：7
反编译是软件逆向工程的重要组成部分。控制流恢复是Ｃ反编译的重要组成部分。本文首先描述了验证反编译结果与原程序功能等价的模型；其次从数学角度提出了Ｃ编译和反编译控制结构的数学模型并给出其性质；再次根据对Ｃ控制语句编译结果的分析，以扩展的ＢＮＦ形式描述了Ｃ控制语句反编译的约束属性方法；最后给出并说明了反编译控制流恢复的算法及其运行示例。 相似文献