Jay Kothari, A. Shokoufandeh, S. Mancoridis, A. Hassan
{"title":"Studying the Evolution of Software Systems Using Change Clusters","authors":"Jay Kothari, A. Shokoufandeh, S. Mancoridis, A. Hassan","doi":"10.1109/ICPC.2006.44","DOIUrl":"https://doi.org/10.1109/ICPC.2006.44","url":null,"abstract":"In this paper, we present an approach that examines the evolution of code stored in source control repositories. The technique identifies change clusters, which can help managers to classify different code change activities as either software maintenance or a new development. Furthermore, identifying the variations in change clusters over time exposes trends in the development of a software system. We present a case study that uses a sequence of change clusters to track the evolution of the PostgreSQL software project. Our case study demonstrates that our technique reveals interesting patterns about the progress of code development within each release of PostgreSQL. We show that the increase in the number of clusters not only identifies the areas where development has occurred, but also reflects the amount of structural change in code. We also compare how the change clusters vary over time in order to make generalizations about the focus of development","PeriodicalId":377450,"journal":{"name":"14th IEEE International Conference on Program Comprehension (ICPC'06)","volume":"2 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2006-06-14","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"128103881","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}
{"title":"Integrating Reverse Engineering Tools Using a Service-Sharing Methodology","authors":"Dean Jin, J. Cordy","doi":"10.1109/ICPC.2006.30","DOIUrl":"https://doi.org/10.1109/ICPC.2006.30","url":null,"abstract":"A common and difficult maintenance activity is the integration of existing software components or tools into a consistent and interoperable whole. One area in which this has proven particularly difficult is in the domain of software analysis and re-engineering tools, which have a relatively poor record of interoperability. This paper outlines our experience in facilitating interoperability between three such tools using OASIS, a service-sharing methodology that employs a domain ontology and specially constructed, noninvasive tool adapters","PeriodicalId":377450,"journal":{"name":"14th IEEE International Conference on Program Comprehension (ICPC'06)","volume":"1 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2006-06-14","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"124401888","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}
{"title":"Programmer-friendly Decompiled Java","authors":"Nomair A. Naeem, L. Hendren","doi":"10.1109/ICPC.2006.40","DOIUrl":"https://doi.org/10.1109/ICPC.2006.40","url":null,"abstract":"Java decompilers convert Java class files to Java source. Java class files may be created by a number of different tools including standard Java compilers, compilers for other languages such as AspectJ, or other tools such as optimizers or obfuscators. There are two kinds of Java decompilers, Javac-specific decompilers that assume that the class file was created by a standard Javac compiler and tool-independent decompilers that can decompile arbitrary class files, independent of the tool that created the class files. Typically Javac-specific decompilers produce more readable code, but they fail to decompile many class files produced by other tools. This paper tackles the problem of how to make a tool-independent decompiler, Dava, produce Java source code that is programmer-friendly. In past work it has been shown that Dava can decompile arbitrary class files, but often the output, although correct, is very different from what a programmer would write and is hard to understand. Furthermore, tools like obfuscators intentionally confuse the class files and this also leads to confusing decompiled source files. Given that Dava already produces correct Java abstract syntax trees (ASTs) for arbitrary class files, we provide a new back-end for Dava. The back-end rewrites the ASTs to semantically equivalent ASTs that correspond to code that is easier for programmers to understand. Our new back-end includes a new AST traversal framework, a set of simple pattern-based transformations, a structure-based data flow analysis framework and a collection of more advanced AST transformations that use flow analysis information. We include several illustrative examples including the use of advanced transformations to clean up obfuscated code","PeriodicalId":377450,"journal":{"name":"14th IEEE International Conference on Program Comprehension (ICPC'06)","volume":"87 1 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2006-06-14","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"132540890","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}
{"title":"An Architecture to Support Model Driven Software Visualization","authors":"R. I. Bull, M. Storey, J. Favre, Marin Litoiu","doi":"10.1109/ICPC.2006.11","DOIUrl":"https://doi.org/10.1109/ICPC.2006.11","url":null,"abstract":"Program comprehension tools are a valuable resource for navigating and understanding large software systems. Package explorers, fan-in/fan-out views, dependency graphs and coverage analysis are example contributions from the program comprehension community. While many of these research projects have lead to exciting enhancements in our field, many other projects have failed to be adopted because of poor interface design or lack of integration with existing tools. Designing, building, integrating and evaluating interfaces is a challenge to software engineering researchers. In this paper we borrow from the field of model driven engineering (MDE) to assist with the creation of highly customizable interfaces for software visualization. MDE moves the level of abstraction from implementation to design, and help improve the efficiency of building software visualizations. By moving away from implementation details, and providing researchers with the ability to customize their visualizations in an efficient manner, software engineers have more resources to design and evaluate their ideas","PeriodicalId":377450,"journal":{"name":"14th IEEE International Conference on Program Comprehension (ICPC'06)","volume":"85 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2006-06-14","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"132746585","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}
{"title":"Identification of Design Roles for the Assessment of Design Quality in Enterprise Applications","authors":"C. Marinescu","doi":"10.1109/ICPC.2006.27","DOIUrl":"https://doi.org/10.1109/ICPC.2006.27","url":null,"abstract":"The software industry is increasingly confronted with the issues of understanding and maintaining a special type of object-oriented systems, namely enterprise applications (EA). In the recent years many specific rules and patterns for the design of such applications were proposed. These new specific principles of EA design define precise roles (patterns) for classes and methods, and then describe \"good-design\" rules in terms of such roles. Yet, these roles are rarely explicitly documented; therefore, due to their importance for an efficient understanding and assessment of EA design, they must be identified and localized in the source code based on their specificities. In this paper we define a suite of techniques for the identification and location of four such roles, all related to the data source layer of an EA. Using the knowledge about these roles we show how this can improve the accuracy of formerly defined techniques for detecting two well-known design problems (i.e., data class and feature envy), making them more applicable for the usage on enterprise systems. Based on an experimental study conducted on three EAs, we prove the feasibility of the approach, discuss its benefits and touch the issues that need to be addressed in the future","PeriodicalId":377450,"journal":{"name":"14th IEEE International Conference on Program Comprehension (ICPC'06)","volume":"307 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2006-06-14","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"133757625","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}
{"title":"JIRiSS - an Eclipse plug-in for Source Code Exploration","authors":"D. Poshyvanyk, Andrian Marcus, Yubo Dong","doi":"10.1109/ICPC.2006.32","DOIUrl":"https://doi.org/10.1109/ICPC.2006.32","url":null,"abstract":"JIRiSS (information retrieval based software search for Java) is a software exploration tool that uses an indexing engine based on an information retrieval method. JIRiSS is implemented as a plug-in for Eclipse and it allows the user to search Java source code for the implementation of concepts formulated as natural language queries. The results of the query are presented as a ranked list of software methods or classes, ordered by the similarity to the user query. In addition to that, JIRiSS includes other advanced features like automatically generated software vocabulary, advanced query formulation options including spell-checking as well as fragment-based search","PeriodicalId":377450,"journal":{"name":"14th IEEE International Conference on Program Comprehension (ICPC'06)","volume":"29 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2006-06-14","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"125208751","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}
Dawn J Lawrie, Christopher Morrell, H. Feild, D. Binkley
{"title":"What’s in a Name? A Study of Identifiers","authors":"Dawn J Lawrie, Christopher Morrell, H. Feild, D. Binkley","doi":"10.1109/ICPC.2006.51","DOIUrl":"https://doi.org/10.1109/ICPC.2006.51","url":null,"abstract":"Readers of programs have two main sources of domain information: identifier names and comments. When functions are uncommented, as many are, comprehension is almost exclusively dependent on the identifier names. Assuming that writers of programs want to create quality identifiers (e.g., include relevant domain knowledge) how should they go about it? For example, do the initials of a concept name provide enough information to represent the concept? If not, and a longer identifier is needed, is an abbreviation satisfactory or does the concept need to be captured in an identifier that includes full words? Results from a study designed to investigate these questions are reported. The study involved over 100 programmers who were asked to describe twelve different functions. The functions used three different \"levels\" of identifiers: single letters, abbreviations, and full words. Responses allow the level of comprehension associated with the different levels to be studied. The functions include standard algorithms studied in computer science courses as well as functions extracted from production code. The results show that full word identifiers lead to the best comprehension; however, in many cases, there is no statistical difference between full words and abbreviations","PeriodicalId":377450,"journal":{"name":"14th IEEE International Conference on Program Comprehension (ICPC'06)","volume":"1 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2006-06-14","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"115842003","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}
{"title":"Dynamic Data Structure Analysis for Java Programs","authors":"Sokhom Pheng, Clark Verbrugge","doi":"10.1109/ICPC.2006.20","DOIUrl":"https://doi.org/10.1109/ICPC.2006.20","url":null,"abstract":"Analysis of dynamic data structure usage is useful for both program understanding and for improving the accuracy of other program analyses. Static analysis techniques, however, suffer from reduced accuracy in complex situations, and do not necessarily give a clear picture of runtime heap activity. We have designed and implemented a dynamic heap analysis system that allows one to examine and analyze how Java programs build and modify data structures. Using a complete execution trace from a profiled run of the program, we build an internal representation that mirrors the evolving runtime data structures. The resulting series of representations can then be analyzed and visualized, and we show how to use our approach to help understand how programs use data structures, the precise effect of garbage collection, and to establish limits on static data structure analysis. A deep understanding of dynamic data structures is particularly important for modern, object-oriented languages that make extensive use of heap-based data structures","PeriodicalId":377450,"journal":{"name":"14th IEEE International Conference on Program Comprehension (ICPC'06)","volume":"11 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2006-06-14","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"131470637","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}
{"title":"Classifying Change Types for Qualifying Change Couplings","authors":"B. Fluri, H. Gall","doi":"10.1109/ICPC.2006.16","DOIUrl":"https://doi.org/10.1109/ICPC.2006.16","url":null,"abstract":"Current change history analysis approaches rely on information provided by versioning systems such as CVS. Therefore, changes are not related to particular source code entities such as classes or methods but rather to text lines added and/or removed. For analyzing whether some change coupling between source code entities is significant or only minor textual adjustments have been checked in, it is essential to reflect the changes to the source code entities. We have developed an approach for analyzing and classifying change types based on code revisions. We can differentiate between several types of changes on the method or class level and assess their significance in terms of the impact of the change types on other source code entities and whether a change may be functionality-modifying or functionality-preserving. We applied our change taxonomy to a case study and found out that in many cases large numbers of lines added and/or deleted are not accompanied by significant changes but small textual adaptations (such as indentation, etc.). Furthermore, our approach allows us to relate all change couplings to the significance of the identified change types. As a result, change couplings between code entities can be qualified and less relevant couplings can be filtered out","PeriodicalId":377450,"journal":{"name":"14th IEEE International Conference on Program Comprehension (ICPC'06)","volume":"12 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2006-06-14","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"131618531","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}
{"title":"Towards a Client Driven Characterization of Class Hierarchies","authors":"Petru Florin Mihancea","doi":"10.1109/ICPC.2006.48","DOIUrl":"https://doi.org/10.1109/ICPC.2006.48","url":null,"abstract":"Object-oriented legacy systems are hard to maintain because they are hard to understand. One of the main understanding problems is revealed by the so-called \"yo-yo effect\" that appears when a developer or maintainer wants to track a polymorphic method call. At least part of this understanding problem is due to the dual nature of the inheritance relation i.e., the fact that it can he used both as a code and/or as an interface reuse mechanism. Unfortunately, in order to find out the original intention for a particular hierarchy it is not enough to look at the hierarchy itself; rather than that, an in-depth analysis of the hierarchy's clients is required. In this paper we introduce a new metrics-based approach that helps us characterize the extent to which a base class was intended for interface reuse, by analyzing how clients use the interface of that base class. The idea of the approach is to quantify the extent to which clients treat uniformly the instances of the descendants of the base class, when invoking methods belonging to this common interface, We have evaluated our approach on two medium-sized case studies and we have found that the approach does indeed help to characterize the nature of a base class with respect to interface reuse. Additionally, the approach can be used to detect some interesting patterns in the way clients actually use the descendants through the interface of the base class","PeriodicalId":377450,"journal":{"name":"14th IEEE International Conference on Program Comprehension (ICPC'06)","volume":"43 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2006-06-14","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"129081911","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}