What is "Refactoring" and How Does it Apply to Theology?

Refactoring is a concept borrowed from Agile software development methodology.  Without getting technical, refactoring is the process of reworking a program after it is debugged in order to simplify and streamline the syntax and logic as much as possible without sacrificing the required functionality.  The theory is that too often, software is made needlessly complex because developers try to anticipate all future contingencies, no matter how unlikely they might be or because they borrow code from similar projects without removing the extraneous bits that aren't required.  This complexity can, and often does, increase the likelihood of defects and makes the code much more difficult to maintain in the long term.

In short, developers have been trained to think that the more complex and abstract the code, the better it will be for the customer and for future extensibility.  Unfortunately, this is more often not true.  Studies have shown that the reverse is true.  Developers can rarely anticipate future requirements accurately, so all the work and overhead added to the code ultimately serves no useful purpose and even hinders the evolution of the code when new functionality is required.

So, how are theologians trained?  In systematic theology, students learn to work within frameworks that attempt to not only address the entirety of the cosmos, the human condition, and ethics, but to also be adaptable to any future ethical or social reality that may not, at that time exist.  The result is a dense collection of theological arguments that must, in the end, get more nuanced and more complex as each generation's issues and realities challenge the systemitician's assumptions.  Sounds familiar?

This blog will begin to outline a process that strives to create the simplest working theological concepts and then, as new areas issues and challenges are considered, find ways to apply them to the theology without adding needly complexity.  In fact, the goal and challenge will be to find ever simpler ways of stating the theology without sacrificing the workability of that theology in all of its previous areas.

The process will follow these basic steps:

1. Identify the core necessary content
2. Develop a theological statement that meets this and all previously identified core content items.
3. Refactor (that is look for ways to simplify the expression of what has been stated).
4. Test to ensure to core content items have been lost or weakened.
5. Repeat at step 3 until step 4 is fully satisfied.

The key steps in a Refactoring Theological process are steps 3 and 4.  Rarely if ever are theologians encouraged to build these steps into their process.  The result, as in many software development projects, is a product that is unwieldy, unmaintainable, and destined to create more problems than it solves.  The goal in Refactoring Theology will be to avoid this same mistake when engaged in developing theological insights.  I will work through this in greater detail in future postings, but for now, this will serve as a brief introduction to the topic of Refactoring Theology.