Much has been written about the many ways Ruby on Rails makes developers more efficient in terms of business features produced per unit of time, or line of code. Syntactic sugar in the language. Nary a line of boilerplate code anywhere. A plethora of plugins and gems to do the dirty work and keep you focused on higher-order features.

It seems that far less has been written on the consequences that hyperefficiency can have in an organization. On the surface, it’s obvious – teams are more efficient, so they create features more quickly, and projects get done faster. Sure, that’s true – but dig a little deeper and things get more interesting.

Most would agree that like so many things in life, the raw talent of IT professionals, in aggregate, is distributed along a bell-shaped curve, and that accordingly there are precious few “rock stars” out there. In traditional IT shops, the best and brightest, in order to have the most impact on an organization, tend to be surrounded by large teams, and spend their time creating designs, helping to solve problems others bring to them, and generally dispensing wisdom. There’s an economic reason for this – given the tools, languages and frameworks we have all been using, there is no way that even a small team of elite minds could produce any software of real significance in a timeframe that matters to the organization. So we have large teams, populated with people from both halves of the bell curve, with the “outliers” leading the way.

But that is changing. With high productivity language/framework combinations like Ruby on Rails, people are discovering a new way to leverage the best and brightest. Suddenly, significant software can be developed by two or three developers in two to three months. Sprinkle in a bit of engineering discipline (DRY, TDD, etc.), and the software that emerges at the end of one of these projects will be a shining example of what software can be – code that actually realizes business and design goals, and does so elegantly and efficiently. The iPhone of the software world.

Sadly, in traditional environments, this almost never happens. Through brute force and much testing and debugging, most applications come close to meeting business goals, but they are so inelegant and internally compromised that they are very costly to maintain, and difficult to adapt to changing business requirements. Why? In old-school leverage, the visionaries could realize their ideas in real software only by describing that vision to the people who were actually writing the code. And depending on the communication skills of the visionary and the ability of the development team, the degradation of that vision might range from severe to only mild. Can you imagine what Beethoven’s Ninth Symphony might have sounded like if he could only hum the theme and describe the countermelodies, and have a group of scribes do the rest of the work?

But put that visionary (or small group of them) in front of keyboards and let them have at it, and you have a whole new ballgame. Not only is there far less time spent communicating the vision, but those who see it most clearly are able to express it directly in code.

This, more than anything, is why I’m excited about RoR and similar languages and frameworks.