13 reasons why Ruby, Python and the gang will push Java to die… of old age

Lately I seem to find everywhere lots of articles about the imminent dismissal of Java and its replacement with the scripting language of the day or sometimes with other compiled languages.
No, that is not gonna happen. Java is gonna die eventually of old age many many years from now.
I will share the reasoning behind my statement. Let’s first look at some metrics.

Language popularity status as of May 2008

For this I am gonna use the TIOBE index (tiobe.com) and the nice graphs at langpop.com. I know lots of people don’t like them because their statistics are based on search engine results but I think they are a reasonable fair indicator of popularity.

Facts from the TIOBE index:

TIOBE Index Top 20

What I find significant here is the huge share the “C like syntax” languages have.

C (15.292) + C++ (10.484) + Java (20.176) + C# (3.963) = 49.915%

This means 4 languages get half of all the attention on the web.
If we add PHP (10.637) here (somehow uses a similar syntax) we get 60.552%

As a result we can extract:

Reason number 1: Syntax is very important because it builds on previous knowledge. Also similar syntax means similar concepts. Programmers have to make less effort to learn the new syntax, can reuse the old concepts and thus they can concentrate on understanding the new concepts.

Let’s look at a group of 10 challengers:

Python (4.613) + Ruby (2.851) + Lisp/Scheme (0.449) + Lua (0.393) + SmallTalk (0.138) +
Haskell (0.137) + Groovy (0.131) + Erlang (0.110) + Caml (0.090) + Scala (0.073) = 8.985%

This is less than the attention Visual Basic gets: 10.782% and leads us to…

TIOBE Index Top 21-50Reason number 2: Too much noise is distracting. Programmers are busy and learning 10 languages to the level where they can evaluate them and make an educated decision is too much effort. The fact that most of these languages have a different syntax and introduce different (sometimes radically different) concepts doesn’t help either.

Looking at the trend for the last 7 years we can see a pretty flat evolution in popularity for most of the languages. There are a few exceptions like the decline of Perl but nothing really is earth shattering. There are seasonal variations but in long term nothing seems to change.


This shows that while various languages catch the mind of the programmer for a short time, they are put back on the shelf pretty fast. This might be caused by the lack of opportunity to use them in real life projects. Most of the programmers in the world work on ongoing projects.

Reason number 3: Lack of pressure on the programmers to switch. The market is pretty stable, the existing languages work pretty well and the management doesn’t push programmers to learn new languages.

Number of new projects started

Looking at another site that does language popularity analysis, langpop.com, we see a slightly different view but the end result is almost the same from the point of view of challenger languages.
What I found interesting here was the analysis regarding new projects started in various languages. The sources for information are Freshmeat.net and Google Code. The results show a clear preference for C/C++/Java with Python getting some attention.

Reason number 4: Challenger languages don’t seem to catch momentum in order to create an avalanche of new projects started with them. This can be again due to the fact that they spread thin when they are evaluated. They are too many.

Other interesting charts at langpop.com are those about books on programming languages at amazon.com and about language discussions statistics. Book writers write about subjects that have a chance to sell. On the other hand a lot of discussion about all theses new languages takes place online. One thing I noticed in these discussion is the attitude the supporters of certain languages have. There is a lot of elitism and concentration on what is wrong with Java instead of pointing to what their language of choice brings useful and on creating good tutorials for people wanting to attempt a switch.

Reason number 5: Challenger languages communities don’t do a good job at attracting programmers from established languages. Telling to somebody why she is wrong will most likely create a counter reaction not interest.

Let’s look now at what is happening on the job market. I used the tools offered by indeed.com and I compared a bunch of languages to produce this graph:

Reason number 6: There is no great incentive to switch to one of the challenger languages since gaining this skill is not likely to translate into income in the near future.

Well, I looked at all these statistics and I extracted some reasons, but what are the qualities a language needs and what are the external conditions that will make a programming language popular?

How and when does a language become popular

  • A new language has to gain the support of a big number of programmers using, at the moment, a different language. To do this it has to leverage things those programmers already know. (C++ built on C, Java built on C++, C# built on C++, Java and Delphi)
  • A new language stands a chance when there are some pressing problems with the existing languages. For example Java managed to cover two problems plaguing the C/C++ world: complexity (C++) and memory management (C/C++). These two were real problems because projects plagued with bugs created by complexity and with memory leaks.
  • A changing market can also help a lot. Java managed to ride the Internet growth. They lost the browser battle, applets are not very used, but the switch to the server market was a huge success.
  • Based on history we can see how all successful languages had very powerful sponsors. C/C++/Java/C# are all creations of big companies like AT&T, Sun, Microsoft. All these new languages are born in universities and research institutes or are coming from very specific niche domains.
  • A popular language needs to be generic and applicable in most of the domains if not all.
  • Popular languages usually succeed fast. They have to avoid getting “old”. When programmers see a language around for many years without a growing market share they start to feel just okay not learning it.
  • Popular languages have cool names :)

So we can draw more reasons:

Reason number 7: The new languages don’t introduce an earth shattering improvement in the life of most of the programmers and projects.

Reason number 8: There is no killer application on the horizon. This means new languages compete in old markets with established players.

Reason number 9: None of these new languages has a powerful sponsor with the will and the money to push them on the market. Powerful sponsor translates in investment in the libraries – see Java. All these new languages are born in universities and research institutes or are coming from very specific niche domains.

Reason number 10: Most of these languages lingered around too much without stepping decisively into the big arena.

For one’s curiosity here is a list of talked about languages with their birth date:
Ruby (mid 1990s), Python (1991), Lisp (1958), Scheme (1970s), Lua (1993), Smalltalk (1969-1980), Haskell (1990), Erlang (1987), Caml (1985), OCaml (1996), Groovy (2003), Scala (2003)

Compare this with older successful languages:
C (1972), C++ (1983), Java (1995), C# (2001), BASIC (1964), Pascal (1970), FORTRAN (1957), Ada (1983), COBOL (1959)

It is pretty obvious most of these “new” languages lost the train to success.

Why many of the new languages will never be popular

  • I already mentioned syntax a few times
  • Some languages made strange mistakes. For example Python is a great language but the idea of using indentation as block demarcation really is a cannon ball chained to its feet. While most of the pythonistas defend this idea with a lot of energy, the truth is this feature makes it really a dangerous tool in big, world wide distributed projects – and most important enterprise projects are big and distributed. For a better analysis from somebody with real experience read this: Python indentation considered boneheaded
  • Some languages have very difficult to “get” concepts. For example most of the supporters of functional languages are proud of how concise statements are in their language. This is not really useful for somebody used to think procedural or object oriented. If the only gain from binding and twisting your mind is typing a few less lines then any experience programmer will tell you that this is not the main activity. Writing the first version is just a small part of the life cycle of a project. Typing the code is even smaller compared with the design time. From the second version the game changes dramatically. Maintainability is way more important. Also very important is to be able to add features and to refactor the code. Readability is paramount from version two, and for both development and support teams.
  • The nature of a part of these languages makes it difficult to build really good tools to support them. One very useful feature is the automatic refactoring provided by advanced tools like Eclipse.

Reason number 11: “Features” that look and are dangerous for big projects. Since there are not a lot of big projects written in any of these languages it is hard to make an unbiased evaluation. But bias is in the end a real obstacle for their adoption.

Reason number 12: Unnatural concepts (for majority of programmers) raise the entry level. Functional languages make you write code like mathematical equations. But how many people actually love math so much to write everything in it? Object oriented languages provide a great advantage: they let programmers think about the domain they want to model, not about the language or the machine.

Reason number 13: Lack of advanced tools for development and refactoring cripple the programmer and the development teams when faced with big amounts of lines of code.

How would a real Java challenger look like

  • The successful challenger should try to build on existing knowledge and infrastructure. Scala is actually getting on this road. Running on the JVM and being able to reuse Java libraries is a huge advantage. Using a similar syntax to Java is also a great decision that might push Scala into mainstream.
  • The challenger needs a killer application. Erlang might have the killer application with distributed computing features. But distributed computing is not that mainstream yet, even on the server market.
  • It has to be born inside a powerful company or to be adopted by a big sponsor. All the challenger languages are lacking a sponsor at this point. Sun seems to be interested in some of the scripting languages. But I am not sure if their attention is gonna help any of these languages or is gonna distract and kill them. And Sun already has Java so we can suspect they are trying to actually promote Java through these languages – see the scripting engine

Pick me, pick mee, pick meeee!!!

Looking at all those (smart) languages and all the heated discussions that surround them makes me think about the donkey from Shrek yelling “Pick me! Pick mee!! Pick meeee!!!”. In the end only one can be the real winner even if in a limited part of the market.

For scripting Python has potential, huge potential. But it has to do something about the indentation fetish to be able penetrate the big project market. Without that the web looks PHPish.

Ruby is elegant but alien. I saw its syntax described like “the bastard son of Perl” (just google it). Its new popularity is based not on the language itself but on a framework (Rails) that can be reproduced in other languages even if with less elegance. Struts 2 attempts just that.

Scripting languages (Groovy, Rhino…) on top of Java and the JVM are interesting but they will never be primadonnas. They cannot compete with Java because they are slower. They can be useful when scripting a Java application

is a desirable feature (VBA is an excellent tool for Microsoft products and other Windows products and it pushed Visual Basic up the scale).

Scala has a lot of good cards. Building on the JVM, familiar syntax, huge inherited library, can be as fast as Java on the JVM… But where is the sponsor and where is the killer application in a shifting market?

The danger for Java doesn’t come from outside. None of these new (actually most of them are pretty old) languages have the potential to displace Java.
The danger for Java comes from inside and it is caused by too many “features” making their way into the language and transforming if from a language that wanted to keep only the essential features of C++ into a trash box for features and concepts from all languages.

In the end I want to make it clear that I am not advocating against any of those languages. There is TAO in all of them. I actually find them interesting, cool and useful as exercise for my brain, when I have time. I recommend to every programmer to look around from time to time and try to understand what is going on the language market.

This article is part of a series of opinions and rants:

60 thoughts on “13 reasons why Ruby, Python and the gang will push Java to die… of old age”

  1. Objective c gaining on Java because of apple WWDC? Well, apparently the attendance at Javaworld is triple that of WWDC.

    The thing I like about Java is it is a reasonable programming language for the computer (enabling refactoring, reliable large APIs) and the human (refactoring, safety, and just about everyone’s code looks the same). Small “clever” one liners will generally get broken into reused functions, why not start with a syntax that recognizes that. Serious code bases gets written then rewritten and passed around and rewritten. Java is the best mainstream language that acknowledges this. And the libraries are superb in breadth and quality, all open source. It doesn’t hurt that you can use Java on everything from a key fob to a mobile to a desktop app to a browser app to a server.

    Having never used Python seriously I can’t comment on the white space issue, but if you have a fragment of code and the spacing is borked, but it will still run (incorrectly), that’s the very definition of insanity. With brace based languages that require declarations variables will be out of scope and it generally just won’t compile, and you can use editor features to find the problem.

    Personally I find annotations to be great and their rapid uptake and simplification of Hibernate/EJB prove their value. But the core language should be cleaned up at some point.

    I would like to see more use of Java, it should be a systems level language for a complete experience of being able to examine, understand and reuse any part of what you’re working on, this was tried in the past, but the technology has advanced and the time has come to try again.

  2. @ohwell

    if you have a python code fragment that is improperly indented and add it to your existing code, it won’t run. Instead it will raise an exception.

    I’ll admit that I’m bias toward python, but a lot of the arguments put forth here against it and similar languages are pretty weak.

    I guess it really depends on the specific domain you work in, but from my point of view there is a lot of momentum behind python, and also ruby, at the moment. A quick perusal of major tech related news site articles seems to confirm this.

  3. the proliferation of languages in my opinion has created a big mess in the development world.
    every day some new languages are coming up adding more confusion than needed. The biggest problem nowadays is that to do a project today , you actually need more people or people having “fluency” in more languages.
    Having mastery of one or two languages is understandable, but fluency in over 5 languagues automatically means you are using a jack of all trade, master of none personality and this never equates to efficiency.

    We should go back to the drawing board and resimplify the development landscape. I believe a lot of the technologies added are just hype. One example among others is XML, I don’t want to start a flame war, xml is just a bloated overkill( think xml, xpath, xsl, xquery, parser, dom, sax, schema etc… you need all these to do what really ? just to create a data file that in the end comes up to 10 times more bloated than it should be !!!)

    Xml has no real value, except making it more readable to a user who needs to read the data in an XML file, while the majority of XML data is consumed by system or applications directly, which would have done better using flat files, with predefined layout. Even XML is not usable by end user at they are , they still need to be converted to tabular for usign excel or any spreadsheet app to be usable. Human mind works with data better when it is in tabular form..

    In the company I worked for, we jumped on the XML band wagon like every body because management wanted that , now we have done a 180 degree turn and gone back to flat file, which are a lot faster and needs less overhead to process. for end user data, the data is represented directly into tabular form by our programs. so far we haven’t suffered at all by going back to flat files for data interchange, although when the decision was made to go back to flat files, there were some concerns it could cause some problems.

  4. I think you are spot on. One of the main reasons Java is stronger than C++ is because Java stayed away from all the detailes that make a C++ program unreadable. However, Java is adding more and more of these stupid things (along with good things) and it looks like we will have a monster soon.
    And like C++, there is pretty good arguments for each new feature, but all combined it is just to much.
    Most fast, small and understandable open source projects go the same way. they start with a useful function which you can use after 10 minutes. Two years later they have merged with eight other projects, have an 800 page introduction book and the core functionality is hidden six layers down.
    For the other languages: saving some keystrokes is not impressive if you make the code harder to read. In small projects they have a merit because they are similair to prototyping tools. But creating a big, maintainable program means quality is key.

  5. @Henrik Holmström
    Sorry for the delay in response, I didn’t notice the new comment. I think the typing of the initial code is the least expensive step in the life of a product. Maintenance is the most expensive and there clarity of design and implementation are paramount.

  6. To Markus,

    How exactly is Ruby maintainable? I’ve already seen such wild swings in Ruby on Rails that between minor version numbers, the way certain STANDARD libraries work create an air of complete unpredictability. How is that “fun”, exactly? Duck-typing is another area which makes Ruby programmers “warm and fluffy”, but explain to me how having to query every single bloody object with a “respond_to?” is superiour to simple specify what object it was to begin with (or which it inherits) as in done in static-type languages?

    And no – the effects of tabbing in Python is not being overstated. The effects of the tabbing rigidity makes the language unusable (or at least insanely ugly) to use under some real condition. Imagine trying to embed Python script inside an HTML page (heaven forbid). Your tabbing would be completely screwed up.

    So, over a year after your post, one can clearly see that Ruby and Python have NOT made this gigantic impact that everyone assumed. Why? Because once your actually use it in a really large project, the cracks and lack of maintainability become VERY apparent VERY quickly.

  7. Java Zombie.

    Don’t be a turd. I actually like many other languages other than Java. Simply because I’ve smacked Ruby and Python around, you assume I’m a fanboy.

    Added to this your lack of an actual counter-argument to my points suggests you have nothing really intelligent to say, so perhaps it’s best to keep your mouth shut.

    As for programming languages, just to set you straight, I enjoy Groovy, Scala, Pascal, NetRexx, Modula-3, C, C++ (not really a fan of Objective-C), even a bit of Icon now and then (among other languages).

    So “please stay with Java” really shows where you personally feel the threat to you dinkie little languages comes from, eh?

  8. I suppose, it’d better to range programming languages according to they popularity for special areas, like web development, system software development, database development, enterprise systems development etc.

    It’s evident that ActionScript can’t be the competitor of Java or C++ because they are applied in completely different ways. i wonder how these people haven’t counted HTML or CSS in this case?

  9. Nice article , you have indeed cover the topic with great details with all data and analysis. but as die hard fan of Java I don’t agree with you , you itself says that java is #1 now days and nearest competitor of Java is C and C++ which itself quite old what this shows is that world is not very eager to adapt any new language and its prefer to go with tried and tested.

    5 tips to write equals method in Java

Comments are closed.