The Next Big Language

thenextbiglanguageFor some time now I’m thinking about the Next Big Language (NBL). Before Java there was C, and to some big amount it’s still there. But what is the next big thing? Java’s successor? For quite a few years there were and still are some aspiring candidates. Python, PHP, JavaScript and Ruby are the obvious candidates from a web and scripting background. C# and Objective C are strong candidates, especially Objective C having gained a lot of traction, but have a very limited vendor specific applicability.

Nevertheless, none was even close to rival Java and C’s first and second place.

You might look at the TIOBE index to get a good feeling for the current situation and the history. But TIOBE’s picture is to wide, at least for me. There are some languages, that are only useful in quite limited circumstances. Here are some examples: NXT-G for programming Lego Mindstorms, ABAP for the SAP stack, Visual Basic for scripting Microsoft products. Nothing to look for the NBL.

Another thing is, TIOBE seems to move really slow, and for my taste, modern languages are underrated. As an alternative source you might look at GitHub‘s language ranking, which gives us a quite a different picture, but has probably a strong tendency towards web development.

Why is (was) a specific programming language widely adopted: a big language? What are the intrinsic characteristics of current and past big languages? What were extrinsic factors bolstering their rise? In recent years I witnessed a quite big number of new programming languages emerge or older ones (at least conceptually) reemerge. Almost a Cambrian explosion in the programming languages universe. One could conclude, that there must be a strong need for something new. And I would wholeheartedly agree.

The answers to: What traits do the newcomers share? What makes them appealing?, have also to be taken into account, when looking for the NBL. All leads to the question: what are the characteristics of and boundary conditions for the NBL?

Before diving into answering this questions, we have to tackle the next one first, what actually are programming language characteristics and boundary conditions? I will spare you the distinction as the borders are fuzzy and give you an admittedly quite lengthy list of things to consider, with short explanations in no special order:

Execution Performance

How fast is the programming language and it’s environment? I will see if I can come up with a simple benchmark. Exact numbers are not relevant, I guess. Just some factor comparing to a C solution, or something.


On what execution environment(s) – e.g. JVM, .Net, V8, BEAM, … – is the language built upon, respectively uses? Or is it something entirely new, everything written from scratch? What are the drawbacks? What the chances?


How stable and bug-free is the programming language? How feature complete is it? Is it hardened by production use? Are their big and serious projects that use that particular language in a major way?

Core Team

How big is the core team? What experience does each member bring to the table? Is there a single strong leader? Or are changes incorporated rather democratical? There are some further factors to consider: a shared vision and a feasible roadmap, for example.

Community Size and Engagement

How many people are using the language? How many third party libraries are around? How active is the community? Is the community growing or shrinking?

Big Company Support and Financials

Is there a big company supporting the development? What are the companies motives for doing this? Is the further development properly funded? Are the core members working fulltime and properly paid for it.


How is the general reception in the media? Is the language rather unnoticed or is (was) it hyped? What do experts say about the language? How far is the blogosphere embracing the language? What is the general mood of early adopters? Are they cheerful? Rather reluctant?


Is there a single web site that serves as an easy access point, summarizing and presenting the language easily approachable for beginners, and at the same time gives advanced programmers access to further material? Is there a nice logo? Does the presentation keep up with current web design flavor?

Developer Productivity

This is a hard one and taken to far, would spur discussions that can not be settled, I guess. To preserve some objectivity, factors like: the amount of code necessary to express some concept and the existence of higher level language concepts might be valid criteria. (Hopefully)

Syntax Style

Is the language C like, with curly braces and semicolons? Or more like Python, where structure is inferred from the usage of space? Maybe the language has some different style or mixes them?

Complexity and Simplicity

How many distinct keywords, constructs, concepts and paradigm does the language support? How many different ways are available to express the same thing?

Type System

The old questions of: Strong versus weak typing? Static versus dynamic typing? Type inference, yes or no? Duck typing, the messiahs? What is the default mechanism. Is it possible to optionally move away to a different type system? Is the type checked during runtime or compilation in case the latter is necessary?

Concurrency and Distribution Schemes

Does the language support multi-threading, multiple processes, multi-core machines, code execution (transparently) distributed to multiple machines?

How does the language support the developer in coping with concurrency in general?

Memory Management

What are the mechanisms the language provides to work with and control the computer’s memory? (garbage collection, reference counting, …)

Target Computing Domain

What kind of development is the language intended to be used for? What kind of programs is the output in most cases? As I’m looking only on languages that are general purpose, the correct question should rather be: In which computing domain does the language shine?

Computing domains are:

  • OS scripting
  • Embedded
  • Realtime
  • Rich clients
  • Server programming
  • Web clients
  • Mobile clients
  • and more

Reason for its Existence and its Ancestry

Why was the language developed? What was the intended purpose? Languages aren’t imagined from nothing. There is always one or more language that certain ideas and concepts are ‘borrowed’ from. What are those languages? What cherries did the author(s) pick and why?

Programming Paradigms

Functional vs. object-oriented vs. structural vs. imperative vs. declarative vs. logical vs. … Which paradigms does the language support and to what extend and purity?

Development Environment

How mature are the tools to create software, real systems using the language? What tools exist? Which are needed? It’s not just an editor with syntax highlighting. It’s continuous integration tools. TDD and BDD tools. Debugger. Profiler. Tools to support refactoring and to extract and enforce metrics and style.

Consistency and Standardization

Are there different, concurrent versions of the language? Does one have to expect major refactorings, when switching from one version to the other? Is a standards body controlling the language features and further development?


How far and how well is the language connectable to common external technologies, systems and protocols? By itself? Or by addable extensions (through libraries or modules)? How hard is it to find out about and use those. Among others: persistency and data storage (relational, nosql, …), HTTP, XML, JSON, HTML, payment systems, social media APIs (Google Maps, Facebook, Paypal,  …).

This was only the first step. The next is moving towards answering the question, what are the actual properties the NBL should/might/will have for each of the properties from above? Is there even more to consider?

As this post is already extraordinary long, I will postpone answering this question to a later post.

This post is actually the start of a series “In search of: the NBL”.

In the next post of this series I will look at the factors that current big languages have in common and discuss some aspects next big languages might tackle differently and why this might be a good idea.

The posts afterwards will look at intriguing programming languages, one at a time. I will provide a cheat-sheet summarizing the factors from above for each of them and rate each regarding the NBL-factors to be outlined in the next post.

I will try to come up with some (pseudo-scientific) rating scheme, where everything boils down to a number stating the chance a language might become the NBL. Possibly I might come up with an estimate when this could happen and what further conditions need to be met. I won’t lean myself to far out of the oracle’s window, though.

My goal is to publish a new language analysis every month, say every first Thursday, until I run out of strong candidates.

I guess the NBL properties analyses will take some time, so the first language analysis might be online on September the 5th. I’m not sure which language it will be. Current candidates are Elixir, CoffeeScript and Io. But I think I will go with CoffeeScript since I used it recently a lot.

This will be a fun journey and the first time I commit to a publishing schedule. I will try hard to stick to it.

If you have any ideas how to make the method better, more accurate, more fun, more relevant, whatever, feel free to contact me. I’m open minded changing things while we go.

Additionally, if you know of interesting programming languages feel free to promote them for an analysis. I will pick them up.

(well as far as I can wrap my head around them, so please spare me Haskell)

3 thoughts on “The Next Big Language

Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s