Der Ausdruck wurde zu dem ersten Mal in einer Arbeit Ralph Johnson und William Opdyke 1990 gebraucht ("Refactoring: An aid in designing application frameworks and evolving object-oriented systems. In: Proceedings of Symposion on Object-Oriented Programming Emphasizing Practical Applications (SOOPPA), September 1990)). Opdyke promovierte 1992 über das Thema.

Sie entwickelten die Idee einer Software-Refactory, die das Umgestalten (eben das re-factoring) von Software-Programmen erleichtern sollte.

Die unzutreffende Übersetzung Refaktorisierung stammt aus einer Verwechslung mit einer häufig zitierten Analogie, die ursprünglich nicht Begriffsinhalt war: Refactoring ist eine Art, ein Programm so zu modifizieren, dass verborgene Strukturen offengelegt werden, ohne die Funktionaliät zu ändern: Dies, so der Analog-Schluss, entspreche dem Vorgehen der Faktorisierung von Polynomen in der Mathematik.

Refactoring dient der Verbesserung der Wartbarkeit des Designs in der Art, dass es für den Programmierer leichter wird, den bestehenden Code funktional zu erweitern oder an anderer Stelle wiederzuverwenden. Dies versucht man zu erreichen, indem man den Code bezüglich folgender Kriterien verbessert:

• Lesbarkeit, so dass möglichst viele Programmierer verstehen, was der Code tatsächlich macht
• Testbarkeit (siehe Unit-Test), so dass es möglich wird, die korrekte Arbeitsweise des Codes für die Zukunft durch Regressionstests abzusichern
• Modularität und Redundanz, so dass konkrete Problemlösungen von anderer Stelle genutzt werden können und nicht mehrfach implementiert sind

Im üblichen Softwareentwicklungszyklus ist ein fortwährender Kreislauf von Spezifikation, Design, Implementierung und Tests vorgesehen. Nach jedem Durchlauf kann das Softwareprodukt stets wieder neu in diesen Kreislauf einsteigen. Mit den klassischen Techniken hieß das jedoch, dass nach einer Änderung der Spezifikation oder einem Redesign häufig Teile oder sogar das ganze Programm völlig neu geschrieben werden mussten. Refaktorisierung erlaubt dem Entwickler diesen Zyklus permanent in dem Kleinen ablaufen zu lassen, und so sein Produkt kontinuierlich zu verbessern.

Refactoring wird ca. auf funktionierendem Code ausgeführt (dessen Funktionalität soll ja erhalten bleiben). Dies beinhaltet aber auch das Risiko, selbst etwas am Code kaputt zu machen. Um dieses Risiko zu vermeiden (oder wenigstens zu minimieren) benutzt man verschiedene Regeln, die den Prozess des Refaktorisierens ungefährlicher machen.

Zuallererst sollte man eine Reihe automatisch ablaufender Unit-Tests haben. Diese werden vor der Refaktorisierung angewandt, und man beginnt erst, wenn die Tests alle funktionieren. Dies stellt sicher, dass das Programm richtig läuft. Nach Ausführung des Refactoring wird wieder die Testsuite ausgeführt. So kann man Fehler beim Refactoring sofort erkennen.

Zusätzlich gilt das Prinzip der kleinen Änderungen. Wenn man ca. wenig verändert, dann kann man auch wenig zerstören. Meistens kann man komplexe Refaktorisierungen, die man plant, in einfache kleine Einheiten zerlegen. Vor und nach jedem Schritt wird wieder durch die Tests die Integrität des Systems geprüft.

Schließlich gibt es einen Katalog von Refactoring-Mustern, die ähnlich wie die Entwurfsmuster eingesetzt werden, um Fehler zu vermeiden. Dabei ist in jedem Muster eine Reihe von Parametern definiert. Da wäre erstmal die Absicht des Musters (Methode extrahieren, Klasse umbebezeichnen, etc.) und dazu dann eine Reihe von Arbeitsanweisungen, die für diese Aktion ausgeführt werden müssen. Viele dieser Muster können heutzutage automatisch von Werkzeugen umgesetzt werden. Man trifft als Softwareentwickler ca. noch die Entscheidung, welches Muster worauf angewendet wird, um den Quelltext zu verbessern.