There are so many tools available today that claim to
magically clean up your code. They slice, they dice, and they magically solve
all your problems. Sadly, as most of us know, writing good code is hard work.
But writing bad code is nearly impossible. There are no tools that can
magically solve this chasm (no matter what the tool vendors tell you!), but
there is one simple tool that can do a pretty good job of keeping you in the
first camp.Continuous integration is a pretty simple idea. Set up a
program to watch your source code. When anyone changes anything, your CI system
compiles immediately. If the compile passes, then any automated tests you have
are run. Finally, the results are published.

Simple right? But why is it so powerful?

Continuous integration is a reverse credit card. A credit
card lets you buy something big today, and pay it back little by little. Credit
cards have a dirty little secret though... compound interest. You pay back
much, much more than you borrowed. It's always cheaper to pay cash if you can
afford it.

When you use a CI system, the opposate is true. You can
either make little payments every day, or you can wait until the end and make
one huge payment. Unfortunately that huge payment has all the compound interest
added to it! By waiting until the end, you're paying more... a lot more!

This is due to the "dark time" between when a
developer writes code and when they merge it into the code everyone else has
written. If you merge all the code together every day, or even a few times a
week, the changes are small and fairly painless. But not if you wait.

If you wait, your changes grow. The longer you wait the more
code you write (hopefully!). And the more code everyone else on your team
writes. So at the end of the month, when you finally are forced to combine all
those changes, the collisions are immense. Developers work on the same files,
sometimes on the same lines... other times functionality that one developer
depended on having in place is changed (I mean "improved") by another
developer. The mutually exclusive changes wreak havoc.

The time between the writing of the code and the merge,
compile, and testing of everyone's code, is when you can't see what's
happening. Are your changes colliding with someone else's? Did someone change
something you need? You just can't see it yet... it's all dark. And it remains
dark until you get it all together.

A CI tool helps developers learn the cadence of "write
one thing," then "check it in." This works much better than
"write one thing.... then another, then another, then another...",
and then "dedicate hours or days to merging." And we haven't even started talking about the benefits of having an automated test run after every commit!

Find problems as quickly as possible, while the fixes are
still small. Turn the steering wheel before the car is actually in the ditch.
It's the easiest time to fix a problem!