Tutorial :Future of languages with no standard and no corporate backing


Over the years we have seen (well, I have :) a number of languages come and go. Some were more accepted, some a little less. So I was wondering, what do you think are factors which most impact whether the language survives ? And whether it will have a future for a number of years (by that I mean several decades or so) ?

For example, fortran and C have survived the test of time. They were popular though, but they also had very good corporate backing, financing, and standard specifications (ANSI and ISO).

Some of the modern languages I see today, although they are popular, have none of that (the current implementation is often considered standard). That is all fine for the time being, but what about 10 or 20 years later, when their authors are maybe not here anymore. I very rarely see open source languages which make the transition into corporate financing.

If you could put with a few words, in your opinion, what would be the most important factors for the survival of a language and why ?


I think the answer depends a lot on the time-frame in which you define survival. This is important because I think there are three factors that have changed over time, and are still changing:

  1. Hardware performance (i.e. speed or memory)
  2. Hardware complexity (i.e. single-core v.s. multi-core)
  3. Software complexity

I think the reason C has survived is because, until just the past few years, there was still a very real need for maximum performance in a lot of applications. Perhaps there will always be that kind of need, but I think it has been growing much less relevant in the past few years. I think it's always going to be around, but I'd be surprised if it was widely used 20 years from now; it's already started getting passed up in favor of C#/Java/etc in the past five years.

The recent (by which I mean past five years or so) rise of languages like Python are also a response to the fact that software has grown more complex, while performance has become less of an issue. Because consumers value the 'now', there's a huge incentive to develop quickly, and worry about speed later, if at all. That has a pretty big impact on which language you use for development.

I see clarity, maintainability and ease of use as the most important factor for survival, if you take the future out to 20+ years.


Ruby is popular, although it has no corporate backing. And it has been here for 14 years already.

Perl already survived 22 years, and probably will survive a few more.

Python has no corporation backing (ok, don't know if you'd count Google's engagement), yet it made to Fortune 500 companies.

On the other hand:

Pascal got corporate backing and died.

Ada has corporation backing and it's practically reduced to DSL for avionics.


Every future language needs to make an existing problem easy

For example, concurrent programming is not easy on most languages today. This will be solved with a new language as we can not easily coax our existing paradigms into the parallel world. Just take a look at Java, which was built from the ground up with threads in mind, it has so many caveats with you even dare to do concurrent programming.

We'll need a system that makes it so easy to do concurrent programming that we won't even need to think about it. We'll need a memory model that protects us from having to think about these problems. For those who can't imagine such a world, you are just stuck in our current paradigm. We will need to change the way we develop software for this to work. Serious problems require change.

Another way for a language to survive is to attach it to an entire system. Just look at Objective C, it is Apple's language for all Apple products. I think this is the way to go. Design a system that is worthy of its own language.

There are many other examples, I've been thinking about this problem for a long time.


As far as I can recall, Fortran had no corporate backing until it was well established. C was backed by AT&T, but they really didn't care if anyone else adapted it. And both were well established before they had ANSI Standards (also, note the ANSI & ISO provide Standard specifications, not implementations)

On the other hand, IBM heavily back & promoted PL/I, and that never really caught on. And the US Government tried to get all of us writing Ada, and that didn't work either.

So, what does work? Good question. Getting schools to teach it is good (Pascal pretty much disappeared when colleges switched to C++ & Java). Lately have "buzz on the 'net" is good (cite: Java, Ruby)


In order for a language to survive it needs several things:

  • It needs to solve a problem better then other comparable options. This is the subjective aspect, that developers feel it is better and so they adopt it.
  • It needs to have good tooling. Without good tooling a language will never catch on to the masses.
  • It needs a strong community to be built around it. A community which provides assistance, help, components, etc etc...

I don't think corporate backing has a direct impact on these items. I think it can make things such as developing tooling more likely, but there are too many examples where it has helped or not helped adoption of a language.


Open source community has become more like a huge corporate, hasn't it?


Languages survive while they are used, and while people are prepared to maintain them. People are often prepared to maintain the language while it is used. If a language is not used, it dies.

There can be all sorts of things that contribute to, or determine whether, a language dies. Corporate-sponsored languages die if the corporate sponsor ceases to see a benefit (profit) in the language, or they want people to use an alternative, and the corporate sponsor is unwilling to release the code to open source, and there is no open source alternative.


I don't see evidence that corporate backing or standardization are sufficient to determine whether a language survives or not. There are many corporate backed languages that have failed to gain a strong foothold (ADA comes to mind). There are many standardized languages (Common Lisp) that also failed. On the other hand, there are plenty of non-standard non-corporate languages that gain popularity (Perl, PHP, Ruby). There doesn't seem to be causality there.

The viability of a language is really determined by the community around it. There is a positive feedback loop. More users means more support and more libraries which in turn means more users. Popular languages can languish, but they don't totally die out. Not for a long time.

If I were looking for a language to use for something that had to last, the two biggest criteria in my mind would be:

  1. Does it work well for my problem domain?
  2. Is the community strong enough to be self-perpetuating?

If the answers to those two questions are true, use the language. If either answer is false, don't.


While other languages have been almost killed by their corporate backing = Delphi

Note:If u also have question or solution just comment us below or mail us on toontricks1994@gmail.com
Next Post »