At one point in an Orthodox Divine Liturgy, a hymn is chanted which starts with the phrase, “We have seen the true light…” While not of similar religious significance, occasionally programmers can have epiphanies that lead us to at least have a similar feeling.
For me, the true light I have finally seen is around testing and test driven development. While I’ve always supported testing – at least the sort of ad hoc testing most developers do while coding, and maybe a more thorough approach along the way by QA people, coupled with UAT at the end of the project, the notion of automated testing as you code has really not appealed to me. I didn’t get the point. Granted, I hadn’t really looked into how it was used, or why it was used – even though Rails builds a nice testing framework for you.
On the project I am working on that started out in appFlower, I decided that I needed to re-evaluate my traditional behaviors. It began with using a deployment tool for the app, which downloads the latest changeset from a version control system and deploys that to production. The tool also allows you to quickly and temporarily bring the site down while leaving a nice maintenance message. This will make deploying changes to production much cleaner than my former brute force approach of just copying everything up to the server, and adjusting a couple of the files so that it was running as production.
The latest re-evaluation was around testing. I researched why and how people were using Rails tests, and was intrigued after reading some online material, and watching this video:
The presenter introduced the notion of “Technical Debt”, basically legacy design and code (frequently dead code in my experience) that requires anyone expanding the system to continue using the old system architecture, simply because it is neither well documented, nor would you have a means of truly knowing if you broke something when you alter the architecture. I have lived, and am currently suffering with, such a system. A great amount of effort is spent coding around limitations, because touching the core code might have significant unintended, and often hard to discover, consequences.
So, last week, I started running at least the basic tests that Rails generates as you are building an app. I had to spend time dealing with the authorization and role based aspects of the app, which are a challenge to deal with in testing, but during I have already reaped the benefit of testing. I was amazed, for such a new app, exactly how much dead code, and ill conceived design decisions had already crept in. Writing test cases forces you to really think, at a detailed level, about how the application will respond to the user. I haven’t even started the process of testing the UI, but I plan on it, because this application is intended to go into production relatively soon with a narrow range of functionalities and then to expand over time. Using a more test driven approach should help this growth occur in a sustainable manner, and hopefully push the redo horizon out a bit further (the point at which the Technical Debt grows to a level that causes Technical Bankruptcy).