As a veteran of two and a half decades of this battleground we call Information Technology, I’ve seen a lot of technologies come and go, and I’ve seen a lot of companies fail to embrace technologies that could have made a significant difference in their ability to deliver software quickly and efficiently. Sadly, in far too many cases, IT leadership (management and senior architects) adopt a play-it-safe approach, opting to “ride it out” with tried-and-true technology stacks while their competitors (often smaller, newer and more nimble) embrace and fully exploit modern advances in technology.
Fifteen years ago, this often meant opting to continue to build mainframe-based applications using stalwarts like COBOL and CICS rather than upstarts like Java. Today, it means avoiding modern languages and frameworks like Ruby on Rails, favoring the safety of the familiar – Java and C#.NET.
In recent months, I’ve had the privilege to conduct “architecture assessments” for three very different companies – two large, established firms with large IT groups and well-established architectures, and a new, small firm with almost no permanent IT staff and a “do what makes sense” attitude toward technology.
The differences among these companies is striking. The largest and most established of these companies, coming from a strong J2EE background, was busy rebuilding a set of customer-facing applications, purportedly to increase reuse of components among them, and to reduce the ongoing cost of maintenance. This project, which was having some serious challenges, was not only using dated J2EE technology, but was piling an incredibly heavy, layered architecture on top of it – resulting in application code that – reuse benefits aside – is going to be as difficult to maintain as anything they currently have in production.
The smallest of these companies, in stark contrast, decided to throw away a VB.NET application that was only six years old, replacing it with a lightweight application my company built for them in Ruby on Rails, which is easily, without exaggeration, fifty times simpler to customize and maintain than the application it replaced.
This set of experiences has had me thinking lately. How much could be accomplished in large, established companies – which tend to have sizeable groups of talented software engineers – if they were to cling to the safety of the past a little less tightly, and more aggressively seek to harness the power of modern languages and frameworks?
Having personally built applications in technologies ranging from COBOL/CICS to PowerBuilder to J2EE to Grails and Rails, I have seen the steady increase in productivity offered with each set of advances in technology. I have also witnessed companies fail to embrace these benefits until well after their competition had done so, nearly always to their detriment.
If you are a CTO, IT manager, architect, or anyone who is responsible for the technical direction of your company’s suite of applications, you owe it to yourself to learn as much as you can about modern, dynamic languages (Groovy, Ruby, etc.) and the web application frameworks built on them (Grails, Rails, etc.). The leading reason companies tend to avoid these technologies – slow execution speed relative to Java or fully compiled languages – is usually given more importance than is warranted, since most performance problems tend to stem from sluggish database interactions or network data transmission time. And many large companies tend to overstate their own performance demands. Sure, your internal applications get a lot of use, but are they really under more of an onslaught than the thousands of public-facing web applications built in dynamic, interpreted languages?
Consider this an open letter to the guardians of reference architectures across the Fortune 1000. Do yourselves a favor. Do not ignore Ruby on Rails. or Groovy and Grails. There’s a whole segment of applications tailor-made for these technologies, and far too many of them are still being built with Enterprise Java Beans, by teams that are far too big and not nearly productive enough.