History of programming languages. 1980s

History of programming languages. 1980s
History of programming languages. 1980s

Once upon a time the concept of “objects” did not exist in programming, and today it is difficult to imagine a sufficiently powerful language that does not at least partially use the principles of OOP. Although object programming dates back to the 1960s, it was the 1980s that were the time when it became mainstream.

Computer Programming Crash Course: 7 Books in 1: Coding Languages for Beginners: C++, C#, SQL, Python, Data Science for Python, Raspberry Pi and Arduino. Teach Yourself to Code. Learn Faster.

Are you looking for the perfect introduction to the world of coding? Want to uncover the secrets of Python, SQL, C++, and so much more? Are you looking for the ultimate guide to getting started with programming? Then this bundle is for you.

But you should start with the hardware. In 1979, the legendary Intel 8088 processor saw the light of day, which gave a powerful impetus to the development of personal computers. Since the IBM PC had essentially become a standard, from now on all machines supported any programming language without the need to cut and adapt them.

Programming philosophy

Despite the fact that formally programming stopped depending on machines in the 1950s, it is only now that it has made real sense. The developers finally got rid of the need to think about the peculiarities of the language on a particular computer, which ultimately led to the development of ideas of structured, non-imperative and object-oriented programming.


Without a doubt, the biggest revolution of the 1980s was the emergence of object-oriented languages. However, the pioneer is considered to be the Simula language, developed in 1967 at the Norwegian Computing Center by three scientists – Ole-Johan Dahl, Bjorn Mirhaug and Kristen Nygaard.

However, as we remember, it was the time of the committees in programming. Moreover, since the language was developed in a small Scandinavian university by three people without relevant experience, the chances of gaining worldwide recognition for Simula 67 were nil.

The language was a development of Algol 60 and at first glance did not contain anything new. The real importance of Simula 67 lay in the philosophy of separating the program itself and its instance. Before that, most programmers did not share these concepts. Dahl and Nygor, on the other hand, were puzzled by the creation of simulations (hence the name of the language).

To understand the difference, consider an example of a car. In traditional languages ​​(Fortran, Algol, BASIC or Cobol), you need to write a subroutine or module for each car, although they will all be more or less the same. Simula 67 takes a different approach – you create just one module that defines a car as a set of variables, procedures, and functions, and then just instantiates with private parameters.

From this simple idea, the philosophy of object-oriented programming began to develop. Today we are talking about classes, objects, instances and inheritance, but all this appeared in Simula, it just took time to perfect ideas and massively introduce them into programming.


Smalltalk was the next major step in the development of object-oriented languages.

Alan Kay lived on the west coast of the United States at the epicenter of the hardware revolution. His main aspiration was to create a computer that even a child could work with. After taking a job at Xerox Palo Alto, Kay created a dedicated research group. It didn’t work with the computer, but Smalltalk 72 and 76 were born, borrowing ideas from Simula. Kay read about this strange Norwegian language in one of the scientific journals, he liked the idea and put it in the basis of his developments. However, in 1981, Kay left the project, after which the Smalltalk emphasis changed.

Henceforth, the group was called the “software concepts group”, and Smalltalk 80 was positioned as a “serious language.” Adele Goldberg, David Robinson, Larry Tesler, Dan Ingalls and Peter Death contributed greatly to this.

Smalltalk was the first full-fledged object-oriented language and set the trend for years. In addition, there is another landmark event associated with Smalltalk. The first graphical environment was written in this language. One day Steve Jobs walked into Xerox Palo Alto, admired the development, and recruited Larry Tesler to create LISA, the predecessor of the first Macintosh. Windows, icons, mouse – it all starts here.

Objects and other languages

The object-oriented approach became so popular in the late 1980s that many traditional languages ​​began to include this approach. Björn Stroustrup of AT&T expanded the capabilities of the C language and created C ++. There were other extensions, even more successful, but Stroustrup had the appropriate authority, so it was his contribution to programming that turned out to be historical.

The main feature of C ++ is a full-fledged extension for C. You didn’t even need a compiler, because it was implemented as a preprocessor that converted C ++ to C. Every machine supporting the parent language could support the new object-oriented one.

Other notable extensions to existing languages ​​were the offshoots of Pascal, Microsoft and Borland. Although they were not compatible, they were similar in approaches. Fortran, Lisp, and Forth also included object-oriented extensions, but these were minor improvements compared to C ++. New languages ​​also emerged, such as Ada and Modula 2, which incorporated some aspects of the object-oriented method.

Thus, by the late 1980s, virtually every programmer was familiar with either Basic or C ++.

Non-imperative programming

Objects seem to be the essence of all popular programming languages ​​today, but in the 1980s there was no consensus on the best approach. Therefore, each new idea was recorded and considered an important breakthrough.

A Day in Code: An illustrated story written in the C programming language

A Day in Code tells the story of an epic day in a beautifully illustrated picture book- and it’s written in the C programming language! From the beach to the bowling alley, you will learn fundamental programming concepts as you read about real-life situations described with code in simple C programs. Each C program is presented next to a full-page illustration that depicts the fun event described in the code. You can even run each program on your computer!

Standard programming languages ​​created programs that, when executed, could be much more complex than they are described in the code. For example, a loop might look like it’s just a few lines of instructions. But on startup, this resulted in thousands of instructions and dynamic interpretation. This distinction between static text and actual program implementation has been exploited in object-oriented languages, allowing running code to result in any number of instances.

In non-imperative programming, there is a clear distinction between static and dynamic code. There are two different ways in which this can be achieved: functional and logical programming languages.

Functional languages ​​like Lisp, FP, and Hope wanted to do away with imperative programming, insisting that special cases were inefficient compared to generalizing math functions. For example, in imperative programming, the expression:

A = A + 1

means that every time this part of the program is executed, A changes the value, that is, it actually has no value. Functional languages ​​use recursion to create new variables and therefore A does not use values ​​until the moment it is requested. Recursion is also used to replace loops, so the code execution time is commensurate with the total program execution time. The only problem is that many programmers find recursion difficult. However, the most famous functional language, LISP, developed by John McCarthy of the Massachusetts Institute of Technology in 1959, still has its fans. And it’s still the primary language for AI in one form or another.

Logic programming

The most successful of the logical languages ​​is Prolog. It is based on the idea of ​​writing programs as a collection of logical operators and using iteration to automatically determine the results.

Formally, this approach frees the programmer from worrying about how the result is obtained – only facts and their analysis are included in the program. The tricky part about Prolog is that it needs fundamental breakthroughs in logic, more precisely, in automatic verification procedures. Without this, Prolog is not a very functional and productive language.

The most important part of Prolog’s history is its adoption by the Japanese in 1981 as part of the Decade Project. This has spurred many US programmers to rethink their use of Lisp as the first choice for AI programming.

Perhaps logic programming and functional programming are technologies that have not yet fully shown their true potential. On the other hand, it might just be cases that work in some situations, leaving the necessary object oriented languages ​​to do the real work.

Turbo languages

It would be unfair to get around 80s programming without mentioning Borland’s turbo dialect family.

Turbo Pascal was the first of the new generation of high performance compilers with a simple development environment. Its creator Anders Hejlsberg (who, incidentally, continued developing C # for Microsoft) is another example of Scandinavian influence on computing.

Turbo Pascal has gone from being a slow and difficult to use interpreter to a fast, interactive, machine-friendly compiler that many programmers have liked.

Following the success of Turbo Pascal, the Turbo C, Turbo BASIC, and Turbo Prolog frameworks emerged.

Far from the mainstream

There are two other languages ​​that made a real impact in the 80s and are worth mentioning but don’t fit into any neat category – Modula 2 and Ada.

Modula 2 was Niklaus Wirth’s proposal as a replacement for Pascal. Basically, it was an update that included ideas for parallel programming. In 1980, Modula 2 appeared, a more versatile extension that included object-oriented programming features.

This was the first implementation of how a single module can “see” data only by using the interface between them, which allows the programmer to focus on what the module is doing, rather than how it does it. This simple idea describes the ability to hide and encapsulate data, which are one of the foundations of the object-oriented method.

Modula 2 inherited too many algol ideas, so it did not gain worldwide fame. On the other hand, Ada was born – perhaps the last of the superlanguages. It was created by another committee commissioned by the US Department of Defense and is a return to the ideas of Algol / Cobol. Ada is a versatile language that includes an incredible range of features. For this reason, it can be used to create an object-oriented or functional program. In short, for everything.

Effective C: An Introduction to Professional C Programming

The world runs on code written in the C programming language, yet most schools begin the curriculum with Python or Java. Effective C bridges this gap and brings C into the modern era–covering the modern C17 Standard as well as potential C2x features. With the aid of this instant classic, you’ll soon be writing professional, portable, and secure C programs to power robust systems and solve real-world problems.

Rate article