Thursday, September 21, 2006


Zen and the Art of Code Design and Maintenance

A few weeks ago, I posted a list of design principles for software development. Here’s a list of guidelines centered on the development process:

Development Principles

  • #1: All change must be trackable. All development must be done utilising a Source Code Control system. SCC should be backed up at least as often as every night and should be the primary repository for all development.
  • #2: Use an issue tracking system, preferably one that integrates with your Source Code Control system. Get developers to associate an issue ‘ticket’ when checking in source code.
  • #3: Builds must be automated and your deployments should be buildable in a single step. Run nightly automated builds as a minimum. Consider using continuous integration. Anything that can be automated should be.
  • #4: Run all tests automatically. Do not use manual procedures; that’s what computers are for! Create unit tests, preferably before writing any code (Test Driven Development). Run unit tests as part of the build process. Employ a code coverage tool alongside your unit tests.
  • #5: Run automated user acceptance tests. Test early and often. Tests that run with every build are much more effective than manual test plans that sit gathering dust on a shelf somewhere.
  • #6: Use code generation to increase your productivity and help avoid duplication. Do not use wizard code you do not fully understand. Look for repeated code patterns (such as Data Access Layers) and create templates to generate code from.
  • #7: Keep a decisions document. It should be under source control. Record all design, architectural and development decisions, along with the reason for each decision, the date and where appropriate the participants involved.
  • #8: When providing time schedule estimates, break tasks down to be less than 4 hours in total duration. Do not cave in to pressure from management to reduce schedule estimates when you believe they are accurate.
  • #9: Make things easy to reuse. If things are easy to reuse, then it’s likely they will be. Strive for an environment that promotes reuse.
  • #10: Perfect your use of debugging and diagnostic tools. Find the tools that suit your needs best, and get to know them well. Do not develop or debug by coincidence. Bugs do not go away by themselves!
  • #11: Make your documentation part of the code; that way it is less likely to be out of date.
  • #12: Use virtual development environments. VMWare and Virtual PC are both free. There are times when having a throwaway PC (or server) is essential: simulating a client site, creating a test environment, installing beta or trial versions of software, sandboxing dangerous code. Once a luxury, now a staple.
  • #13: Strive for simplicity and consistency in your designs and in everything you do.
  • #14: Understand your users' expectations and then deliver just a little bit more. If your users become project champions, you know you are succeeding where others often fail.

I’d like to leave you with this parting thought from The Pragmatic Programmer:

Sign your work: In previous generations, master craftsmen were proud and eager to sign their work. You should be, too.


Powered by Blogger