18.05.14 - 23.05.14, Seminar 14211
The Future of Refactoring
The following text appeared on our web pages prior to the seminar, and was included as part of the invitation.
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.