Languages should die


One of those interesting facts about evolution is that most of the species that ever existed are now extinct. There are good reasons for this. The average life time for a mammalian species is a few million years. There are currently about 5400 species of mammals alive right now, and the mammalian class has existed for about 300 million years. If the current number is representative, there has been about 810 000 different species of mammals during the history of that class. So less than 1% are alive today. And this is only talking about mammals.

Many programming languages have died out, but there are still several old programming languages making a living. Cobol is still the backbone of much infrastructure in the world – it is even evolving still (Cobol 2002 include support for object orientation). Making another analogy with evolution, Cobol would be the sharks of programming languages. They have been around for a long, long time – at least 400 million years in the case of sharks, and 50 for Cobol – and are still recognizable. Fortran is another language that has been used for a long time, and has evolved substantially.

But we also have newer languages. From the view of business and technology, Java and other C-based languages are way ahead. In the dynamic realm, we have Perl, Python and Ruby. All of them over 14 years old. And then we have the really new languages, like Scala and Clojure, who are rapidly gaining use.

Maybe it is a bad thing that these languages that we use day to day have been so long lived. I’m not saying they should die out totally – I know that will never happen. But it might have been better if we had spent energy on fixing the Java language, instead of creating more and more tools to fix deficiencies in the language. The good part about Java is the JVM, and that could have been at least as good now even if we had evolved the language more.

It’s obvious that humanity isn’t evolving like other animals. Natural selection is still happening, but the results are getting skewed by better medicine, social infrastructure and many other inventions. These are tools that make it better for us – with the side effect that natural evolution is changing course. Something similar seems to have happened with Java – we have created so many tools to fix Javas problems, that there isn’t enough pressure to fix the language. I tend to believe that this is a good strategy for humanity, but a bad strategy for language development.

I’m happy that more and more new languages are gaining play on the JVM, on LLVM, the CLR and Parrot. That’s great. But on the other hand I’m seeing threads on Ruby-talk asking whether Ruby can stay ahead. Why would we want that? Wouldn’t it be better to take the best pieces of Ruby, and build on that? In the keynote at the last RubyConf, Dave Thomas proposed that people fork the language. I think that would be a great thing if it started to happen more.

I guess I’m sounding a bit like “yeah, all the current effort is good, but it could be better!”. And it could be. I think the way most people look at languages are all wrong.

Michael Feathers wrote a post on Artima called Stunting a Framework. Maybe we should look at language development in that way? Is this another way to approach DSLs, or can we get more useful, smaller languages, by using such an approach? I think it would be very interesting, no matter what.

Languages should die and be replaced. There should be less cost involved in developing a language. Languages should work on common infrastructure that makes this easy – and we’re finally hitting that mark with machines such as the JVM, LLVM, CLR and Parrot.

So – you should go out and fork your favorite language. Or your least favorite language. Fix the things that you don’t like with it. Modify it for a specific domain. Remove some of the cruft. Create a new small language. It doesn’t have to be big. It doesn’t have to do everything – one of the really cool things about functional languages is that they are often have a very small core. Use a similar approach. Hack around. See what happens.

No existing language will die in a long time. But we need new ideas. New fresh ways of looking at things. And new languages that incorporate what other languages do right. That’s how we will finally get rid of the things we don’t like in our current languages.

You should be ready to abandon your favorite language for something better.


21 Comments, Comment or Ping

  1. I know this sounds relly boring, but to a person responsible for maintenance of systems this sounds like a nightmare. Because I suppose you mean we shouldn’t just experiment with these languages at home, but use them to build real systems? If the current small group of languages that rules the world (C, C++, Java, C#, PHP, VB, Python) would fragment into dozens of languages, the cost of production may possibly go down, if we indeed pick the exact right language for each problem, but the maintenance cost will go up, since it will be harder to find replacements to people that leave after the product is built.

    April 14th, 2009

  2. Martin Krauskopf

    I think this is already happening for years. A lot of people learning language design by implementing a language (either new, or porting existing to the alternative VM, or tweaking it). Probably we just do not know about those languages: take a look at this[1] S.P.Jones’ talk, particularly at 55:15, which nicely shows it :)
    Seems that trend of developing own new languages is moving from academia to “normal” devs which is probably what you are encouraging for here; with which I agree – if nothing else, one learns a lot on the way.

    [1] /presentations/Taming-Effect-Simon-Peyton-Jones

    April 14th, 2009

  3. Joao Pedrosa

    I am torn about that idea:

    * Performance of Scripting Languages –
    /2009/04/black-belt-c-series-language-keywords/

    Trade-offs seem to play a huge role in what dies and what does not… ;-)

    April 15th, 2009

  4. I suppose you’ve never heard the story of the tower of babel.

    April 15th, 2009

  5. The situation in biology is even more appropriate than you seem to realise. Quote: “The average life time for a mammalian species is a few million years.” Well, no. We have no idea what the average lifetime for a mammalian species is — it depends very much on what we mean by “species”, which is not well defined — but it’s probably dominated by species that die out after a very few generations, often one generation. Almost all species are total failures.

    What is a few million years is the average lifetime for the mammalian species we’ve NOTICED in the very patchy fossil record. And that makes the analogy with programming languages even closer. :-)

    April 15th, 2009

  6. Joao Pedrosa

    With my previous comment I meant to point you to the following slides about performance of scripting languages:
    /homes/sbarakat/cs456/Scripting.pdf

    While it might not be completely accurate, I just wanted to show an example of why trade-offs play a role in what can “die”, or why languages are die-hards…

    And I really liked that set of slides when I saw them yesterday during some browsing of the programming languages shootout benchmark game or whatever the heck they call it these days. ;-)

    April 15th, 2009

  7. dterror

    Paleontologist Stephen Jay Gould says that the dynamics of evolution fundamentally depends the random catastrophical events that exterminate whole branches of the tree of life forms. Life on earth would be completely different without those. Maybe we’re missing something in the programming world.

    April 15th, 2009

  8. Brendan

    Mats:

    I assume that you would stop looking for people with 5 years Java experience and start looking for people with technical, communication and process skills who are motivated to solve your problems.

    Jason:

    I can’t see an individual that dies out in one generation as a species:

    Most textbooks follow Ernst Mayr’s definition of a species as “groups of actually or potentially interbreeding natural populations, which are reproductively isolated from other such groups”.

    Ola:

    I am not sure that language is such a leveraged choice. In my environment interactivity is much more leveraged : i.e. the ability to make a small change and test it quickly. Maybe if I had more of that language would make more difference.

    April 15th, 2009

  9. Ugh. Mayr’s definition is terrible. Maybe most textbooks still give it. If so, that’s sad.

    April 15th, 2009

  10. Emmanuel Surleau

    Ola, I think that’s a terrible idea. A language does not only stand on its own merits (syntax, performance…) but also by the number and qualities of its libraries. This is one of the reasons while Java is still going strong, and Perl has not died out.

    Nobody will want to redevelop libraries every six months for the latest language du jour. I’m not even speaking about companies which would get burdened with code nobody wants to maintain because “dude, the language it’s written in is *one year old*”.

    It does not mean language can’t get improvements, this is just something that should not break backward compatibility (or at least, as little as possible).

    That said, I’m not opposed to having new languages pop up on a regular basis – that’s happening already. This kind of competition breeds innovation. Just do not expect them to become mainstream.

    April 15th, 2009

  11. Our problem is that nobody is paying attention to existing research. The languages that we use are hopelessly behind where they could be, and forking outdated ideas in order to generate new ideas seems completely backward. If you want a better language the first thing you should do is to read the literature. That’s what the functional programming community does and it seems to work out for them. There’s no reason we can’t do the same.

    April 15th, 2009

  12. @Brendan That assumes you can throw a skilled programmer into any language environment and expect him/her to be productive very quickly. I don’t believe that is true, and the main reason is what Emmanuel Surleau talks about – the libraries. They take time to learn well, and without that skill you won’t do a good job.

    This is why the path taken by Scala is good – new language, some new libraries, and seamless access to the Java legacy libraries, if you need them. That seamless access to Java is not something you can fix in your basement at night.

    April 15th, 2009

  13. I have already moved from a favorite language, one that I had invested lots of time to master (C++), to something newer and better (Java). Now I am a veteran in Java but I know I’ll do that transition again – and the failure of the Java community to evolve the language (e.g., closures) makes me even want it. I’m just waiting for good alternatives (Scala, JavaFX, etc. – I’m not a believer in dynamic typed ones) to become really viable for enterprise grade development (stable language with big community, multiple and excellent implementations, rich and robust frameworks, IDEs, etc.)

    Another reason to go for the next language is paradigm-level evolution. The functional paradigm is growing in important, most cool new languages are at least hibrid FPs (Scala, Clojure, C# 3.0, even some bits of JavaFX). But this isn’t something you can patch into existing languages even if you are willing to pay a big price in compatibility breaking (e.g. in the level of Python 3.0).

    April 15th, 2009

  14. mark

    Totally agree with you.

    I think, for my use, ruby is 95% perfect.

    My gripe with ruby is:

    - It is too complex
    - not enough english online docu
    - disharmony sometimes (for example, proc and lambda in my code seems to break my fiddling around with prototypic thinking of objects)
    - single inheritance limits you for no real advantage (mixins should be extended heavily, to allow snatching of behaviour of other objects)

    Also I would like to play with some minor things. It would be cool if I have a mode where I can omit end and the parser has no problem with that (but without adding new tokens. Would be fine with 2 spaces as a clue to the parser, but no new extra tokens, because if we use new tokens, then we can keep “end” too)

    Anyway its not always good to have too many paradigms in the language.

    Personally I prefer the python approach, however I hate python’s crappy syntax compared to ruby.

    It also takes A LOT OF effort to sustain growth of a language. Look at the Io language, it is practically dead compared to python and ruby. Within two years it hardly grew a lot.

    April 15th, 2009

  15. Interestingly, Perl has different possibility – extend language with language itself and CPAN. Old Python-style OO system is considered outdated – Moose took it’s place. Devel::Declare allows adding new keywords. CPAN has modules even for type safety. Source filters allow adding new languages (I created a module for Perl6-style comments, but not yet released yet). Inline::* family allows integrating code in other languages.

    April 15th, 2009

  16. haa sde

    To elaborate upon the evolution analogy, what is needed is a Cambrian explosion of languages(or perhaps strategies), many of which will die off, leaving only the well-adapted (and lucky) to thrive.

    April 15th, 2009

  17. Aloha Ola, a contrarian view: /ProgrammingLanguageProliferation.aspx

    April 16th, 2009

  18. As others have commented, new languages are usually easy to pick up and switch to. The real anchor around our necks is the platform libraries. .NET defines the platform independent of the language, which is the right idea, poorly implemented (imho). Free software folks need to pick up the same torch and run with it.

    April 16th, 2009

  19. Dave: Do you know any other libraries that work better than .NET? (Genuine question. I’m not batting for .NET.)

    Haa: Yes!

    I’ve been waiting for Ola to point out that Ioke can use Java libraries … or will be able to soon.

    April 16th, 2009

  20. Jason: Cross platform / language libraries? Unfortunately, no. Language specific libraries? Even given its many warts, I would take the Ruby core and standard libraries over .NET.

    April 16th, 2009

  21. COBOL has just passed .000166% of its journey to extinction; now is definitely the time to kill it!

    April 18th, 2009

Reply to “Languages should die”