I while back, I read The Mythical Man-Month. The data in chapter 8 of the book (which is by no means recent) points out that the average productivity for a developer, measured in debugged lines of code per year is almost constant.
The interesting part here is that it is constant even when changing languages.
The data compares LOC written in low level machine code and those written in a high level language (PL/I). Because every line in PL/I was on average generating 5 low level instructions, this mean improving developper productivity by a factor of 5.
Fast forward 32 years… and now I’m here wondering if the rule still applies.
I guess the answer is yes, and that’s why everyone is so happy with languages like Ruby and concepts like convention over configuration, which allow you to write less.
But then… Spring must be a huge productivity boost, since it is quite coarse grained. You’re not avoiding code… you’re doing more with less code. Same thing for Hibernate.
Less LOC, more function.
To be fair… this is more related to component reuse (called “buy versus build” in the book) than to higher level languages.
Then there are the DSL (Domain Specific Languages) that are starting to pop up everywhere. Specific high level languages for specific problems (like configuration, business rules, etc…). Those should really cause a big impact in productivity if they can be used in a significant part of a project. I’m under the impression that DSLs are used for relatively small parts of a system (maybe BPEL would be the only one able to have a wider scope).
So why aren’t these new languages/frameworks used everywhere? Why are they not taught at computer science faculties?
It’s related to the intellectual load imposed on the developer.
Lower level languages can do any thing with a reduced set of commands (functions, operations… you name it). The developer needs to know very little thing about the language but needs to figure out how to do every little thing. Just imagine how a simple hello world program would look in assembler.
In the other hand, higher level languages require knowledge about lots of commands and features. Put in the mix a wide collection of extensions (or libraries) and integration with other high level languages, and the intellectual overhead is just barely manageable.
Maybe at this point is where we start creating standards. J2EE is not the best of the options (JSF, EJB…) but is a standard. A developer can learn it and have a pretty good grasp of everything without being overloaded with too much information.
However, most companies are using other kind of tools, like Spring or Hibernate (although Hibernate now can be used with JPA, so it can be seen as a standard). And every project/company uses a different presentation framework (we have plenty to choose from in the java world).
And then there is Eclipse RCP, Grails, Jython… and outside the java world you always need some Bash, Perl (at least Perl regexps)…All this tools make something easier and faster, but they add to the pile of knowledge a developer requires to do his job.
Under this stress, how can we remain productive and still be able to create working solutions in our jobs?
I don’t know. But we certainly do.
And from time to time, they are not only working… they are good! 😀