Many researchers have conducted a variety of research related to clone evolution. In order to grasp how clones have evolved, clones must be tracked. However, conventional clone tracking techniques are not feasible to track clones if they moved to another location in the source code. Consequently, in this research, we propose a new clone tracking technique. The proposed technique is an enhanced version of clone tracking with clone region descriptor (CRD) proposed by Duala-Ekoko and Robillard. The proposed technique can track clones even if they moved to another location. We have implemented a software tool based on the proposed technique, and applied it to two open source systems. In the experiment, we confirmed that the proposed technique could track 44 clone groups, which the conventional CRD tracking could not track. The accuracy of the tracking for those clones was 91%.
{"title":"Enhancement of CRD-based clone tracking","authors":"Yoshiki Higo, Keisuke Hotta, S. Kusumoto","doi":"10.1145/2501543.2501548","DOIUrl":"https://doi.org/10.1145/2501543.2501548","url":null,"abstract":"Many researchers have conducted a variety of research related to clone evolution. In order to grasp how clones have evolved, clones must be tracked. However, conventional clone tracking techniques are not feasible to track clones if they moved to another location in the source code. Consequently, in this research, we propose a new clone tracking technique. The proposed technique is an enhanced version of clone tracking with clone region descriptor (CRD) proposed by Duala-Ekoko and Robillard. The proposed technique can track clones even if they moved to another location. We have implemented a software tool based on the proposed technique, and applied it to two open source systems. In the experiment, we confirmed that the proposed technique could track 44 clone groups, which the conventional CRD tracking could not track. The accuracy of the tracking for those clones was 91%.","PeriodicalId":321820,"journal":{"name":"International Workshop on Principles of Software Evolution","volume":"173 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2013-08-19","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"116553359","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}
Understanding and minimizing the impact of software changes on performance are both challenging and essential when developing software. Unfortunately, current code execution profilers do not offer efficient abstractions and adequate representations to keep track of performance across multiple versions. Consequently, understanding the cause of a slow execution stemming from a software evolution is often realized in an ad hoc fashion. We have designed Rizel, a code profiler that identifies the root of performance variations thanks to an expressive and intuitive visual representation. Rizel highlights variation of executions and time distribution between multiple software versions. Rizel is available for the Pharo programming language under the MIT License.
{"title":"Tracking performance failures with rizel","authors":"Juan Pablo Sandoval Alcocer, Alexandre Bergel","doi":"10.1145/2501543.2501549","DOIUrl":"https://doi.org/10.1145/2501543.2501549","url":null,"abstract":"Understanding and minimizing the impact of software changes on performance are both challenging and essential when developing software. Unfortunately, current code execution profilers do not offer efficient abstractions and adequate representations to keep track of performance across multiple versions. Consequently, understanding the cause of a slow execution stemming from a software evolution is often realized in an ad hoc fashion. \u0000 We have designed Rizel, a code profiler that identifies the root of performance variations thanks to an expressive and intuitive visual representation. Rizel highlights variation of executions and time distribution between multiple software versions. Rizel is available for the Pharo programming language under the MIT License.","PeriodicalId":321820,"journal":{"name":"International Workshop on Principles of Software Evolution","volume":"13 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2013-08-19","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"126326482","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}
While requirements for open source projects originate from a variety of sources like e.g. mailing lists or blogs, typically, they eventually end up as feature requests in an issue tracking system. When analyzing how these issue trackers are used for requirements evolution, we witnessed a high percentage of duplicates in a number of high-prole projects. Further investigation of six open source projects and their users led us to a number of important observations and a categorization of the root causes of these duplicates. Based on this, we propose a set of improvements for future issue tracking systems.
{"title":"An analysis of requirements evolution in open source projects: recommendations for issue trackers","authors":"P. Heck, A. Zaidman","doi":"10.1145/2501543.2501550","DOIUrl":"https://doi.org/10.1145/2501543.2501550","url":null,"abstract":"While requirements for open source projects originate from a variety of sources like e.g. mailing lists or blogs, typically, they eventually end up as feature requests in an issue tracking system. When analyzing how these issue trackers are used for requirements evolution, we witnessed a high percentage of duplicates in a number of high-prole projects. Further investigation of six open source projects and their users led us to a number of important observations and a categorization of the root causes of these duplicates. Based on this, we propose a set of improvements for future issue tracking systems.","PeriodicalId":321820,"journal":{"name":"International Workshop on Principles of Software Evolution","volume":"7 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2013-08-19","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"133227414","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}
Design degradation has long been assessed by means of structural analyses applied on successive versions of a software system. More recently, repository mining techniques have been developed in order to uncover rich historical information of software projects. In this paper, we leverage such information and propose an approach to assess design degradation that is programming language agnostic and relies almost exclusively on commit metadata. Our approach currently focuses on the assessment of two particular design smells: rigidity and fragility. Rigidity refer to designs that are difficult to change due to ripple effects and fragility refer to designs that tend to break in different areas every time a change is performed. We conducted an evaluation of our approach in the project Apache Maven 1 and the results indicated that our approach is feasible and that the project suffered from increasing fragility.
{"title":"What can commit metadata tell us about design degradation?","authors":"G. Oliva, Igor Steinmacher, I. Wiese, M. Gerosa","doi":"10.1145/2501543.2501547","DOIUrl":"https://doi.org/10.1145/2501543.2501547","url":null,"abstract":"Design degradation has long been assessed by means of structural analyses applied on successive versions of a software system. More recently, repository mining techniques have been developed in order to uncover rich historical information of software projects. In this paper, we leverage such information and propose an approach to assess design degradation that is programming language agnostic and relies almost exclusively on commit metadata. Our approach currently focuses on the assessment of two particular design smells: rigidity and fragility. Rigidity refer to designs that are difficult to change due to ripple effects and fragility refer to designs that tend to break in different areas every time a change is performed. We conducted an evaluation of our approach in the project Apache Maven 1 and the results indicated that our approach is feasible and that the project suffered from increasing fragility.","PeriodicalId":321820,"journal":{"name":"International Workshop on Principles of Software Evolution","volume":"37 3 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2013-08-19","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"125944484","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}
Model-driven engineering (MDE) is a software engineering discipline focusing on models as the primary artifacts in the software development process while programs are mainly generated by means of model-to-code transformations. In particular, modeling languages tailored to specific application domains promise to increase the productivity and quality of software development. Nevertheless due to e.g. evolving requirements, modeling languages and their meta-models evolve which means that existing models have to be migrated correspondingly. In our approach, such co-evolutions are specified as related graph transformations ensuring well-typed model migration results. Based on our earlier work on co-transformations, we now consider the automatic deduction of migration rule schemes from given meta-model evolution rules. Rule schemes form the basis for user customizations on a high abstraction level. A rule scheme deduction algorithm is presented and several customized migration schemes for different co-evolution examples are discussed.
{"title":"Customizing model migrations by rule schemes","authors":"Florian Mantz, G. Taentzer, Yngve Lamo","doi":"10.1145/2501543.2501545","DOIUrl":"https://doi.org/10.1145/2501543.2501545","url":null,"abstract":"Model-driven engineering (MDE) is a software engineering discipline focusing on models as the primary artifacts in the software development process while programs are mainly generated by means of model-to-code transformations. In particular, modeling languages tailored to specific application domains promise to increase the productivity and quality of software development. Nevertheless due to e.g. evolving requirements, modeling languages and their meta-models evolve which means that existing models have to be migrated correspondingly. In our approach, such co-evolutions are specified as related graph transformations ensuring well-typed model migration results. Based on our earlier work on co-transformations, we now consider the automatic deduction of migration rule schemes from given meta-model evolution rules. Rule schemes form the basis for user customizations on a high abstraction level. A rule scheme deduction algorithm is presented and several customized migration schemes for different co-evolution examples are discussed.","PeriodicalId":321820,"journal":{"name":"International Workshop on Principles of Software Evolution","volume":"4 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2013-08-19","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"131983176","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}
Multi-tenant systems represent a class of software-as-a-service (SaaS) applications in which several groups of users, i.e. the tenants, share the same resources. This resource sharing results in multiple business organizations using the same base application, yet, requiring specific adaptations or extensions for their specific business models. Each configuration must be tended to during evolution of a multi-tenant system, because the existing application is mended, or because new tenants request additional features. In order to facilitate the understanding of multi-tenant systems, we propose to use a runtime topology augmented with user and version information, to help understand usage patterns exhibited by tenants of the different components in the system. We introduce Serviz, our implementation of the augmented runtime topology, and evaluate it through a field user study to see to which extent Serviz aids in the analysis and understanding of a multi-tenant system.
{"title":"Understanding the interactions between users and versions in multi-tenant systems","authors":"Tiago Espinha, A. Zaidman, H. Groß","doi":"10.1145/2501543.2501551","DOIUrl":"https://doi.org/10.1145/2501543.2501551","url":null,"abstract":"Multi-tenant systems represent a class of software-as-a-service (SaaS) applications in which several groups of users, i.e. the tenants, share the same resources. \u0000 This resource sharing results in multiple business organizations using the same base application, yet, requiring specific adaptations or extensions for their specific business models. \u0000 Each configuration must be tended to during evolution of a multi-tenant system, because the existing application is mended, or because new tenants request additional features. \u0000 In order to facilitate the understanding of multi-tenant systems, we propose to use a runtime topology augmented with user and version information, to help understand usage patterns exhibited by tenants of the different components in the system. \u0000 We introduce Serviz, our implementation of the augmented runtime topology, and evaluate it through a field user study to see to which extent Serviz aids in the analysis and understanding of a multi-tenant system.","PeriodicalId":321820,"journal":{"name":"International Workshop on Principles of Software Evolution","volume":"26 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2013-08-19","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"126565050","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}
Previous research efforts have proposed various techniques for supporting code clone removal. They identify removal candidates based on the states of the source code in the latest version. However, those techniques suggest many code clones that are not suited for removal in addition to appropriate candidates. That is because the presence of code clones do not necessarily motivate developers to remove them if they are stable and do not require simultaneous modifications. In this paper, we propose a new technique that identifies removal candidates based on past records of code modifications. By using the proposed technique, we can identify code clones that actually required simultaneous modifications in the past.
{"title":"Identifying clone removal opportunities based on co-evolution analysis","authors":"Yoshiki Higo, S. Kusumoto","doi":"10.1145/2501543.2501552","DOIUrl":"https://doi.org/10.1145/2501543.2501552","url":null,"abstract":"Previous research efforts have proposed various techniques for supporting code clone removal. They identify removal candidates based on the states of the source code in the latest version. However, those techniques suggest many code clones that are not suited for removal in addition to appropriate candidates. That is because the presence of code clones do not necessarily motivate developers to remove them if they are stable and do not require simultaneous modifications. In this paper, we propose a new technique that identifies removal candidates based on past records of code modifications. By using the proposed technique, we can identify code clones that actually required simultaneous modifications in the past.","PeriodicalId":321820,"journal":{"name":"International Workshop on Principles of Software Evolution","volume":"39 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2013-08-19","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"121298221","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}
Timo Nummenmaa, Annakaisa Kultima, Kati Alha, T. Mikkonen
Computer games are a genre of software systems that in many ways differs from more traditional applications. In particular, when designing games, the end result of game development resembles work of art rather than that of engineering, emphasizing the need for creativity and artistic abilities. However, as technology, tools, methods, and artifacts that are used in the development of games are to a large extent similar to those used in the development of more traditional system, games should conform to the basic laws of software, including software evolution. In this paper, we reflect the principles of software evolution distilled by Manny Lehman in the form of laws of software evolution to the game domain. We present how the laws can be interpreted and applied in games projects, and argue that many of the laws apply to many games, but not all laws apply to all games. The way the game is evolved especially has an effect on the applicable laws as changes in games can be emerging, reactive or pre-planned.
{"title":"Applying lehman's laws to game evolution","authors":"Timo Nummenmaa, Annakaisa Kultima, Kati Alha, T. Mikkonen","doi":"10.1145/2501543.2501546","DOIUrl":"https://doi.org/10.1145/2501543.2501546","url":null,"abstract":"Computer games are a genre of software systems that in many ways differs from more traditional applications. In particular, when designing games, the end result of game development resembles work of art rather than that of engineering, emphasizing the need for creativity and artistic abilities. However, as technology, tools, methods, and artifacts that are used in the development of games are to a large extent similar to those used in the development of more traditional system, games should conform to the basic laws of software, including software evolution. In this paper, we reflect the principles of software evolution distilled by Manny Lehman in the form of laws of software evolution to the game domain. We present how the laws can be interpreted and applied in games projects, and argue that many of the laws apply to many games, but not all laws apply to all games. The way the game is evolved especially has an effect on the applicable laws as changes in games can be emerging, reactive or pre-planned.","PeriodicalId":321820,"journal":{"name":"International Workshop on Principles of Software Evolution","volume":"13 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2013-08-19","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"115353986","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 plays a key role in the overall lifecycle of a software system. In this phase, software developers extend the capabilities and functionality of the system to meet new user requirements. However, the maintenance process could rapidly lead to phenomena of "source code deterioration". The possibility to early detect bad software evolution patterns represents a paramount opportunity to keep the application maintainable. In this paper we propose a combined visualization to identify software evolution patterns related to user requirements. Such visualization consists in showing the evolution metrics of a software system together with the implementation of its requirements. We also show some examples on how this visualization could help to identify some "common" evolution patterns.
{"title":"Visual identification of software evolution patterns","authors":"Andrejs Jermakovics, M. Scotto, G. Succi","doi":"10.1145/1294948.1294956","DOIUrl":"https://doi.org/10.1145/1294948.1294956","url":null,"abstract":"Software evolution plays a key role in the overall lifecycle of a software system. In this phase, software developers extend the capabilities and functionality of the system to meet new user requirements. However, the maintenance process could rapidly lead to phenomena of \"source code deterioration\". The possibility to early detect bad software evolution patterns represents a paramount opportunity to keep the application maintainable. In this paper we propose a combined visualization to identify software evolution patterns related to user requirements. Such visualization consists in showing the evolution metrics of a software system together with the implementation of its requirements. We also show some examples on how this visualization could help to identify some \"common\" evolution patterns.","PeriodicalId":321820,"journal":{"name":"International Workshop on Principles of Software Evolution","volume":"1 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2007-09-03","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"128886563","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}
Tudor Gîrba, Stéphane Ducasse, Adrian Kuhn, Radu Marinescu, D. Ratiu
Software systems need to change over time to cope with new requirements, and due to design decisions, the changes happen to crosscut the system's structure. Understanding how changes appear in the system can reveal hidden dependencies between different entities of the system. We propose the usage of concept analysis to identify groups of entities that change in the same way and in the same time. We apply our approach at different levels of abstraction (i.e., method, class, package) and we detect fine grained changes (i.e., statements were added in a class, but no method was added there). Concept analysis is a technique that identifies entities that have the same properties, but it requires manual inspection due to the large number of candidates it detects. We propose a heuristic that dramatically eliminate the false positives. We apply our approach on two case studies and we show how we can identify hidden dependencies and detect bad smells.
{"title":"Using concept analysis to detect co-change patterns","authors":"Tudor Gîrba, Stéphane Ducasse, Adrian Kuhn, Radu Marinescu, D. Ratiu","doi":"10.1145/1294948.1294970","DOIUrl":"https://doi.org/10.1145/1294948.1294970","url":null,"abstract":"Software systems need to change over time to cope with new requirements, and due to design decisions, the changes happen to crosscut the system's structure. Understanding how changes appear in the system can reveal hidden dependencies between different entities of the system. We propose the usage of concept analysis to identify groups of entities that change in the same way and in the same time. We apply our approach at different levels of abstraction (i.e., method, class, package) and we detect fine grained changes (i.e., statements were added in a class, but no method was added there). Concept analysis is a technique that identifies entities that have the same properties, but it requires manual inspection due to the large number of candidates it detects. We propose a heuristic that dramatically eliminate the false positives. We apply our approach on two case studies and we show how we can identify hidden dependencies and detect bad smells.","PeriodicalId":321820,"journal":{"name":"International Workshop on Principles of Software Evolution","volume":"14 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2007-09-03","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"116173706","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
扫码关注我们
求助内容：
应助结果提醒方式：