The oldest programming language. Evolution of programming languages

The personal computer, until the mid-sixties, was an overly expensive machine that was used exclusively for specific tasks and that only performed one task at a time.

Programming languages ​​at that time, as well as the computer device on which they were used, were developed only to perform specific tasks, for example, for scientific computing, and not. Due to the fact that machines, as we said above, were a very expensive pleasure, and only one task was performed at a time, time was considered expensive - therefore, the speed of program execution was in the foreground.

However, the cost began to decline during the sixties, and the time came when even small firms could afford this pleasure. In addition, the speed increased, and the machines stood idle for a long time without performing any tasks. And to stop this, time-sharing systems were introduced.

Processor time in these systems was, how to put it, “sliced”, and users could receive alternately short sections of this same time. The computer device began to work much faster, which allowed the user to feel at the terminal as if he were carrying out his activities with the system alone. The device, in turn, was idle less, since it carried out not one, but several tasks at once. Time sharing significantly reduced the cost of hardware time, and all due to the fact that one device could be shared by not one user, or even two, but hundreds.

So, when power became cheaper and more accessible, those who created programming languages ​​began to think more and more about more convenient writing of software, and not about the speed of their execution. “Small” operations, that is, atomic-type operations that were directly performed by device devices, were combined into more “volume” high-level operations and single structures with which it was much more convenient and easier for users to carry out their activities.

What are programming languages?

We will now give a clear answer to this question. A programming language is a formal sign system that is intended to describe algorithms in a more convenient form for the performer, for example, personal computer. A programming language includes a package of semantic, syntactic and lexical rules that are used to create a computer program. Using such a language, the programmer will be able to accurately determine what events the PC will react to, how information will be stored and transmitted, as well as what actions need to be performed on these various types of circumstances.

Almost three thousand programming languages ​​were invented during the creation of the first programmable devices. Their number increases every year, and new ones are added to the list. There are some languages ​​that only a small number of creators who developed them can use, while others become known to a large number of users. Specialist programmers use more than ten different programming languages ​​in their work.

Why are programming languages ​​needed?

The process of PC operation is the execution of a program. To put it more in simple language, that is, a package of commands that follow in a certain order. The type of machine instruction, which consists of zeros and ones, indicates what actions the central processor should perform. It follows from this: in order to set the PC the sequence of actions to be performed, a sequence of binary type codes of the corresponding commands is specified. In machine codes, software consists of many commands. Writing such software is time-consuming, difficult and tedious. The programmer must know the combination of ones and zeros of the binary type code of each program, in addition, he must remember the binary type codes of the data addresses that are used during its execution. It is much easier to write software in a language that is closer to human natural language, and have a PC translate this program into machine-type codes. This is exactly how programming languages ​​appeared, which are intended specifically for writing software.

Nowadays there are a large number of different programming languages. Each of them can be used to solve many problems. Specialists in their field know exactly which programming language needs to be used to solve any problems, since each of the languages ​​is equipped with its own capabilities, targeting certain types of tasks, and also has its own way of describing objects and concepts that are used to solve a large number of problems.

Programming languages ​​are divided into 2 groups

There are languages ​​that have a low level and languages ​​that have a high level.

The first group includes assembly languages, where command notations are used in the form of symbols that are quickly and clearly remembered. Symbolic notations are written instead of a sequence of binary-type commands, and instead of the addresses of the binary-type data that are used when executing a command, the names chosen by the programmers and the names of this data in the form of symbols are taken. This programming language has another name - autocode or mnemonic code.

But, high-level programming languages ​​are most often used for programs by those who create them. Such a language, in principle, just like human language, has its own alphabet, namely, a large number of symbols that are used in languages. These symbols are necessary to compose the keywords of the language. Each keyword has its own function, just like in the language we are used to, words that are made up of alphabetic letters. Keywords are connected to each other into sentences using the syntactic rules of the language. Each of all sentences is responsible for the sequence of actions that the PC will perform.

A programming language, which has a high level, is the link between the PC and the user, inviting him to communicate with the PC using the method that is most convenient for the person. Quite often, this language helps to choose the right method for solving problems.

Before starting to write software in a programming language that has a high level, a specialist draws up an algorithm for solving problems, namely, he draws up a step-by-step action plan that must be followed to solve this problem. Therefore, programming languages ​​that require the preliminary compilation of an algorithm are called algorithmic-type languages.

Well, here we come, one might say, to the main thing. Now we will tell you what programming languages ​​there are.

What are the different programming languages?

Fortran

Back in the mid-fifties, scientists began to create programming languages. And the very first language of this type was called Fortran, and it was developed in 1957. It is used to describe an algorithm for solving scientific and technical problems using a digital computer. In addition, like the first computing units, the language of this type used to carry out natural science and mathematical calculations. This language, in an improved type, has survived to this day, and among modern languages ​​that have a high level, it is the one most used in conducting scientific research. The most common options today: Fortran-I2, Fortran-I4, EASIC Fortran and their generalizations.

ALGOL

We continue our topic of programming languages. As you already understand, we will now talk about a programming language like Algol, which appeared in 1958-1960. In 1964-1968 it was improved, and ALGOL-68 appeared. A language of this type was developed by a committee that included scientists from America and Europe, and it was classified as a high-level language. Using this type of language, algebraic formulas could be easily translated into program commands. Algol was popular not only in European countries, but also in Russia. This type of language had a noticeable influence on all programming languages ​​created after some time, and in particular, this affected the Pascal language. This type languages, in principle, just like the Fortran language, were created to solve scientific and technical problems. In addition, the language was used as a means of teaching the basics of programming, that is, the art of composing software.

COBOL

The Cobol programming language was created in 1959-1960, and this language belongs to the third generation. First of all, it is intended for developing applications for business and for solving economic problems, for processing banking data, for insurance companies and other institutions. The "inventor" of Kobol is Grace Hopper. Usually, COBOL is criticized for its cumbersomeness and verbosity, since one of the goals of the creators of this language was to get as close as possible to English language. At the same time, the programming language had, for its time, excellent tools for working with data structures and files, and this, by the way, ensured its long life in business applications. At least in the USA - for sure.

Lisp

Next in line is the Lisp programming language. The Lisp programming language was developed almost at the same time as the Cobol programming language. This language is based on the program representation of system linear lists of symbols, which are the main data structure of the language. It is the second oldest programming language after Fortran. It is used extensively to process information in the form of symbols and is used to create software that simulates the functioning of the human brain.

A program created in Lisp consists of sequences of expressions, that is, forms. The result of the program is the calculation of these expressions, written in the form of a list - one of the main structures of this type of language. The main point of a Lisp program is “life” in symbolic space.

BASIC

The BASIC programming language was developed by programmers at Dartmouth College in the USA in the mid-sixties. The language was based partly on Fortran 2 and partly on ALGOL-60, additions were also made that made it more convenient for working in time-sharing mode, and after several years it became convenient for word processing and matrix arithmetic. This type of programming language was initially implemented on the GE-265 mainframe, which supports a large number of terminals. At the time of its appearance, contrary to popular belief, it was a compiled language.

This type of programming language is designed so that students can write programs using time-sharing terminals. It was created not only to solve the problem that is associated with problematic, older languages, but it was also intended to be used by “ordinary” users who are not interested in the speed of the program, but are interested in the ability to use a PC to solve their tasks. Most beginning programmers, due to the simplicity of this type of language, begin their programming journey with it.

Fort

The Forth programming language appeared in the late sixties and early seventies. This type of language was used in control tasks of various kinds of systems after its creator, Charles Moore, wrote software in it that was intended to control radio telescopes at the Arizona Observatory.

Many properties, such as flexibility, interactivity and ease of "invention", have made Forth an effective and attractive language in applied research and in the creation of tools. The obvious areas of application for this type of programming language are embedded control systems. In addition to all that has been said, it has also found application in programming PCs running various operating systems.

Pascal

Continuing the topic, one cannot fail to note this type of programming language as Pascal. Pascal was created in 1972 and was named after Blaise Pascal, who was once a great mathematician and inventor of the world's first arithmetic unit. The Swiss scientist and computer scientist Nikolaus Wirth is rightfully considered the creator of the language. The innovation was used to teach programming methods. Pascal is a general purpose programming language.

Of all its features, the main ones can be named - this is the strictest typing and the presence of structural type programming tools. Pascal became one of the first such languages. The Pascal programming language teaches you how to correctly write a program and how to correctly develop methods for solving problems, and it also helps you learn how to choose the right options for representing and organizing the data that is used in a problem. The Pascal language has been introduced into secondary computer science courses since 1983. educational schools USA.

Continuing the topic of programming languages, we decided to talk about another type of language - the Ada language. The Ada programming language was created from Pascal in the late seventies and was named after Ada Lovelace, a gifted mathematician. It was this talented woman who in 1843 explained to the whole world the capabilities of Charles Babbage’s Analytical Unit. This type of language was developed by order of the US Department of Defense, and was initially used to solve space flight control problems.

The Ada programming language is a modular, structured, and object-oriented programming language that contains high-level parallel process programming capabilities. The syntax of this type of program language is taken from Pascal and Algol, it has been expanded and executed in a logical and strict style. Ada is a strongly typed programming language that completely eliminates working with objects that do not have types, and also reduces automatic conversions to an absolute minimum.

The C programming language is by far the most popular and used among programmers. This type of programming language originates from two languages, namely BCPL and B. Martin Richards created BCPL in 1967 as a language that was intended for writing system software and compilers. We will tell you what it is below. Ken Thompson in 1970 to create more earlier versions UNIX OS used on DEC PDP-7 PC. In both the first and second languages, variables were not divided into types - each data value had one word in memory.

The SI programming language was first implemented in 1972 on the DEC PDP-11 PC. But it managed to gain its popularity and fame as the UNIX operating system. All major operating systems today are written in C or C++. The C programming language is available on a large number of PCs after several decades. And by the way, it’s worth noting that it is completely independent of hardware.

The C language became a traditional programming language in the late seventies. This type of language is equipped with rich tools that provide the ability to write flexible software that is used in all kinds of modern PCs.

Prologue

Well, we've come to the end. We will end our topic of programming languages ​​with a story about the latest language in this area - and it is called Prolog. This type of language is considered the programming language of the future, and it was created in the early seventies. Specialists from the University of Marseille took part in the development. They named it from the words “Programming in the language of LOGIC”. The programming language was created based on the laws of mathematical logic. This type of language, unlike the programming languages ​​that were described above, is not algorithmic and it belongs to the so-called descriptive languages, that is, languages ​​of the descriptive kind.

Now let's talk about what a compiler and interpreter are?

Compiler and interpreter

Developing a language that would be convenient for writing a program is not enough. Each language must have a translator, which is a special program - a translator.

So, a translator is a program that is designed to translate software that was written in one programming language into software in another programming language. This translation process is called translation. An example of a translator is a complitor, which is also a program. It is intended to translate software that is written in any language into software in machine code. This process is called compilation.

There is another method that can combine the processes of translation and program execution, and it is called interpretation. The essence of the process is as follows: first it is translated into machine codes, then the first line of software is executed. When the first line is completed, translation of the second line begins, and so on.

So, from this we can conclude that an interpretation is a program that is intended for line-by-line translations and the original program.

Well, that seems to be all for today, now you know what they are programming languages, and what they are.

It is common knowledge that information Technology are one of the fastest growing areas modern life. New technologies, projects, names and abbreviations appear almost every day. And in pursuit of progress, in an effort to keep up with it, it is sometimes useful to stop for a minute, stand on tiptoe and look around. Take a look at the horizon, remember history and think about the future... In order to plunge back into work with fresh energy, master new technologies, increase your own efficiency and well-being. Until you want to stand on your tiptoes again...

I was prompted to write this article by a discussion that flared up on one of the dotSITE forums after a message appeared there that sharply criticized C#, one of the main components of the new .NET platform from Microsoft. The message contained already quite banal criticism of Microsoft in general and in particular (I am not saying here that there is nothing to criticize Microsoft for, it’s just that this criticism has already set the teeth on edge), as well as some statements specifically about C#. During the ensuing discussion, several interesting comments were made, but some questions remained unaddressed. All this prompted me to write an article in which an attempt is made to “reconcile” in some way those who hold opinions about the exclusivity of a particular programming language. I will try to give some historical outline of the development of various languages ​​and explain with examples some general trends. Perhaps I can convince someone of the futility of holding discussions similar to the above. I do not claim either objectivity (although I will try to be so) or completeness of presentation. This is just an attempt to “stand on tiptoe and look around”...

1. The first universal languages

So, let's begin. Let's turn to the origins of development computer technology. Let's remember the very first computers and programs for them. This was the era of programming directly in machine codes, and the main storage media were punched cards and punched tapes. Programmers were required to know the machine's architecture thoroughly. The programs were quite simple, which was determined, firstly, by the very limited capabilities of these machines, and, secondly, by the great complexity of developing and, most importantly, debugging programs directly in machine language. At the same time, this method of development gave the programmer incredible power over the system. It became possible to use such ingenious algorithms and ways of organizing programs that modern developers had never dreamed of. For example, such a feature as self-modifying code could be used (and was used!). Knowledge of the binary representation of commands sometimes made it possible not to store some data separately, but to embed them in the code as commands. And this is far from full list techniques, mastery of at least one of which now immediately propels you to the level of a top-class “guru.”

2. Assembler

The first significant step seems to be the transition to assembly language (let us allow ourselves a small lyrical digression: the English name assembly language, or assembler, is translated into Russian by exactly the same term that was used above. At the same time, the beginner gets the impression that the language is named after a certain person by named assembler. Quite a funny situation, isn't it?). A seemingly not very noticeable step - the transition to symbolic encoding of machine instructions - was actually of great importance. The programmer no longer had to delve into the ingenious ways of encoding commands at the hardware level. Moreover, often essentially identical commands were encoded in completely different ways depending on their parameters (a well-known example from the world of modern computers is the encoding of the mov instruction in Intel processors: There are several completely differently encoded variants of the command; the choice of one or another option depends on the operands, although the essence of the operation is unchanged: place the contents (or value) of the second operand into the first). It also became possible to use macros and labels, which also simplified the creation, modification and debugging of programs. There was even some semblance of portability - it was possible to develop a whole family of machines with a similar instruction system and some kind of common assembler for them, without the need to ensure binary compatibility.

At the same time, the transition to a new language also contained some negative (at least at first glance) sides. It became almost impossible to use all sorts of clever techniques akin to those mentioned above. In addition, here, for the first time in the history of programming development, two representations of the program appeared: in source texts and in compiled form. At first, while assemblers were just translating mnemonics into machine codes, one was easily translated into another and back again, but then, as features such as labels and macros became available, disassembling became more and more difficult. By the end of the assembler era, the possibility of automatic translation in both directions was completely lost. In this regard, a large number of special disassembler programs have been developed that perform inverse transformations, but in most cases they can hardly separate code and data. In addition, all logical information (names of variables, labels, etc.) is lost forever. In the case of the problem of decompiling high-level languages, examples of a satisfactory solution to the problem are completely rare.

3. FORTRAN

In 1954, the Fortran programming language was created within the depths of IBM Corporation by a group of developers led by John Backus.

The significance of this event is difficult to overestimate. It is the first high-level programming language. For the first time, a programmer could truly abstract himself from the peculiarities of machine architecture. The key idea that distinguishes new language from assembler, there was the concept of subroutines. Let us remind you that this modern computers support routines at the hardware level, providing the corresponding instructions and data structures (stack) directly at the assembler level, but in 1954 this was completely different. Therefore, compiling Fortran was by no means a trivial process. In addition, the syntactic structure of the language was quite complex for machine processing, primarily due to the fact that spaces were not used at all as syntactic units. This gave rise to a lot of opportunities for hidden errors, such as:

In Fortran the following construct describes " for loop to mark 10 when changing the index from 1 to 100": DO 10 I=1.100 If you replace the comma here with a dot, you get the assignment operator: DO10I = 1.100 They say that such an error caused the rocket to explode during launch!

The Fortran language was (and is still used today) for scientific computing. It suffers from the absence of many familiar language constructs and attributes; the compiler practically does not check a syntactically correct program in terms of semantic correctness (type matching, etc.). It does not support modern ways of structuring code and data. The developers themselves were aware of this. According to Backus himself, they were faced with the task of developing a compiler rather than a language. Understanding the independent significance of programming languages ​​came later.

The introduction of Fortran was met with even more fierce criticism than the introduction of assembler. Programmers were afraid of the reduction in program efficiency due to the use of an intermediate link in the form of a compiler. And these fears were justified: indeed, a good programmer, most likely, when solving any small problem by hand, will write code that works faster than the code obtained as a compilation result. After some time, the understanding came that the implementation of large projects is impossible without the use of high-level languages. The power of computers grew, and the decline in efficiency, which was previously considered threatening, became possible to come to terms with. The advantages of high-level languages ​​became so obvious that they prompted developers to create new languages, more and more advanced.

4.Cobol

In 1960, the Cobol programming language was created. It was intended to be a language for creating commercial applications, and it became one. Thousands of commercial application systems are written in Cobol. A distinctive feature of the language is the ability efficient work with large amounts of data, which is typical of commercial applications. The popularity of Cobol is so high that even now, with all its shortcomings (in structure and design, Cobol is largely reminiscent of Fortran), new dialects and implementations are appearing. So recently, an implementation of Cobol compatible with Microsoft .NET appeared, which probably required introducing some features of an object-oriented language into the language.

In 1964, the same IBM corporation created the PL/1 language, which was intended to replace Cobol and Fortran in most applications. The language had an exceptional wealth of syntactic structures. It introduced exception handling and parallelism support for the first time. It should be noted that the syntactic structure of the language was extremely complex. Spaces have already been used as syntactic delimiters, but keywords were not reserved. In particular, next line- this is a completely normal operator in PL/1: IF ELSE=THEN THEN THEN; ELSE ELSE

Because of these features, developing a compiler for PL/1 was extremely difficult. The language never became popular outside the IBM world.

6.BASIC

In 1963, the BASIC (Beginners’ All-Purpose Symbolic Instruction Code) programming language was created at Dartmouth College. The language was conceived primarily as a teaching tool and as the first programming language to be learned. It was intended to be easy to interpret and compile. It must be said that BASIC has truly become the language in which one learns to program (at least, this was the case a few years ago; now this role is being taken over by Pascal). Several powerful implementations of BASIC have been created that support the latest programming concepts (Microsoft Visual Basic is the prime example).

7. Algol

In 1960, a team led by Peter Naur created the Algol programming language. This language gave rise to a whole family of Algol-like languages ​​(the most important representative is Pascal). In 1968 it appeared a new version language. She didn't find it so wide practical application, like the first version, but was very popular in theorist circles. The language was quite interesting, as it had many unique characteristics at that time.

8. Further development programming languages

At this point I prefer to pause and make some remarks. The creation of each of the above-mentioned languages ​​(with the possible exception of Algol) was caused by certain practical requirements. These languages ​​served as the foundation for later developments. They all represent the same programming paradigm. The following languages ​​went significantly further in their development, towards deeper abstraction.

I will present information about later languages ​​in the form of descriptions of families of languages. This will allow us to better trace the relationships between individual languages.

9. Pascal-like languages

The language was created in 1970 by Niklaus Wirth Pascal programming. The language is remarkable in that it is the first widely used language for structured programming (the first, strictly speaking, was Algol, but it was not so widely used). For the first time, the unconditional jump operator no longer plays a fundamental role in controlling the order of execution of statements. This language also introduced strict type checking, which made it possible to identify many errors at the compilation stage.

A negative feature of the language was its lack of tools for dividing a program into modules. Wirth recognized this and developed the Modula-2 language (1978), in which the idea of ​​a module became one of the key concepts of the language. In 1988, Modula-3 appeared, which added object-oriented features. The logical continuation of Pascal and Modula are the Oberon and Oberon-2 languages. They are characterized by a movement towards object- and component-orientation.

10. C-like languages

In 1972, Kernighan and Ritchie created the C programming language. It was created as a language for developing the UNIX operating system. C is often called a “portable assembler,” meaning that it allows you to work with data almost as efficiently as an assembly language, while providing structured control constructs and high-level abstractions (structures and arrays). This is what accounts for his enormous popularity to this day. And this is precisely his Achilles heel. The C compiler has very little type control, so it's very easy to write a program that looks perfectly correct but is logically flawed.

In 1986, Bjarne Stroustrup created the first version of the C++ language, adding object-oriented features taken from Simula (see below) to the C language and correcting some of the language's bugs and bad decisions. C++ continues to improve to this day; in 1998, a new (third) version of the standard was released, containing some quite significant changes. The language has become the basis for the development of modern large and complex projects. He also has, however, weak sides, arising from efficiency requirements.

In 1995, the Sun Microsystems Corporation was created by Ken Arnold and James Gosling. Java language. It inherited the syntax of C and C++ and was spared some of the latter's unpleasant features. A distinctive feature of the language is the compilation of a certain abstract machine into code, for which an emulator (Java Virtual Machine) is then written for real systems. In addition, Java does not have pointers or multiple inheritance, which greatly increases the reliability of programming.

In 1999–2000, Microsoft created the C# language. It is quite similar to Java (and was intended as an alternative to the latter), but it also has distinctive features. Focused mainly on the development of multi-component Internet applications.

11. Ada and Ada 95 languages

In 1983, under the auspices of the US Department of Defense, the Ada language was created. The language is remarkable in that many errors can be detected at the compilation stage. In addition, many aspects of programming that are often left to the operating system (concurrency, exception handling) are supported. In 1995, the Ada 95 language standard was adopted, which develops previous version, adding object-orientation to it and correcting some inaccuracies. Both of these languages ​​are not widely used outside of military and other large-scale projects (aviation, rail transportation). The main reason is the difficulty of mastering the language and its rather cumbersome syntax (much more cumbersome than Pascal).

12. Data processing languages

All of the above languages ​​are general-purpose languages ​​in the sense that they are not targeted or optimized for the use of any specific data structures or for use in any specific areas. A large number of languages ​​have been developed, targeting fairly specific applications. Below is short review such languages.

In 1957, an attempt was made to create a language to describe mathematical data processing. The language was named APL (Application Programming Language). Its distinctive feature was the use of mathematical symbols (which made it difficult to use on text terminals; the appearance graphical interfaces eliminated this problem) and a very powerful syntax that made it possible to perform many non-trivial operations directly on complex objects, without resorting to breaking them into components. Widespread use was prevented, as already noted, by the use of non-standard symbols as elements of syntax.

14. Snobol and Icon

In 1962, the Snobol language (and in 1974, its successor Icon) appeared, designed for string processing. The syntax of Icon is reminiscent of C and Pascal at the same time. The difference lies in the presence of powerful built-in functions for working with strings and special semantics associated with these functions. The modern analogue of Icon and Snobol is Perl, a string and text processing language that adds some object-oriented capabilities. It is considered a very practical language, but lacks elegance.

15.SETL

In 1969, the SETL language was created - a language for describing operations on sets. The main data structure in the language is a set, and the operations are similar to mathematical operations on sets. Useful when writing programs that deal with complex abstract objects.

16. Lisp and similar languages

In 1958, the Lisp language appeared - a language for processing lists. It has become quite widespread in artificial intelligence systems. Has several descendants: Planner (1967), Scheme (1975), Common Lisp (1984). Many of his traits were inherited modern languages functional programming.

17. Scripting languages

IN Lately Due to the development of Internet technologies, the widespread use of high-performance computers and a number of other factors, so-called scripting languages ​​have become widespread. These languages ​​were initially oriented towards use as internal control languages ​​in all kinds of complex systems. Many of them, however, have gone beyond the scope of their original application and are now used in completely different areas. The characteristic features of these languages ​​are, firstly, their interpretability (compilation is either impossible or undesirable), secondly, simplicity of syntax, and thirdly, easy extensibility. Thus, they are ideal for frequent use changeable programs, Very small programs or in cases where the execution of language operators takes time that is incomparable with the time of their parsing. A fairly large number of such languages ​​have been created; we will list only the main and most frequently used ones.

18. JavaScript

The language was created by Netscape Communications as a language for describing the complex behavior of web pages. Originally called LiveScript, the reason for the name change was due to marketing considerations. Interpreted by the browser when the web page is rendered. The syntax is similar to Java and (remotely) to C/C++. It has the ability to use the browser's built-in object functionality, but is not a truly object-oriented language.

19. VBScript

The language was created by Microsoft Corporation largely as an alternative to JavaScript. Has a similar scope. Syntactically similar to the Visual Basic language (and is a truncated version of the latter). Just like JacaScript, it is executed by the browser when displaying web pages and has the same degree of object-orientation.

20. Perl

The language was created to help system administrator Unix operating system for processing various types of texts and highlighting necessary information. It has developed into a powerful tool for working with texts. It is an interpreted language and is implemented in almost all existing platforms. It is used in text processing, as well as for dynamic generation of web pages on web servers.

21.Python

An interpreted object-oriented programming language. It is similar in structure and scope to Perl, but is less widespread and more strict and logical. There are implementations for most existing platforms.

22. Object-oriented languages

The object-oriented approach, which replaced the structural one, did not first appear in C++, as some believe. There is a whole series of pure object-oriented languages, without information about which our review would be incomplete.

23. Simula

The first object-oriented language was Simula (1967). This language was intended for modeling various objects and processes, and object-oriented features appeared in it precisely to describe the properties of model objects.

24. Smalltalk

The popularity of object-oriented programming was brought by the Smalltalk language, created in 1972. The language was intended for designing complex graphical interfaces and was the first truly object-oriented language. In it, classes and objects are the only programming constructs. The big disadvantage of Smalltalk is its large memory requirements and low performance received programs. This is due to the not very successful implementation of object-oriented features. The popularity of the C++ and Ada 95 languages ​​is due precisely to the fact that object-orientation is implemented without a significant decrease in performance.

25. Eiffel

There is a language with a very good implementation of object orientation, which is not a superstructure on any other language. This is the language of Eiffel (1986). Being a pure object-oriented programming language, it also improves program reliability through the use of “control statements.”

26. Parallel programming languages

Majority computer architectures and programming languages ​​are focused on the sequential execution of program statements. At present, however, there are software and hardware systems that make it possible to organize the parallel execution of various parts of the same computing process. To program such systems, special support is required from programming tools, in particular programming languages. Some general-purpose languages ​​contain elements of parallelism support, but programming truly parallel systems sometimes requires special techniques.

27. Occam language

The Occam language was created in 1982 and is intended for programming transputers - multiprocessor distributed data processing systems. It describes the interaction of parallel processes in the form of channels - ways of transmitting information from one process to another. Let us note a feature of the syntax of the Shccam language - in it, the sequential and parallel orders of execution of operators are equal, and they must be explicitly indicated with the keywords PAR and SEQ.

28. Linda parallel computing model

In 1985, the Linda parallel computing model was proposed. Its main task is to organize interaction between parallel running processes. This is achieved by using a global tuple space. A process can place a tuple of data there (that is, a collection of several, possibly heterogeneous, data), and another process can wait for a certain tuple to appear in the tuple area and, after its appearance, read the tuple and possibly subsequently delete it. Note that a process can, for example, place a tuple in an area and exit, and another process can use that tuple some time later. This ensures the possibility of asynchronous interaction. Obviously, using such a model, synchronous interaction can also be simulated. Linda is a parallel computing model and can be added to any programming language. There are quite efficient implementations of Linda that get around the problem of having a global tuple region with potentially unlimited memory.

29. Non-imperative languages

All the languages ​​discussed earlier have one thing in common: they are imperative. This means that programs on them ultimately represent step by step description solving this or that problem. You can try to describe only the statement of the problem, and entrust the compiler to solve the problem. There are two main approaches that develop this idea: functional and logic programming.

30. Functional languages

The basic idea behind functional programming is the representation of a program as mathematical functions (that is, functions whose meaning is determined only by their arguments, and not by the execution context). The assignment operator is not used in such languages ​​(or at least its use is discouraged). Imperative possibilities, as a rule, exist, but their use is subject to serious restrictions. There are languages ​​with lazy and energetic semantics. The difference is, roughly speaking, that in languages ​​with energetic semantics the computation is done in the same place where it is declared, while in the case of lazy semantics the computation is done only when it is actually needed. The former languages ​​have more efficient implementation, while the latter have better semantics.

Among languages ​​with energetic semantics, we mention ML and its two modern dialects - Standard ML (SML) and CaML. The latter has an object-oriented descendant - Objective CaML (O'CaML).

Among languages ​​with lazy semantics, the two most common are Haskell and its simpler dialect Clean.

More information about functional languages ​​can be found HERE:

31. Logic programming languages

Programs in logic programming languages ​​are expressed as mathematical logic formulas, and the compiler attempts to derive consequences from them.

The ancestor of most logic programming languages ​​is Prolog (1971). It has a number of descendants - Parlog (1983, focused on parallel computing), Delta Prolog, etc. Logic programming, like functional programming, is a separate area of ​​programming, and for more detailed information we refer the reader to specialized literature.

32. Instead of a conclusion

Let me highlight some general trends in the development of programming languages. The astute reader has probably already guessed what I am going to say a long time ago. Languages ​​evolve towards greater and greater abstraction. And this is accompanied by a drop in efficiency. Question: is abstraction worth it? Answer: worth it. It’s worth it, since increasing the level of abstraction entails increasing the level of programming reliability. Low efficiency can be combated by creating more fast computers. If memory requirements are too high, you can increase the memory size. This, of course, takes time and money, but it can be solved. But there is only one way to deal with errors in programs: they must be corrected. Or better yet, don’t do it. Better yet, make it as difficult as possible to commit them. And this is precisely what all research in the field of programming languages ​​is aimed at. And you have to come to terms with the loss of efficiency.

The purpose of this review was to try to give the reader an idea of ​​the variety of existing programming languages. Among programmers there is often an opinion about the “universal applicability” of a particular language (C, C++, Pascal, etc.). This opinion arises for several reasons: lack of information, habit, inertia of thinking. I tried to slightly compensate for the first factor. Regarding the rest, I can only say that a true professional must constantly strive to improve his professional qualifications. And for this you need not to be afraid to experiment. So what if everyone around you writes in C/C++/VB/Pascal/Perl/Java/… (underline as appropriate)? Why not try something new? What if this turns out to be more effective? Of course, before you start using a new language, you need to carefully study all its features, including the availability of an effective implementation, the ability to interact with existing modules, etc., and only then make a decision. Of course, there is always a risk of going the wrong way, but... Only those who do nothing make no mistakes.

And further. I have heard and sometimes participated in discussions like “language A is better than language B.” I hope that after reading this review, many will be convinced of the pointlessness of such disputes. The maximum that can be discussed is the advantages of one language over another when solving a particular problem under certain conditions. This is where there really is sometimes something to argue about. And the solution is sometimes not at all obvious. However, arguing “in general” is obvious stupidity.

This article was intended as a response to those who cry “language X MUST DIE”. I hope that the answer turned out to be quite adequate and convincing. I also hope that the article has, in addition to polemical, educational value.

Material from Wikipedia