Monday, February 19, 2007

Programmer Productivity is Accelerating

In a recent post, Tomasz Węgrzanowski points out Yannis's Law, which states:
Programmer Productivity Doubles Every 6 Years
Yanis's law is phrased to be provocative; the "law" is extrapolated from a single datapoint. Two if you count Tomasz's observation.

Assuming that there is a grain of truth here, I see a few factors that could drive this trend:
  • Programming the same old thing over and over again gets boring
  • Tools get better
  • Libraries get better
  • New techniques emerge
  • Better platforms emerge
Every so often, I think about a system I was working on in the early 1990s that did a lot of brute force string processing in a mixture of Fortran 66/Fortran 77. String processing in Fortran is an extremely mind-numbing activity, and leads to low programmer productivity, frequent bugs, and regular coffee breaks to clear the head and revisit pages and pages of code with fresh eyes.

By the early 1990s, if you wanted to do massive amounts of brute force string processing, C was the way to go, because it was so much better than everything that came before it. By the late 1990s, if you wanted to do massive amounts of brute force string processing, Perl, Python or Java were the tools of choice, because they were so much better than everything that came before. Every year, computers get faster, and the systems we want to build get bigger. Micromanaging the computer the same way we did 6, 12 or 18 years ago simply isn't an effective way to write software. Which is why we feel the need to write better languages and better tools that get computers to do more of our drudge work.

Tools do get better over time. The compilers, languages, debuggers, SCM tools, bug trackers, and other tools developers use to make systems are always getting better. Simply using revision control is a huge productivity boost over projects that deal with frequent changes without revision control....

XML is simultaneously the most beloved and most reviled artifact of software development of the late 1990s. On the one hand, it raised a great many issues: parsing is a key component of all but the most trivial systems, parsing text is much easier than parsing opaque binary formats, and using a standardized grammar and parsing library is better than faking it with regexes, or worse, writing (and testing, and debugging) a grammar for every format to be parsed. On the other hand, XML is frequently abused, misused and shoved into places it doesn't belong. Nevertheless, adoption of XML is a net benefit, because it eliminates the need to write code for an entire class of problems.

Finally, the biggest productivity improvement in recent memory is the move away from cumbersome desktop programming environments towards web based applications. That topic has been beaten to death for years.

There may not be a whole lot of objective data backing up Yanis's law, but programmer productivity does feel like it's been growing faster than linearly for the last few decades. Maybe the factors aren't 2x every 6 years. Maybe it's 2x every 5 years, or 3x every 10 years.

In any case, programmer productivity is accelerating, and the expectation is that it will continue to accelerate, somehow. What are you going to do to accelerate your productivity over the next 5-10 years?

No comments: