The evolution of programming languages

March 26th, 2003 § 7 comments

Programming languages, by their own nature, are quickly created and changed. Every new niche, need, or market demands that new languages be invented to meet their requirements. A document, written in early 1995, listed nothing less than 2350 different languages. Another page, which catalogs versions of a program written in various languages, lists more than 500 languages.

Even with such abundance of languages, it’s easy to see that many of them are just variations in overlapping programming concepts. In fact, as the aforementioned lists show, many of them are just variants of a base languages with a few new features thrown in to deal with some unknown demand. If we observe many of the languages created in the last ten years, we will notice that there was little evolution in conceptual terms. Perl, Python, PHP, Java, C, C++, C#, and Delphi exhibit few real differences among themselves. In most cases, those differences amount to nothing more than syntactic sugar, which changes the way some constructions are written without changing their meaning. Just to clarify, I’m using evolution here to denote paradigm changes as opposed to changes that happen because of aesthetic choices or pressures by competitive features. Although all the languages previously mentioned are imperative languages, the same pattern can be observed in other languages classes. For example, many functional languages are only rehashing Lisp themes. To compensate for that homogeneity, software development seems to have changed to focus on the creation of methodologies that just make better use of already existing languages. Extreme Programming and UML are some examples of that trend. Both methodologies can be used with almost any kind of programming languages, but they don’t change the languages to which they are applied. Another focus is the creation of class libraries to cope with the limitations of some languages — poorly, in many cases.

An exception to the pattern above is the slow adoption of concepts like aspect-oriented programming, design by contract, and generics. Although those concepts are not new, their implementation is still limited. While some languages display some of those concepts naturally — Smalltalk is an evident example — and others are seeking to introduce it, many other languages seem to gravitate around their original concepts, and change only in the most restricted way. Delphi, a variant of Object Pascal, is such a language. After becoming an object-oriented language, in 1989, it has remained almost unchanged. Most new features were already old when they were implemented, and only came as a result of market pressures. Other languages, like Beta, are trying to introduce new paradigms in programming, but they seem to have limited commercial success and remain constrained to the academic realms.

It’s worth noting that many of the most used languages today have just gone beyond their procedural infancy. PHP is an obvious example. Other languages were already born as oriented-object languages, but didn’t introduce any new concepts in their syntax and/or semantic domains. Python and Java are typical cases of those languages. That means many languages are just repeating history, trapped in an old evolutionary cycle.

In spite of the reasoning above, one can ask: Is language evolution a necessary step in solving new kinds of problems? Take Smalltalk, for instance. It has remained essentially unchanged for decades. Even so, it has shown itself incredibly able to cope with the new demands of a modern programming world. Lisp is a similar example. It’s one of the oldest programming languages in use today, but it’s able to adapt itself to new tasks without any significant change in its core. It’s interesting to realize that some companies keep their use of those languages a secret, while others suggest that those languages are their competitive advantage against rivals. Is the future of programming a commercial return of those languages? We are talking about languages that were created more than 30 years ago.

Smalltalk and Lisp share a characteristic that can explain the fact that they remain current: their simplicity. Smalltalk has just five keywords and a few syntactical and semantic rules. Even so, it’s generally believed that it takes fewer lines of code to implement a given task in Smalltalk than in other programming languages. Lisp follows the same pattern. The expressions that make the language core allow it to have an incredible flexibility, and make it able to implement any construct required by a given task, also resulting in fewer lines of code. The fact that both languages use the concept of an image that holds the whole development and run-time environment also contributes immensely to their efficiency. The edit-compiled-run-debug cycle becomes edit-run-debug.

Although language evolution remains seemingly limited, a current tendency may have a positive impact in the development of new programming concepts: the greater adoption of virtual machines. The era of inefficient virtual machines is over, and new implementations combining compilation and interpretation exhibit excellent performance and make a good use of hardware resources. Virtual machines are naturally flexible and are a good field for experimentation that is not restricted to traditional environments that closely replicate the bare metal. It’s worth noting that both Smalltalk and Lisp are usually implemented in virtual machines. Some new languages try to achieve the flexibility offered by virtual machines with the introduction of new keywords that only result in a raise in the overall complexity of those languages.

Another concept that has gained wider acceptance in the last years is that of dynamic typing. Many modern languages have opted for dynamic typing to improve productivity and reduce errors. It’s curious that Java and C#, languages created with market considerations in mind, use static typing, and are forced to provide resources to “violate” that concept because of its failings. (Boxing is one of such “violations”, which tries to remedy the gap between value and reference types in those languages.)

So, what is the evolutionary path that new languages will follow? Obviously the current programming needs will not remain constant. Are oriented-object models, such as those that exist today, sufficient to take care of those new requirements? Will languages like Smalltalk and Lisp, that have proved themselves impervious to the passage of time, be able to remain up to date without significant changes in their semantic structure? I don’t even know how to begin answering those questions, but I believe they are crucial to the future of software development.

§ 7 Responses to The evolution of programming languages"

  • I’ve been working in a research group for several years, and in ’95, we were looking into alternatives to C++ for our company’s product development. Several us learned Smalltalk and built a prototype, and although there were things we liked, we ended up moving to the newly emerging Java.

    Now I’m learning Python because it gives me a better prototyping environment than Java, and with Jython I can even mix my Java and Python code. I would be interested in using Lisp or Smalltalk but I always feel like they would be pulling me out of the mainstream. They really do seem like different worlds. I wonder why that is.

  • Ronaldo says:

    I understand how you feel. I’m frustrated that mainstream languages don’t offer any real advances over what was being used 30 years ago. Unfortunately, as it’s today, marketing has final say about what is an accepted language. So, Java and C# are the languages of the new generation because Sun and Microsoft say so. At least C# is a lot better than C++, and in the future it may even give raise to a better (evolved) programming language.

    Python has great potential. It’s already one the mainstream languages for Linux (and is starting to conquer Windows), but it also doesn’t offer many advances over older languages except that it borrows a good enviroment from Lisp that makes it perfect for fast prototyping as you mentioned. I guess Python filled the gap left by Perl’s lack of updates. It is successful, but I don’t think it brings anything new to the table.

    As to Smalltalk and Lisp, they are really different worlds. It has been said that when you come to understand Lisp, your vision of programming is forever changed. This is true of Smalltalk as well. I think it is due to their unusual development cycles and environments, which make for faster and more powerful development. Fortunately, they seem to be getting more attention recently, and I believe they will be considered good alternatives for development in the future.

  • Jason says:

    C# is not a programming language. It’s an infantile scripting language that is useless in most applications. I wouldn’t touch it with a 10 foot pole. Java is insanely difficult for a language as wordy as it is. It’s almost like programming in Ada, except Ada makes sense!

    The only real languages are Assembly Language, C, Ada95, Prolog, Forth, Lisp and Smalltalk. The others can be thrown in the trash as wasted space.

  • Ronaldo says:

    C# is not a scripting language — at least, not in the sense the word “scripting” is applied to languages to day. The only fact against the language I can point is that it’s not much different from C++ or Java, although it has a few niceties.

    As for “real languages”, I think your list is a bit limited. While some of the languages you cited are really interesting and powerful, there are others who can be as powerful and productive.

  • Jude says:

    I think you’re document/article about programming languages isn’t that well-explained, There is a big importance that everything should be well-explained about the evolution of programming.

    I myself have studied programming and have noticed that some have big differences, and through my study I have noticed some of the differences and improvements of programming languages and have come to knowledge that these languages though some commands and syntax are the same they pose different understanding to each and that they are in concept different from each other.

    For instance, From C to Java there is a big difference between implementation and that Java uses different syntax although some are just the same or an improvement from C or C++.

  • Ignace Saenen says:

    Lips has one obvious advantage over most OO languages. They adhere to the lamda calculus principle and are actually more pattern matchers than anything else.

    If there is anything you always miss in OO, then it’s a dynamic code path, since it conflicts with design-by-contract and encapsualtion principles that lie embedded in all OO languages that are derived from the Smalltalk ancestor.

    Another thing I always seem to miss in OO languages is the notion of state programming. If you look at UnrealC, you have the concept of states embedded in the language, so you can actually define multiple versions of the same function embedded in multiple states. Changing a codepath becomes a matter of putting an object in a different state. UnrealC is still somewhat limitted, because you can’t have parallel states in one class and you still have to derive from a baseclass, but it is a huge step in the good direction.

    One language that expands even further on dynamic codepaths is Ruby, where every method call in essence is a message. If the method does not exist, then the message isn’t processed and you get an exception thrown. If the method exists, then you can call the method. But the nice thing is that you can add methods to the class at run-time. Obviously there is no design-by-contract here anymore. But Ruby is immensly popular and all sorts of projects, small and large of scope, have been written in it, including things like webservers etc..

    I think the language that can capture the extensibility principle that lamda calculus inhibits, without breaking the design by contract principle of OO languages, still has to be constructed. But it’s popularity will first and foremost depend on the backing of major companies such as IBM, Sun or MS, more than on the actual features of a language.

  • chengetai says:

    say something on visual oriented languages

What's this?

You are currently reading The evolution of programming languages at Reflective Surface.

meta