A simple back-of-the-envelope calculation suggests that, worldwide, we produce about 33 billion lines of new or modified code every year. Cumulatively, this means that since the 1940s and ‘50s (when higher order programming languages began to gain some traction), we’ve produced somewhere around one trillion source lines of code.
On the one hand, this volume of output suggests that ours is an incredibly vibrant and innovative industry. On the other hand, it’s a humbling thought, for through those trillion lines of code, all handcrafted by individual human labor, we’ve changed the world.
Truth be told, some nontrivial percentage of the 33 billion lines yearly is dead on arrival or so transitory that it’s thrown away quickly. Much of that code, however, has a longer half-life, and even some of that code lives after 10, 20, or even 30 or more years. For many developers, the code they write today becomes tomorrow’s legacy that their children or their children’s children may stare at some day, trying to use it, adapt it, evolve it, asking the question, “What the heck was this developer thinking?”
Greenfield development, quite honestly, is great fun, simply because you get to start with a clean slate and, thus, are not burdened by anything from the past. For the most part, we teach Greenfield development in our schools; furthermore, start-up companies look so much more nimble than their older counterparts because they don’t have the millstone of legacy around their necks. Woe be unto the student who enters the real world (it’s not like being at the university, unless you move from the college womb to the start-up womb immediately), and woe be unto the start-up company that begins to mature into sustainable development and soon realizes that you can’t just start over.
Richard and Kevin introduce us to a reality that’s often neglected in our industry: the problem of evolving legacy systems, a domain they call Brownfield development. The typical economically interesting system these days is continuously evolving (you can’t shut it off) and ever-growing. The authors identify the root of the problem as that of complexity, and offer an approach that focuses on the fundamentals of abstraction and efficient communication to nibble at this problem of transformation bit by bit. Their model of Views, Inventory, Transforms, and Artifacts offers an approach to reasoning about and executing on the transformation of Brownfield systems. They propose a Brownfield lifecycle involving surveying, engineering, acceptance, and deployment that offers a means of governing this transformation.
As the old saying goes, the way you eat the elephant is one bite at a time. Richard and Kevin bring us to the table with knife and fork and other tools, and show us a way to devour this elephant in the room.
Grady Booch
IBM Fellow
January 2008