become apparent that dynamic programming languages such as Ruby, Python
and even Java/ECMAScript are coming into vogue for developers on the
cutting edge. Ruby on Rails has done much to promote the Ruby
Python hasn't found its muse yet, but its also gaining more attention.
The age of dynamic programming languages is imminent. What I mean is, a
time when dynamic programming languages are the norm, rather than the
exception, is just around the temporal corner.
Within the next five years most organizations will use dynamic
programming languages in some enterprise development. Not all
development: There will always be a need for conventional programming
languages which allow you to detect bugs at compile time rather than
run time. However, the times when dynamic languages are dismissed as
"dangerous" or "toys" is coming to a close.
While cutting-edge developers are flocking to dynamic languages like
Ruby, the mainstream of the development community has been less
inclined to adopt dynamic languages. There are two reasons for this:
FUD and Productivity. Fear, Uncertainty, and Doubt (FUD) continue to
muddy the waters for developers who are trying to grok the significants
and use of dynamic programming languages. It's not unusual to hear
people say that dynamic languages are "toys" or are "dangerous". What
I've discovered, however, is that these same people usually have little
or no experience with a dynamic language. The FUD was born and
propagated out of ignorance as is usually the case with these things.
There is, however, a far more pragmatic reason why dynamic languages
have not been taken up by the masses: Productivity. Learning a new
programming language platform is not a small endeavor. While syntax of
a language can be fairly easy to learn, learning an entirely new set of
libraries is a huge obstacle. For example, Java programmers spend
proportionally much more time learning how to use standard, enterprise,
proprietary, and open source APIs than they do the syntax. In fact, I
would say the ratio is something like 20:1 the first year and 100:1
If you've spent all of your mental effort learning how to properly
use Java packages and APIs (rather than syntax) then the thought of
throwing all that time away in order to learn a completely new platform
may seem ... well ... stupid. Or more accurately, its not a pragmatic
choice when the advantages of the new platform are not obvious.
Essentially, everything a Java developer knows about accessing
databases, manipulating strings, doing input and output, etc becomes
obsolete. In addition, the new platform may not have as strong of an
ecosystem as Java.
In the case of mainstream Java developers, its seems less than
optimal, for example, to change platforms to something like Ruby. Don't
get me wrong! I'm a big fan of Ruby, but to be perfectly honest
compared to the Java Platform the Ruby platform is positively anemic.
The number of APIs (libraries) and the size of the Ruby ecosystem pales
in comparison to the Java platform. There are probably around 4 million
or more Java developers in the world. I would be surprised if there
were more than 100 thousand Ruby developers and probably only 50
thousand that use Ruby on a daily basis in production code. Of course
that's pure speculation, the real numbers for Ruby might be smaller or
larger but few people would argue that the size of the Ruby development
community is anywhere near the size of the Java development community.
generally much more productive than conventional programming languages.
In my research, which now spans about 3 years on the subject, I've
consistently found that developers are about five times more productive
with a dynamic language than they were with a conventional language in
the same context. This means that once you've mastered a dynamic
language, the benefits are enormous in terms of productivity and
maintenance. Less code is much easier to maintain provided its clean
So this creates a Catch-22 of sorts: Dynamic languages are much more
productive yet it would take time for developers to learn a new
platform, so much time in fact that in the short run it would cost more
to move to Ruby or Python than would be saved by the productivity of
these languages. In addition, there really isn't a dynamic language
with the same ecosystem and infrastructure as Java - so adopting a
dynamic language necessitates accepting less in terms of resources,
tooling, and skilled people.
The solution, therefor, would seem to be a dynamic language that is
based on a platform with which the Java community is already familiar.
There are many dynamic languages that have been created for the Java
platform including Jython, JRuby, BeanShell, Pnut, and others but of
these I believe that Groovy has the most potential. The primary reason
is that Groovy is being standardized within the Java community.
Although standardization is never a measure of quality, the horrible
truth is technology does not win on merit alone. Companies will
understandably be more comfortable adopting a language that has been
standardized via the same process that standardizes J2SE and J2EE than
a language that is not. Right or wrong, the powers that make decisions
look to standardization as a litmus test for acceptance and usage.
Besidies being standardized, Groovy has the advantage of being a
dynamic language that was built from the ground up with Java developers
in mind. It's retains much of the same syntax and semanitics familure
to Java developers while also offering dynamic language features like
dynamic typing, mixins, and closures. These are the types of features
that make dynamic languages much more productive than conventional
languages. Finally, all the Java APIs that you use today can be used in
exactly the same way in Groovy. Groovy compiles into byte code, so any
Java API you can import and access in a Java program you can import and
access in Groovy.
The Groovy standard (JSR 241) was started close to three years ago
and is now coming to fruition. To some that seems like a really long
time, but this is an opinion that is not based on a historical
understanding of how long it takes a language to mature. Ruby, for
example, which is just now getting a lot of attention has been in
14 years, and Python for 15 years. The fact that its taken only 3 years
for the Groovy language standard to be developed is actually a
The future seems obvious: Dynamic languages are growing in
popularity and their productivity and broad applicability cannot be
ignored. The Java platform is supported by a huge ecosystem of 4
million-plus developers and thousands of tools and APIs. If any dynamic
language is to be successful it has to (a) be standardized (b) appeal
to Java developers (c) be fairly easy to learn, and (d) leverage the
existing Java ecosystem. There is only one dynamic language that meets
those needs and that's Groovy.
The hype surrounding Groovy has died down and buzz about the project
has been pretty quiet and in my opinion that’s the best thing that
could have happened. The result is a language that has had time to be
developed into something that is going to be truly useful. In many
respects Groovy is the best combination of the Java platform and
dynamic language design. Groovy has been quiet, but like a sleeping
giant Groovy will awaken and effectively take over as the dominate
dynamic programming language after it becomes a JCP standard.