Dagstuhl Seminar 14211
The Future of Refactoring
( May 18 – May 23, 2014 )
(Click in the middle of the image to enlarge)
Permalink
Please use the following short url to reference this page:
https://www.dagstuhl.de/14211
Organizers
- Danny Dig (Oregon State University, US)
- William G. Griswold (University of California - San Diego, US)
- Emerson Murphy-Hill (North Carolina State University - Raleigh, US)
- Max Schaefer (Semmle Ltd. - Oxford, GB)
Contact
- Annette Beyer (for administrative matters)
Schedule
Modern software is rarely written from scratch. Instead, it usually incorporates code from previous systems, and is itself reincarnated in other programs. Modern software is also not static. Instead, it constantly changes as bugs are fixed and features added. Usually these changes are performed by more than one programmer, and not necessarily by the original authors of the code.
Refactoring is a technique for supporting this highly dynamic software life cycle. At its most basic, refactoring is the process of improving the internal structure of an existing piece of code without altering its external behavior. It can be used for cleaning up legacy code, for program understanding, and as a preparation for bug fixes or for adding new features. While any behavior-preserving change to a program can be considered a refactoring, many particularly useful and frequently recurring refactoring operations have been identified and catalogued. Over the past decade, popular development environments have started providing automated support for performing these common refactorings, making the process of refactorings less tedious and error-prone.
Traditionally, automated refactoring has been associated with interactive source-to-source transformation tools that preserve existing behavior while improving the program design. However, a similar approach can be taken to improve many other non-functional qualities. One example of this is performance: in the multicore era, a major programming task is to make existing sequential programs parallel. A possible approach to parallelizing an existing sequential program is to rewrite it from scratch. However, the most common way is to parallelize a program incrementally, by changing the existing code. Each small step can be seen as a behavior-preserving transformation, i.e., a refactoring. While refactoring is more economical than rewriting, it is still tedious because it requires consistently changing many lines of code, and it is error-prone and non-trivial because programmers need to ensure non-interference of parallel operations. This is one area where refactoring tools can help.
There is a tremendous interest in embracing a refactoring approach for transformations related to concurrency, parallelism, mobile platforms, web-based and cloud computing, GPUs, etc. Research questions to be answered include: What are the common, tedious, error-prone refactorings that programmers use to change real-world programs for their respective domains? How can we automate such refactorings to improve programmer productivity and software quality? Given that there are so many possibly new domains for refactoring, can we simplify the development of new refactoring tools to make it possible for programmers to implement their own domain-specific refactorings? How can we improve programmer experience in using refactoring tools? How can we support programmers in using refactoring tools more often and more effectively? How can we improve the reliability of refactoring tools? How can we improve programmers' knowledge of refactoring? How can we support refactoring in new languages?
This Dagstuhl Seminar aims to bring together experts in the field to consider these and other questions, to map out the future of refactoring and push it into novel domains.
The Dagstuhl seminar on "The Future of Refactoring" brought together 41 researchers and practitioners from academia and industry working on different aspects of refactoring. Participants had the opportunity to introduce their own work both in short plenary talks and more detailed presentations during breakout sessions, with daily keynote talks by eminent refactoring researchers providing historical background. Given the rapid growth of the field over the past decade, special emphasis was put on providing opportunities for researchers with similar interests to meet and survey the state of the art, identify open problems and research opportunities, and jointly chart the future of refactoring research.
We believe the seminar achieved its goal of providing a forum for in-depth discussion of recent research in the area, and of fostering collaboration. In particular, it kickstarted several collaborative projects, among them a book on refactoring tools, a special journal issue on refactoring and a survey article on refactoring research over the last decade.
Research Context
Modern software is rarely written from scratch. Instead, it usually incorporates code from previous systems, and is itself reincarnated in other programs. Modern software is also not static. Instead, it constantly changes as bugs are fixed and features added, and usually these changes are performed by more than one programmer, and not necessarily by the original authors of the code.
Refactoring is a technique for supporting this highly dynamic software life cycle. At its most basic, refactoring is the process of improving the internal structure of an existing piece of code without altering its external behavior. It can be used for cleaning up legacy code, for program understanding, and as a preparation for bug fixes or for adding new features. While any behavior-preserving change to a program can be considered a refactoring, many particularly useful and frequently recurring refactoring operations have been identified and catalogued. Over the past decade, popular development environments have started providing automated support for performing common refactorings, making the process of refactoring less tedious and error-prone.
Based on the accumulated experience with refactorings both in practical applications and in research, this seminar aimed to identify open problems and challenges and to foster collaboration between researchers and between academia and industry to address these issues and actively shape the future of refactoring.
Seminar Format
Given the large number of participants, the standard conference format with one in-depth talk per participant would have been impractical. Instead, we decided to split up the schedule: during the first three days, the mornings were allocated to plenary sessions. Each day began with a keynote by a distinguished speaker with decades of experience with refactoring, in which they presented their perspective on refactoring. The rest of the morning was allocated to "lightning talks" where each participant was given a 7-minute presentation slot for providing a quick, high-level overview of their work without getting bogged down in detail, followed by a few minutes for questions. While this format was not easy for the speakers, everyone rose to the challenge, and reactions from both presenters and audience were broadly positive.
Monday afternoon was given over to four parallel breakout sessions organized along thematic lines: novel domains for refactoring, user experience in refactoring, refactoring tools and meta-tools, and refactoring in education. While participants appreciated the opportunity for more in-depth presentations and discussion, this format had the unfortunate but inevitable drawback that several talks were held in parallel, and not everyone was able to attend all the talks they were interested in.
Tuesday afternoon had an industry panel, followed by another round of breakout sessions. Discussion and exchange continued in an informal setting during Wednesday afternoon's excursion to Mettlach.
On Thursday morning, we had another keynote followed by a final round of breakout sessions. While the focus of the breakout sessions on Monday and Tuesday had been on surveying recent work and getting an overview of the state of the art, Thursday's sessions were aimed at gathering together the threads, and identifying common themes, open problems and research opportunities.
The outcome of these group discussions were then briefly presented in a plenary on Thursday afternoon, and opportunities for collaborative projects were identified. Specifically, the following projects were discussed and planned in group discussions on Thursday afternoon:
- a book on refactoring tools;
- a special issue of IEEE Software on refactoring;
- a survey paper on refactoring research in the last decade;
- an informal working group on the place of refactoring in the Computer Science curriculum.
Friday morning saw a final plenary discussion, summarizing the project discussions of Thursday afternoon and ending with a retrospective session on which aspects of the seminar are worth keeping for the future, what needs to change, and what still puzzles us.
We hired George Platts, a professional artist, to facilitate games he designed and tangential thinking activities to help the participants develop a sense of scientific community. During each of the five days of the Seminar, George ran 30-minute games sessions at the beginning of the day which doubled as times for announcements to be given and daily reports to be delivered. In the early afternoon, we had a 30-minute game session to energize participants for the afternoon's workshops. For the rest of the time in his 'studio', he has been playing music, showing short films, facilitating drawing and painting activities, composing sound composition for all participants to perform.
Creative Commons BY 3.0 Unported license
Danny Dig, William G. Griswold, Emerson Murphy-Hill, and Max Schaefer
- Don Batory (University of Texas - Austin, US) [dblp]
- Ira D. Baxter (Semantic Designs - Austin, US) [dblp]
- Andrew P. Black (Portland State University, US) [dblp]
- Robert Bowdidge (Google Inc. - Mountain View, US) [dblp]
- John Brant (The Refactory Inc. - Urbana, US) [dblp]
- Caius Brindescu (Oregon State University, US) [dblp]
- Marcio Cornelio (Federal University of Pernambuco - Recife, BR) [dblp]
- Stephan Diehl (Universität Trier, DE) [dblp]
- Danny Dig (Oregon State University, US) [dblp]
- Ran Ettinger (Ben Gurion University - Beer Sheva, IL) [dblp]
- Alejandra Garrido (University of La Plata, AR) [dblp]
- Rohit Gheyi (Universidade Federal - Campina Grande, BR) [dblp]
- William G. Griswold (University of California - San Diego, US) [dblp]
- Shinpei Hayashi (Tokyo Institute of Technology, JP) [dblp]
- Felienne Hermans (TU Delft, NL) [dblp]
- Jongwook Kim (University of Texas - Austin, US) [dblp]
- Huiqing Li (University of Kent, GB) [dblp]
- Francesco Logozzo (Microsoft Corporation - Redmond, US) [dblp]
- Kim Mens (University of Louvain, BE) [dblp]
- Tom Mens (University of Mons, BE) [dblp]
- Naouel Moha (University of Quebec - Montreal, CA) [dblp]
- Emerson Murphy-Hill (North Carolina State University - Raleigh, US) [dblp]
- Oscar M. Nierstrasz (Universität Bern, CH) [dblp]
- Bill Opdyke (JP Morgan Chase - Chicago, US) [dblp]
- Christopher J. Parnin (Georgia Institute of Technology - Atlanta, US) [dblp]
- Javier Perez (University of Antwerp, BE) [dblp]
- Veselin Raychev (ETH Zürich, CH) [dblp]
- Don Roberts (University of Evansville, US) [dblp]
- Max Schaefer (Semmle Ltd. - Oxford, GB) [dblp]
- Gustavo Soares (Universidade Federal - Campina Grande, BR) [dblp]
- Peter Sommerlad (Hochschule für Technik - Rapperswil, CH) [dblp]
- Friedrich Steimann (Fernuniversität in Hagen, DE) [dblp]
- Kathryn T. Stolee (Iowa State University - Ames, US) [dblp]
- Volker Stolz (University of Oslo, NO) [dblp]
- Simon J. Thompson (University of Kent, GB) [dblp]
- Eli Tilevich (Virginia Polytechnic Institute - Blacksburg, US) [dblp]
- Frank Tip (University of Waterloo, CA) [dblp]
- Mohsen Vakilian (University of Illinois - Urbana-Champaign, US) [dblp]
- Jurgen J. Vinju (CWI - Amsterdam, NL) [dblp]
- Louis Wasserman (Google Inc. - Mountain View, US) [dblp]
- Jan Wloka (IBM Research GmbH - Zürich, CH) [dblp]
Classification
- programming languages / compiler
- software engineering
Keywords
- refactoring
- program analysis
- program transformation
- software evolution
- reengineering
- software restructuring
- code smells
