ASE 2016 Workshops
31st IEEE/ACM International Conference on Automated Software Engineering (ASE 2016)
Powered by
Conference Publishing Consulting

1st International Workshop on Software Refactoring (IWoR 2016), September 4, 2016, Singapore, Singapore

IWoR 2016 – Proceedings

Contents - Abstracts - Authors

1st International Workshop on Software Refactoring (IWoR 2016)


Title Page

Message from the Chairs
The first International Workshop on Refactoring (IWoR 2016) is co-located with the 31st IEEE/ACM International Conference on Automated Software Engineering (ASE 2016) and takes place on September 4, 2016 in Singapore. IWoR 2016 aims to provide an informal interactive forum for researchers and practitioners to exchange ideas and experiences, and to streamline and foster research on software refactoring, identify common ground for their work, share lessons and challenges, thereby articulating a vision for the future of software refactoring.

Architecture, Detection, and Evaluation

Refactoring for Software Architecture Smells
Ganesh Samarthyam, Girish Suryanarayana, and Tushar Sharma
(CodeOps Technologies, India; Siemens, India; Athens University of Economics and Business, Greece)
Code smells and refactoring have received considerable interest from the academia as well as from the industry in the past two decades. The interest has given birth to various tools, processes, techniques, and practices to identify smells and refactor them. Despite the high interest, architecture smells and corresponding refactorings haven't received as much focus and adoption from the software engineering community. In this paper, we motivate the need of architecture refactoring, discuss the current related research, and present a few potential research directions for architecture refactoring.

Empirical Evaluation of Code Smells in Open Source Projects: Preliminary Results
Aziz Nanthaamornphong and Apatta Chaisutanon
(Prince of Songkla University, Thailand)
Open Source Software (OSS) now plays an important role in various industry domains. OSS is generally developed by highly experienced developers who have multiple perspectives. However, previous studies have indicated that OSS has quality limitations in software maintainability. In general, OSS developers typically focus on achieving the correct functionality. In contrast, in addition to focusing on building software functionality, software engineering practices also focus on the structure of the software and on its maintainability. Code with a well-designed structure is more likely to result in high quality software. To better understand how peer code review can reduce ``code smells" in existing OSS projects, we examined comments from code reviewers that identified code smells in OSS projects. This paper is a proof-of-concept that presents the preliminary results from an analysis of comments we obtained for two OSS projects, OpenStack and WikiMedia, both of which use the code review data repository called Gerrit. The preliminary results of this ongoing research show that code reviewers comment on only a small number of code smells. The full-scale results would contribute to the empirical body of validated knowledge in the field of OSS quality and code review.

Measuring Refactoring Benefits: A Survey of the Evidence
Mel Ó Cinnéide, Aiko Yamashita, and Steve Counsell ORCID logo
(University College Dublin, Ireland; Oslo and Akershus University College of Applied Sciences, Norway; Brunel University, UK)
Refactoring has become a standard technique for software developers to use when trying to improve or evolve the design of a program. It is a key component of Agile methods, the most popular family of software development methodologies in industrial practice. Refactoring has also been the subject of much attention from researchers and many practitioner textbooks have been written on the topic. It would be natural to assume then that the benefits of refactoring would be easy agree upon, and easy to measure. In this position paper we review a selection of the empirical studies that have attempted to measure the benefits of refactoring and find the situation to be quite unclear. The evidence suggests that what motivates developers to refactor, and what benefits accrue from refactoring, are open issues that require further research.

Graph-Based Approach for Detecting Impure Refactoring from Version Commits
Shogo Tsutsumi, Eunjong Choi, Norihiro YoshidaORCID logo, and Katsuro Inoue
(Osaka University, Japan; NAIST, Japan; Nagoya University, Japan)
Impure refactoring is defined as a refactoring operation that was saved together with non-refactoring changes or several refactoring operations were saved at the same location stored in source code repositories. Many of existing approaches are not correctly viable for detecting impure refactoring. To mitigate this problem, we propose an approach that detects impure refactoring from commits stored in the repositories using a graph search algorithm. In case study, we applied our approach to two actual classes in Apache Xerces project and confirmed the feasibility of the approach.

Models and Application

Refactoring Verification using Model Transformation
Makoto Ichii, Daisuke Shimbara, Yasufumi Suzuki, and Hideto Ogawa
(Hitachi, Japan)
Software refactoring is an effective way for dealing with technical debt accumulated in a software system; however, regression risk prevents developers from refactoring their code. Herein, we propose an approach to check the equivalence of source code before and after refactoring using the AST-based model extracted from source code. In order to detect unintended changes to the program structure, our approach first transforms the model from the refactored code in accordance with the refactoring pattern so that the refactoring is cancelled, and then compares it with the model from the code before refactoring. We also built a tool named POM/EQ based on the Eclipse Modeling Framework for checking C/C++ source code. As a result of the case study using the tool, we successfully checked 56 % of the refactoring changes that are performed on an industrial product.

Automated Translation among EPSILON Languages for Performance-Driven UML Software Model Refactoring
Davide Arcelli, Vittorio Cortellessa, and Daniele Di Pompeo
(University of L'Aquila, Italy)
Although performance represents a crucial non-functional attribute of software, few model-based approaches have been introduced up today for reducing the gap between performance analysis results (e.g., mean response time) and the feedback expected by software engineers when performance problems are detected (i.e., refactoring actions). However, existing approaches aimed at performance-driven refactoring of software models suffer from fragmentation across different paradigms, languages, and meta-models.
This paper aims at reducing such fragmentation by exploiting the EPSILON environment, which provides a suite of languages for checking properties and applying refactoring on models. In particular, we introduce automation aimed at translating performance antipattern detection rules and refactoring actions among three EPSILON languages. Such automation helps to reduce code writing effort, in the context of performance-driven refactoring of UML models, while exploiting the specific support provided by the different execution semantics of considered languages.

Full Application of the Extract Interface Refactoring: Conceptual Structures in the Hands of Master Students
Marianne Huchard
(LIRMM, France; CNRS, France; University of Montpellier, France)
Interfaces are data types that are very useful for providing abstract and organized views on programs and APIs, and opportunities for writing more generic code and for reuse. Extract interface refactoring is a well known local refactoring which is commonly used in development tools. Beyond that local refactoring, there is a need for mass extraction of an interface hierarchy from a class hierarchy. In this paper, we made an experience with master students to put into practice an existing Formal Concept Analysis (FCA) based approach for solving that problem. The results show that the data selection (selected datatypes: interfaces, abstract classes, concrete classes; attributes; attribute description; methods; method description; etc.) was not obvious as it was expected to be, and that the students used the approach more as an analysis technique that would guide the extraction, than as a turn key solution.

proc time: 1.52