These patterns are intended to be used by the community so it is the community the best suited for decide their content.
"By definition, you only refactor code that is already working, which where I come from is scary. Working code is a valuable asset since it is hard to get right (...) and takes time. Touching working code is always a risk and so there should be a darned good reason for doing it" .
Backtrack If Refactoring Fails
How do you assure the quick recovery of the code in case the refactoring process introduces irreversible changes?
You are applying refactorings as the source code evolves. You followed RefactoringInVerySmallSteps
, but the volume of changes involved in each refactoring is big enough that the code cannot be taken to its original position in a simple way.
- Rewriting a code may cause an unjustified backwardness in the work schedule.
- Rewriting a code may cause the appearance of new errors in the system.
- The programming team do not want to alter a code section after it is functionally correct.
- Rolling back a source code that is connected to external data sources may cause unexpected results.
Maintain backup copies of the state of the code before applying refactorings. Use version control systems to carry out this activity. A common routine to follow can be: check out the code to be changed, apply the refactoring, test the changed code, and then, if things went well, commit the new version, otherwise roll back the changes.
Keeping backup copies of the source code using version control systems offers a safe method to carry out refactorings without fear to lose the functionality already programmed. If your refactoring is defective, you can back out the adjustments, so you'll never need to rewrite already programmed code.
You should pay special attention to rolling back a source code that is connected with external data sources, because there are no clear ways to roll back them to the point that matched the code rollback without significant data loss or, sometimes, there is no way to synthesize previously required data from newer data sets.
"Program testing is an effective and practical way of improving correctness of software (...)" , however, "(...) no system can be completely tested" . Therefore, there are no mechanisms to assure that after applying refactorings, errors will not be introduced in the code in a manner that they can't be detected by existent tests. The development team needs this pattern to be sure that refactorings will not decompose the performed work. This pattern breaks the barrier created by fear and allows people to run the risk of applying refactorings.
William Opdyke in his doctoral thesis  exposed "one way to prevent errors from happening would be to save the current version of a program before each refactoring, apply the refactoring (...), and then recompile the program. If an error is flagged, fall back to the old version".
In the WIKI pages about refactoring, Falk Bruegmann wrote "(...) make sure you can rollback the refactoring without to much work in case the tests do fail. (...) at least for larger changes, have a backup copy of the state of your program (...)" .
- Bill Trost from Portland, Oregon.
- Falk Bruegmann from Munich, Germany.
- Glyph Lefkowitc from 
- Toivo Lainevool from 
- Garry Hamiltom from Carson City, Nevada.
 Robert X. Cringely. Refactoring Refactoring: Sometimes (Even in Computer Programming) What Everyone Knows Isn't Always Correct. Available at: http://www.pbs.org/cringely/pulpit/pulpit20030508.html
. 2003. Last confirmed: July 01, 2004.
 William F. Opdyke. Refactoring Object-Oriented Frameworks. PhD Thesis, University of Illinois. Urbana, Illinois, 1992.
 Yoonsik Cheon, Gary T. Leavens. A Simple and Practical Approach to Unit Testing: The JML and JUnit Way. Proceedings of 16th European Conference Object-Oriented Programming (ECOOP), pp. 231-255. 2002.
 Ivar Jacobson, Grady Booch, James Rumbaugh. El Proceso Unificado de Desarrollo de Software. Addison - Wesley, 2000.
 Wiki Pages About Refactoring. Available at: http://c2.com/cgi/wiki?WikiPagesAboutRefactoring
. Last confirmed: June 26, 2004.
May I also point out that there is more to this than the code.
Particularly troublesome are the changes often made to the data stored and retrieved by the code. This is often, but not always, database storage. Spectacular failures have occurred where the code has been rolled back, yet there was no clear way to roll back the database(s) to the point that matched the code rollback, without significant data loss or, sometimes, no way to synthesize previously required data from newer data sets.
I would suggest that this issue is at least as important as simple preservation of the code.
Your comments were included as a force
of the above pattern. Also, there is an explanation in the resulting context
section. You can see your name as part of the Acknowledgments
The idea of backtracking assumes your working with something like a HEAD revision in your VersionControl
. In something like SubVersion
, you could just branch at the start of your Refactoring, and only MergeChanges?
back to your HEAD if they are successful. You just delete your branch if your refactoring fails.
This gives you a Transactional style approach
Yes Kevin. That should be a mechanic to follow this pattern.