Language revolution

JAOO was interesting this year. A collection of very diverse subjects, and many focusing on programming languages – we had presentations about functional programming, JavaScript, Fortress and JRuby. Guy Steele and Richard Gabriel did their 50 in 50 presentation, which was amazing. I’ve also managed to get quite a lot of work done on Ioke. The result of all this is that my head has been swimming with thoughts about programming languages. I’ve also had the good fortune of spending time talking about languages with such people as Bill Venners, Lars Bak, Neal Ford, Martin Fowler, Guy Steele, Richard Gabriel, Dave Thomas, Erik Meijer, Jim des Rivieres, Josh Holmes and many others.

It is obvious that we live in interesting times for programming languages. But are they interesting enough? What are the current trends in cutting edge programming languages? I can see these:

  • Better implementation techniques. V8 is an example of this, and so is Hotspot. V8 employs new techniques to drive innovation further, while Hotspot’s engineers continuously adds both old and new techniques to their tool box.
  • DSLs. The focus by some people on domain specific languages seem to be part of the larger focus on languages as an important tool.
  • Functional semantics. Erik Meijers keynote was the largest push in this direction, although many languages keep adding features that make it easier to work in a functional style. Clojure is one of the new languages that come from this point, and so is Scala. The focus on concurrency generally lead people to the conclusion that a more functional style is necessary. From the concurrency aspect we get the recent focus on Erlang. Fortress aslo seems to be mostly in this category.
  • Static typing. Scala and Haskell are probably the most representative of this approach, in trying to stretch static typing as far as possible to improve both the programmer experience, semantics and performance.

Is this really it? You can quibble about the specific categories and where the borders are. I’m not entirely satisfied with where I put Fortress, for example, but all in all it feels like this is what’s going on.

Seeing 50 in 50 reminded me about how many languages we have seen, and how different these all are. It feels like most of the innovation happened in the past. So why is the current state of programming languages so poor? Is it because other things overshadow the language itself? I really don’t believe that. I think a good enough language would enable better tools, more productivity and more successful projects. So why isn’t it happening? We seem to be stuck in a rut. Anders Hejlsberg said in his opening keynote that the last 10-15 years have been an anomaly. I really do hope so.

What is apparent from the list compiled above is that everything that currently happens is very much evolutionary in approach. Innovation is happening, but it’s mostly small innovation.

We need a language revolution. We need totally new ways at looking at programming languages. We need new innovation, unfettered by the failures and successes of times past. We need more language implementors. We need more people thinking about these things.

I don’t know what the new approaches need to be, but the way I see it the last 10 years have been quite disappointing. If programming languages really are important tools, why haven’t we seen the same kind of innovation in that field as we have in IDEs and tools? Why haven’t we seen totally new ideas crop up? Is it because language development is always evolutionary? Does it have to be? Or is everyone interested in the field already convinced that we are at the peak right now? Or that Lisp or Smalltalk was the peak?

What needs to be rethought? I’ve read Jonathan Edwards recently, and he writes a lot about revisiting basic ideas and conclusions. I don’t agree with everything he says, but in this matter he’s totally right. We need to revisit all assumptions. We need to figure out better ways of doing things. Programming languages are just too important. We shouldn’t be satisfied with the current approaches just because we don’t know anything better.

We need a revolution.

12 Comments, Comment or Ping

  1. Ola,
    Two factors seemed to weed out innovation and diversity, especially after ’95: (1) the tech boom, where people made a dash for cash, and (2) the general increase in the complexity and pervasiveness of software in technology and the business world, where the demand for development tools, standardization, and “safety” made people pick a few winners, primarily C/C++, Java and later .NET. I’m glad we’re past #1 and rethinking #2.

    The other interesting fact is that widespread adoption of language and design ideas seems to lag their invention by as much as decades. OOP took 2 decades and if the interest in FP really holds, it will be 4-5 decades.

    I wonder if the next revolution will be spawned by language designers who exploit the optimizations and other improvements happening now in VM’s? That is, what could we do with languages now that people just dismissed previously as not viable?

    October 4th, 2008

  2. mark

    I think one huge problem is that every revolution takes a lot of effort. And let’s face it – creating a language is still not a trivial task. I am amazed at how much effort was spent to shape today’s programming languages.

    Who can afford such resources into a language? It simply seems as if a good programmer has to invest years of his life into this effort.

    So maybe instead of a revolution we first need a way to make programming language creation much easier. If average Joe is able to create a super-complex language then we would indeed have a revolution – coming straight from a human brain into the model of computer world.

    PS: Personally I believe a revolution will not happen. But I still have hope that new languages crop up that unite MANY good ideas and make them ACCESSIBLE to new programmers. This is one critique I have about lisp – it feels very old compared to other languages.

    October 4th, 2008

  3. The thing I don’t understand is how come there is so little focus on versionability and representation at the language level.

    With versionability I am referring to a way to version interfaces/types, such that we can finally truly innovate in a language without having to worry about backwards compatability which inevitably leads to hacks (Java inner classes) and sub-optimal solutions (Java generics).

    With representation I am thinking of a way to represent a program, ANY program, by an AST rather than flat file. This will enable people to choose their own editor, format etc. without it impacting the actual representation in the source tree. Let the editor handle the view part, let all underlying tools work on the model part.

    Those things would constitute a revolution to me.

    October 4th, 2008

  4. ¡Hola Ola! I think there is no revolution because people and companies want to get things done fast and while there are so many languages and also people who are able to use them, there will be no revolution because the time needed to reinvent the wheel in this case can be used to finish another bunch of projects which in return is money…

    October 4th, 2008

  5. Union is power

    I like your blog, I like lisp, clojure, ruby and Mathematica.

    I think you should descompose the problem of creating a revolution in computer languages in two subproblems:

    First step: First create a FullForm for your language, here it doesn’t matter the name of the concepts, that the job of the third step.

    Second Step: Make up your mind about what is the feature you consider more powerful in your language. This will force you to stay in the ground
    and decide what is the market for your product.

    Third Step: Now show us you are a master or the natural language.
    Choose the word and concepts for your language so that other get a good appreciation of your skills.

    Intelligent step: I should join the clojure or the scala world, or any world where the creators are willing to collaborate in creating a better language and they don’t mind who is the owner of the copyright.

    Only thinking.

    October 5th, 2008

  6. Patrick Wright


    I’m not sure what you include in “programming languages” here. There’s an interview with Alan Kay over at the ACM Queue (, where he references a study in the mid-1960’s–over 40 years ago–where Jean Sammet identified over 3,000 extant programming languages. If you just restrict yourself to the JVM and the last 10+ years, looking over Robert Tolksdorf’s list ( you’ll find dozens and dozens that neither you, nor I, nor most people have even installed and tried out. Outside of the JVM the number of available programming languages is huge. Research papers are published on new experimental languages all the time, individual authors are introducing news ones regularly–most of these just get no notice in the wider world of working programmers. My guess is you could make a lifetime pursuit of trying out existing languages (sometimes with the help of hardware or OS emulators), and still not cover more than a fraction of them in any depth.

    My sense is you’d like to restrict yourself to some tiny category of those many thousand languages, perhaps those “widely deployed and widely used in production?”. But if so, that would seem to counter your goal of wide-ranging experimentation in language design.

    I’d like to hear more about what you really have in mind.


    October 5th, 2008

  7. For me (a Java developer), that revolution is Scala.

    For example, who would have thought of using singleton classes (as well as packages) as modules? People cleverer than me, that’s for sure.

    To those whose business it is to invent new languages, this might seem only evolutionary; to others, it is more.

    October 5th, 2008

  8. Tracy Nelson

    I’m hoping that we’ll break away from source code expressed in ASCII characters stored in flat files. Granted, it’s hugely convenient to do so (as a LCD for tools to target), but I think once we break free from old notational and storage conventions, it will shake people up enough to spark some genuinely new ideas. I think APL could make a significant comeback now that we have the CPU power to make it viable, but I doubt it will because nobody will support its unique character set. Hopefully, Fortress is taking the first baby steps in this direction, although I’m not terribly sanguine regarding “syntactic stylesheets”.

    October 6th, 2008

  9. It somehow seems that the brilliant young minds of this generation don’t come together to create their ‘next big thing’. The innovations that are developing seem to be evolutionary developments from the baby-boom cohort’s perspective/mindset.

    I don’t know why this is, perhaps there are more people like me who were initially drawn to the business side of things before turning back to the technical side; perhaps it’s because the dominance of the baby-boomers makes it diificult for these new ideas to find a breeding ground; perhaps the university system has become a place that stifles innovation; who knows.

    In my perception a new idea is brewing that looks at programming from a completely different perspective which is not easily explainable in a short comment while the long explanation is usually TL,DR.

    What it is? Casper Bang already mentioned it: let the language be an AST and have various representations of that AST and make this AST versionable. I call it Graph Oriented Programming, where (semantic) graphs are what lists are to Lisp and objects are to Smalltalk.

    What surprises me is that the old guard hasn’t taken the trouble to pick up on this and seems to persist in thinking they can do it better.

    October 7th, 2008

  10. I should say I also see a few others factors that nowadays lower the need for a new language revolution and thus make it more unlikely:

    1) sharing objects on VM’s: with the new languages being ported over standard VM like JRuby aon the JVM and others: you can now use several languages, several paradigms and the trend is even to be able to share objects natively (e.g. MOP), so you can pick up different best tools for the job as you often says: much less need to have a new big language to rule them all. Moreover, the concepts brought in those standard VM languages are now part of the culture so it’s super natural say to translate a customer need who think SQL into SQL or CSS into CSS and the industry and money powers that system strongly.

    So new languages/concepts can birth; no matter how clever they are, it will take a lot of time some customers start expressing needs accordingly to such new paradigms so those will be good languages in theory but with little business momentum, especially compared to the momentums of the others…

    2) The world seems to look every day more like a big mashup over the Internet. Systems are now built around small molecules that interact over HTTP and struggle for their own minimalist business model. Since those little systems tend to interact over HTTP, then, just like with the VM’s, there is now a cross language interface between systems and thus again people can more easily choose the best tool for the right job and hence there is again less need for a new killer language to rule them all.

    Overall, we long lived in a world were languages could hardly interact together. That’s now more true precisely in that last decade. Before we were often compelled to innovate or at least leave some language because it was too bad at some new requirement. This is less and less true as we can now accommodate the different paradigms together. Of course this doesn’t mean we can’t do better.

    finally, I see things happening in software engineering that might actually be a revolution:

    1) People will put much less faith in big corporate tools maker (like JSF editors, BPM and all) and will re-discover the true power of DSL sitting over generic powerful languages. End of a big hypocrisy. Rails is certainly one of the things that made it happening by taking industry web productivity by storm.

    2) People might also start putting less faith into corporate standards (like JCP) and rather evaluate open source projects as living systems were the best stuff is actually unlikely to happen within large corporations. Instead people we learn better how to qualify those open source products and put their faith into the best ones.

    My very volatile 0.02$

    October 16th, 2008

Reply to “Language revolution”