Where do programming languages come from, and how do they die?

Share on Facebook0Share on Google+0Tweet about this on Twitter0Share on LinkedIn60Email this to someoneShare on Reddit0

Big DataI was recently investigating how best to port an application to the Eclipse development platform. Doing so, I needed to extend Eclipse with the ability parse the application’s programming language. Eclipse has a very nice tool to use called XText. However it required me to learn yet another language called XTend.

To be fair, XTend is easy to learn as it’s a Java-like language but less verbose. But it is a recurrent phenomenon I find myself encountering repeatedly–to use certain tools you need to learn new languages (like XTend) or frameworks with their own declaration syntax (like Maven). So it led me to reflect on the languages I encountered and had to master to some extent over the decades, which led to the question of what makes new languages appear, and why do languages wither and die?

The answer is clearly not easy. Many, if not most, new languages are not fundamentally different in that most are imperative and fall either into statically or dynamically typed languages. One has to only look at the discussion about JavaScript, Ecmascript, CoffeeScript and TypeScript  which are all variants of each other, with each offering a particular philosophical difference, e.g. conciseness vs type checking.

On the other hand, some languages have disappeared and you have to ask what made it so. Smalltalk is an example–in the 90s it was a rising star as it offered productivity and the flexibility that gave rise to the agile movement. IBM’s development environment for Smalltalk, VisualAge, was the leading light for IDEs, with its original creators later being the key drivers in the development of Eclipse, which stands today side by side with Microsoft’s Visual Studio.

Copyright by Redmonk

Today, Smalltalk has almost entirely disappeared, except that many of its concepts have reappeared in Python, which can be seen as one of the top 10 languages. There appears to be a generic pathway languages follow:

The birth

Languages are created for many reasons. Some of the early ones came out of considering an abstract concept such as LISP, which was all about List Processing and to show that the lambda calculus was actually useful (which took a long time to catch on but today is common for many languages). At birth languages tend to be simple, as they tend to focus on the concept that drove their creation.

The young years

Many languages come and disappear very quickly at this stage–some hang on because of corporate backing (think VBScript) but many do not survive as they do not find a following.  What makes a language survive this period is either large corporate backing (Java, C#) or an enthusiastic community (Ruby, Python).

The young adult

Having survived the young years languages tend to develop large communities where the communities start contributing. Today all successful languages have large and fruitful ecosystems consisting of frameworks, libraries and integration to development environments. This would not have been possible without the existence of the open source community. In fact, in today’s world it is pointless to just consider a language; the libraries and frameworks that go with the language are at least as (if not more) important as the language itself.

The maturity plateau

During the growth period, the language often continues to evolve. This is critical for its future success. I mentioned Lambda expressions, and many languages did not include these at the beginning but were literally forced by the community to do so later. This evolution can be beneficial but also detrimental. C++ kept evolving at a steady pace, but when Java arrived on the scene it started losing popularity rather rapidly, which was in part driven by the frustration over the complexity of C++ compared to Java.

Thus this is the time where the path of longevity is either set or an inevitable decline will set in. A good lesson here is COBOL; this language simply spells longevity. It exists for many reasons, not least because of the existence of a large code base which helps perpetuate its use. But its name ”COmmon Business Oriented Language” spells out its objective: to be accessible to business users and programmers–something it achieved brilliantly at a time when little was known about language construction.

But many languages develop a bloat at this stage that ultimately dooms them. If you want to develop in Java these days you need to know many things: build languages (Maven), Dependency Injection (Guice), REST services (JAX-RS, JAXB, Jersey -> Maven)…the list goes on and the complaints about language bloat are mounting.

And this is a common pattern: even Javascript, which currently is in its growth period, is already developing a large set of frameworks. JQuery is not even discussed anymore; the focus is on other libraries. Angular (data binding and dependency injection), Node (networking/server client applications), and Bootstrap (responsive web design) are common now but new contenders are already arriving like Meteor, Modernizr, Response.js, etc.

The slow decline

Very few languages that have reached maturity disappear overnight. There is too much existing code base for applications that are simply not going to be rewritten in other languages. Delphi is a good example of a language that is clearly in decline but still a good proposition for developers.

Declining languages offer both challenges and opportunities. Owners of code bases in these languages face the question of whether to maintain the product or rewrite it–the latter posing a large up-front financial investment with a high risk profile.

The decline in a language is accompanied by a decline in developer availability. This may well mean opportunities for developers who want to take advantages of niche work, well away from hordes of competing developers (I was recently contacted by a someone who was desperate for help finding a Smalltalk developer) with a good contract rate to boot.

R.I.P. programming language?

Little is known about when a language actually dies. Most commonly the compilers no longer support existing platforms. When Windows XP went out of support and many companies were forced to upgrade to one of its successors, they found out how many compilers no longer worked. Maybe your company still has one of those little applications that can no longer be maintained but just keeps on running. If so, let me know.

Some language trivia

In 1969, 120 different programming languages existed, out of which there are still 10 (including Cobol & Fortran) for which code is still being produced today. The majority of these languages are gone. (source Jean Sammet’s Programming Languages—History and Fundamentals. 1969)

In 2004, John Mashey published an article in ACM titled “Langauges – Levels, Libraries, and Longevity.” He stated “Anyone who is tempted to create a new language esthetically cleaner than, but incompatible with, some existing, widely used language, and 10 percent better, should resist temptation.” I don’t think the industry listened…

List of programming languages: http://en.wikipedia.org/wiki/List_of_programming_languages

The first programming language, Plankalkül, never actually ran on a computer. It was developed by Dr Konrad Zuse between 1943 and 1945. See Wikipedia

The following two tabs change content below.
Stephan is a Professional Services Consultant for the Legasuite range. HE enjoys being a polyglot and works with other technologies: cloud computing, text analytics, machine learning, and big data are all part of his activities at Rocket Software.

, , , , , , ,

No comments yet.

Leave a Reply