Most traditional reverse engineering tools focus on abstraction and analysis of source code, presenting a visual representation of the software architecture. This approach can be both helpful and cost effective in software maintenance tasks. However, where large software teams are concerned, with moderate levels of employee turnover, traditional reverse engineering tools can be inadequate. To address this issue, we examine the use of software process data, such as software artifact change history and developer activities. We propose the application of this data confers additional information developers need to better understand, maintain and develop software in large team settings. To explore this hypothesis, we evaluate the use of a tool, Xia, in the navigation of both software artifacts and their version history. This work introduces Xia, reveals the results of our evaluation and proposes directions for future research in this area.
{"title":"A reverse engineering approach to support software maintenance: version control knowledge extraction","authors":"Xiaomin Wu, Adam Murray, M. Storey, R. Lintern","doi":"10.1109/WCRE.2004.8","DOIUrl":"https://doi.org/10.1109/WCRE.2004.8","url":null,"abstract":"Most traditional reverse engineering tools focus on abstraction and analysis of source code, presenting a visual representation of the software architecture. This approach can be both helpful and cost effective in software maintenance tasks. However, where large software teams are concerned, with moderate levels of employee turnover, traditional reverse engineering tools can be inadequate. To address this issue, we examine the use of software process data, such as software artifact change history and developer activities. We propose the application of this data confers additional information developers need to better understand, maintain and develop software in large team settings. To explore this hypothesis, we evaluate the use of a tool, Xia, in the navigation of both software artifacts and their version history. This work introduces Xia, reveals the results of our evaluation and proposes directions for future research in this area.","PeriodicalId":443491,"journal":{"name":"11th Working Conference on Reverse Engineering","volume":"18 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2004-11-08","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"125392712","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
In the presence of undocumented and unfamiliar hardware, the process of program comprehension becomes more complex. To perform maintenance activities, programmers must understand the functioning of each element independently, as well as their interactions. We examine the process taken by the first author during the analysis, porting and re-implementation of a software system that has a heavy reliance on undocumented customized hardware interfaces. This process also demonstrates the use of a two-phase approach when migrating a mission-critical software system. The software was first ported to a new platform running a semi-compatible BASIC interpreter (phase I) before a complete re-implementation was performed (phase 2). The experiences, strategies used, and lessons learned during the process are reported here.
{"title":"Combined software and hardware comprehension in reverse engineering","authors":"P. Roche, Anthony Cox","doi":"10.1109/WCRE.2004.16","DOIUrl":"https://doi.org/10.1109/WCRE.2004.16","url":null,"abstract":"In the presence of undocumented and unfamiliar hardware, the process of program comprehension becomes more complex. To perform maintenance activities, programmers must understand the functioning of each element independently, as well as their interactions. We examine the process taken by the first author during the analysis, porting and re-implementation of a software system that has a heavy reliance on undocumented customized hardware interfaces. This process also demonstrates the use of a two-phase approach when migrating a mission-critical software system. The software was first ported to a new platform running a semi-compatible BASIC interpreter (phase I) before a complete re-implementation was performed (phase 2). The experiences, strategies used, and lessons learned during the process are reported here.","PeriodicalId":443491,"journal":{"name":"11th Working Conference on Reverse Engineering","volume":"1 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2004-11-08","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"126618438","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
The issues of code scattering and tangling, thus of achieving a better modularity for a system's concerns, are addressed by the paradigm of aspect orientation. Aspect mining is a reverse engineering process that aims at finding crosscutting concerns in existing systems. This work describes a technique based on determining methods that are called from many different places (and hence have a high fan-in) to identify candidate aspects in a number of open-source Java systems. The most interesting aspects identified are discussed in detail, which includes several concerns not previously discussed in the aspect-oriented literature. The results show that a significant number of aspects can be recognized using fan-in analysis, and that the technique is suitable for a high degree of automation.
{"title":"Identifying aspects using fan-in analysis","authors":"M. Marin, A. Deursen, L. Moonen","doi":"10.1109/WCRE.2004.23","DOIUrl":"https://doi.org/10.1109/WCRE.2004.23","url":null,"abstract":"The issues of code scattering and tangling, thus of achieving a better modularity for a system's concerns, are addressed by the paradigm of aspect orientation. Aspect mining is a reverse engineering process that aims at finding crosscutting concerns in existing systems. This work describes a technique based on determining methods that are called from many different places (and hence have a high fan-in) to identify candidate aspects in a number of open-source Java systems. The most interesting aspects identified are discussed in detail, which includes several concerns not previously discussed in the aspect-oriented literature. The results show that a significant number of aspects can be recognized using fan-in analysis, and that the technique is suitable for a high degree of automation.","PeriodicalId":443491,"journal":{"name":"11th Working Conference on Reverse Engineering","volume":"304 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2004-11-08","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"116100977","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
Philippe Thiran, G. Houben, Jean-Luc Hainaut, D. Benslimane
Wrapping databases allows them to be reused in earlier unforeseen contexts, such as Web-based applications or federated systems. Data wrappers, and more specifically updating wrappers (that not only access legacy data but also update them), can provide external clients of an existing (legacy) database with a neutral interface and augmented capabilities. For instance, a collection of COBOL files can be wrapped in order to allow external application programs to access them through a relational, object-oriented or XML interface, while providing referential integrity control. We explore the principles of a wrapper architecture that addresses the problems of legacy data consistency management. The transformational paradigm is used as a rigorous formalism to define schema mappings as well as to generate as much as possible of the code of the wrappers. The generation is supported by an operational CASE tool.
{"title":"Updating legacy databases through wrappers: data consistency management","authors":"Philippe Thiran, G. Houben, Jean-Luc Hainaut, D. Benslimane","doi":"10.1109/WCRE.2004.41","DOIUrl":"https://doi.org/10.1109/WCRE.2004.41","url":null,"abstract":"Wrapping databases allows them to be reused in earlier unforeseen contexts, such as Web-based applications or federated systems. Data wrappers, and more specifically updating wrappers (that not only access legacy data but also update them), can provide external clients of an existing (legacy) database with a neutral interface and augmented capabilities. For instance, a collection of COBOL files can be wrapped in order to allow external application programs to access them through a relational, object-oriented or XML interface, while providing referential integrity control. We explore the principles of a wrapper architecture that addresses the problems of legacy data consistency management. The transformational paradigm is used as a rigorous formalism to define schema mappings as well as to generate as much as possible of the code of the wrappers. The generation is supported by an operational CASE tool.","PeriodicalId":443491,"journal":{"name":"11th Working Conference on Reverse Engineering","volume":"26 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2004-11-08","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"129284738","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
Andrian Marcus, A. Sergeyev, V. Rajlich, Jonathan I. Maletic
Concept location identifies parts of a software system that implement a specific concept that originates from the problem or the solution domain. Concept location is a very common software engineering activity that directly supports software maintenance and evolution tasks such as incremental change and reverse engineering. This work addresses the problem of concept location using an advanced information retrieval method, Latent Semantic Indexing (LSI). LSI is used to map concepts expressed in natural language by the programmer to the relevant parts of the source code. Results of a case study on NCSA Mosaic are presented and compared with previously published results of other static methods for concept location.
{"title":"An information retrieval approach to concept location in source code","authors":"Andrian Marcus, A. Sergeyev, V. Rajlich, Jonathan I. Maletic","doi":"10.1109/WCRE.2004.10","DOIUrl":"https://doi.org/10.1109/WCRE.2004.10","url":null,"abstract":"Concept location identifies parts of a software system that implement a specific concept that originates from the problem or the solution domain. Concept location is a very common software engineering activity that directly supports software maintenance and evolution tasks such as incremental change and reverse engineering. This work addresses the problem of concept location using an advanced information retrieval method, Latent Semantic Indexing (LSI). LSI is used to map concepts expressed in natural language by the programmer to the relevant parts of the source code. Results of a case study on NCSA Mosaic are presented and compared with previously published results of other static methods for concept location.","PeriodicalId":443491,"journal":{"name":"11th Working Conference on Reverse Engineering","volume":"1 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2004-11-08","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"128505458","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
A key problem during software development and maintenance is to detect and recognize recurring collaborations among software artifacts that are implicit in the code. These collaboration patterns are typically signs of applied idioms, conventions and design patterns during the development of the system, and may entail implicit contracts that should be respected during maintenance, but are not documented explicitly. We apply formal concept analysis to detect implicit collaboration patterns. Our approach generalizes Antoniol and Tonella one for detecting classical design patterns. We introduce a variation to their algorithm to reduce the computation time of the concepts, a language-independent approach for object-oriented languages, and a post-processing phase in which pattern candidates are filtered out. We identify collaboration patterns in the analyzed applications, match them against libraries of known design patterns, and establish relationships between detected patterns and their nearest neighbours.
{"title":"Detecting implicit collaboration patterns","authors":"G. Arévalo, F. Buchli, Oscar Nierstrasz","doi":"10.1109/WCRE.2004.18","DOIUrl":"https://doi.org/10.1109/WCRE.2004.18","url":null,"abstract":"A key problem during software development and maintenance is to detect and recognize recurring collaborations among software artifacts that are implicit in the code. These collaboration patterns are typically signs of applied idioms, conventions and design patterns during the development of the system, and may entail implicit contracts that should be respected during maintenance, but are not documented explicitly. We apply formal concept analysis to detect implicit collaboration patterns. Our approach generalizes Antoniol and Tonella one for detecting classical design patterns. We introduce a variation to their algorithm to reduce the computation time of the concepts, a language-independent approach for object-oriented languages, and a post-processing phase in which pattern candidates are filtered out. We identify collaboration patterns in the analyzed applications, match them against libraries of known design patterns, and establish relationships between detected patterns and their nearest neighbours.","PeriodicalId":443491,"journal":{"name":"11th Working Conference on Reverse Engineering","volume":"7 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2004-11-08","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"114237880","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
Software evolution can result in making a program harder to maintain, as it becomes more difficult to comprehend. This difficulty is related to the way the source code is formatted, the complexity of the code, and the amount of information contained within it. This work presents an initial approach that uses measures of typographical style, spatial complexity and concept assignment to measure these factors, and to model the comprehensibility of an evolving program. The ultimate aim of which is to identify when a program becomes more difficult to comprehend, triggering a corrective action to be taken to prevent this. We present initial findings from applying this approach. These findings show that this approach, through measuring these three factors, can model the change in comprehensibility of an evolving program. Our findings support the well-known claim that programs become more complex as they evolve, explaining this increase in complexity in terms of layout changes, conceptual coherence, spatial relationships between source code elements, and the relationship between these factors. This in turn can then be used to understand how maintenance affects program comprehensibility and to ultimately reduce its burden on software maintenance.
{"title":"An initial approach to assessing program comprehensibility using spatial complexity, number of concepts and typographical style","authors":"A. Mohan, N. Gold, P. Layzell","doi":"10.1109/WCRE.2004.11","DOIUrl":"https://doi.org/10.1109/WCRE.2004.11","url":null,"abstract":"Software evolution can result in making a program harder to maintain, as it becomes more difficult to comprehend. This difficulty is related to the way the source code is formatted, the complexity of the code, and the amount of information contained within it. This work presents an initial approach that uses measures of typographical style, spatial complexity and concept assignment to measure these factors, and to model the comprehensibility of an evolving program. The ultimate aim of which is to identify when a program becomes more difficult to comprehend, triggering a corrective action to be taken to prevent this. We present initial findings from applying this approach. These findings show that this approach, through measuring these three factors, can model the change in comprehensibility of an evolving program. Our findings support the well-known claim that programs become more complex as they evolve, explaining this increase in complexity in terms of layout changes, conceptual coherence, spatial relationships between source code elements, and the relationship between these factors. This in turn can then be used to understand how maintenance affects program comprehensibility and to ultimately reduce its burden on software maintenance.","PeriodicalId":443491,"journal":{"name":"11th Working Conference on Reverse Engineering","volume":"39 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2004-11-08","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"123444776","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
We evaluate the benefits of applying aspect-oriented software development techniques in the context of a large-scale industrial embedded software system implementing a number of crosscutting concerns. Additionally, we assess the feasibility of automatically extracting these crosscutting concerns from the source code. In order to achieve this, we present an approach for reverse engineering aspects from an ordinary application automatically. This approach incorporates both a concern verification and an aspect construction phase. Our results show that such automated support is feasible, and can lead to significant improvements in source code quality.
{"title":"An initial experiment in reverse engineering aspects","authors":"M. Bruntink, A. Deursen, T. Tourwé","doi":"10.1109/WCRE.2004.12","DOIUrl":"https://doi.org/10.1109/WCRE.2004.12","url":null,"abstract":"We evaluate the benefits of applying aspect-oriented software development techniques in the context of a large-scale industrial embedded software system implementing a number of crosscutting concerns. Additionally, we assess the feasibility of automatically extracting these crosscutting concerns from the source code. In order to achieve this, we present an approach for reverse engineering aspects from an ordinary application automatically. This approach incorporates both a concern verification and an aspect construction phase. Our results show that such automated support is feasible, and can lead to significant improvements in source code quality.","PeriodicalId":443491,"journal":{"name":"11th Working Conference on Reverse Engineering","volume":"42 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2004-11-08","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"130925930","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
Many legacy systems are built on the technology of dynamic link libraries. Software engineering tools have not exploited this framework very well. Because the linking is delayed until runtime, it seems natural to provide tools access to the linking process, in order to track it, and even to modify it. There is no reason the dynamic linker must resolve a symbol to the intended function. To this end we have created DDL (the Dynamic Dynamic Linker) by modifying the Gnu dynamic linker to provide an API for developers to use to customize the linking process. We believe that DDL will be useful for a wide variety of software engineering tasks, not the least of which is the reverse engineering of legacy systems, and their maintenance and modification. We present a case study of one such task. This task is the understanding and modification of the SimpleScalar CPU/architectural simulator. We were able to use DDL to understand the behavior of SimpleScalar at a function-call level, and then used DDL to modify the run-time behavior (without modifying the functional source code) to implement the switching between detailed and functional simulation modes (an important extension to the community).
{"title":"Using DDL to understand and modify SimpleScalar","authors":"Naoman Abbas, Sumant Tambe, J. Cook","doi":"10.1109/WCRE.2004.43","DOIUrl":"https://doi.org/10.1109/WCRE.2004.43","url":null,"abstract":"Many legacy systems are built on the technology of dynamic link libraries. Software engineering tools have not exploited this framework very well. Because the linking is delayed until runtime, it seems natural to provide tools access to the linking process, in order to track it, and even to modify it. There is no reason the dynamic linker must resolve a symbol to the intended function. To this end we have created DDL (the Dynamic Dynamic Linker) by modifying the Gnu dynamic linker to provide an API for developers to use to customize the linking process. We believe that DDL will be useful for a wide variety of software engineering tasks, not the least of which is the reverse engineering of legacy systems, and their maintenance and modification. We present a case study of one such task. This task is the understanding and modification of the SimpleScalar CPU/architectural simulator. We were able to use DDL to understand the behavior of SimpleScalar at a function-call level, and then used DDL to modify the run-time behavior (without modifying the functional source code) to implement the switching between detailed and functional simulation modes (an important extension to the community).","PeriodicalId":443491,"journal":{"name":"11th Working Conference on Reverse Engineering","volume":"1 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2004-11-08","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"125437739","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
Despite their 40 year history, native executable decompilers have found very limited practical application in commercial projects. The success of Java decompilers is well known, and a few decompilers perform well by recognising patterns from specific compilers. This work describes the experience gained from applying a native executable decompiler, assisted by a commercial disassembler and hand editing, to a real-world Windows-based application. The clients had source code for a prototype version of the program, and an executable that performed better, for which the source code was not available. The project was to recover the algorithm at the core of the program, and if time permitted, the recovery of other pieces of source code. Despite the difficulties, the core algorithm was successfully decompiled, and a portion of the rest of the program as well. There were surprises, including the ability to recover almost all original class names, and the complete class hierarchy.
{"title":"Using a decompiler for real-world source recovery","authors":"M. Emmerik, T. Waddington","doi":"10.1109/WCRE.2004.42","DOIUrl":"https://doi.org/10.1109/WCRE.2004.42","url":null,"abstract":"Despite their 40 year history, native executable decompilers have found very limited practical application in commercial projects. The success of Java decompilers is well known, and a few decompilers perform well by recognising patterns from specific compilers. This work describes the experience gained from applying a native executable decompiler, assisted by a commercial disassembler and hand editing, to a real-world Windows-based application. The clients had source code for a prototype version of the program, and an executable that performed better, for which the source code was not available. The project was to recover the algorithm at the core of the program, and if time permitted, the recovery of other pieces of source code. Despite the difficulties, the core algorithm was successfully decompiled, and a portion of the rest of the program as well. There were surprises, including the ability to recover almost all original class names, and the complete class hierarchy.","PeriodicalId":443491,"journal":{"name":"11th Working Conference on Reverse Engineering","volume":"28 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2004-11-08","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"127896164","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
京公网安备 11010802042870号
京ICP备2023020795号-1
扫码关注我们
求助内容：
应助结果提醒方式：