Programming language for engineering solutions. Programming languages

Standardization of programming languages

International standards have been created for many widely used programming languages. Special organizations regularly update and publish specifications and formal definitions of the corresponding language. Within the framework of such committees, the development and modernization of programming languages ​​continues and issues are resolved on the expansion or support of existing and new language constructs.

Data types

Modern digital computers are binary and data is stored in binary (binary) code (although implementations in other number systems are possible). This data typically reflects real-world information (names, bank accounts, measurements, etc.) representing high-level concepts.

A special system by which data is organized in a program is type system programming language; the development and study of type systems is known as type theory. Languages ​​can be divided into static typing and dynamic typing, as well as untyped languages(For example, Forth).

Statically typed languages ​​can be further subdivided into languages ​​with mandatory declaration, where every variable and function declaration has a mandatory type declaration, and languages ​​with inferred types. Sometimes dynamically typed languages ​​are called latently typed.

Data Structures

Type systems in high-level languages ​​allow the definition of complex, composite types, so-called data structures. Typically, structural data types are formed as the Cartesian product of base (atomic) types and previously defined composite types.

Basic data structures (lists, queues, hash tables, binary trees, and pairs) are often represented by special syntax constructs in high-level languages. Such data is structured automatically.

Semantics of programming languages

There are several approaches to defining the semantics of programming languages.

The most widespread varieties of the following three: operational, derivational (axiomatic) and denotational (mathematical).

• When describing semantics within the framework operational approach, the execution of programming language constructs is usually interpreted with the help of some imaginary (abstract) computer.
• Axiomatic semantics describes the consequences of executing language constructs using the language of logic and setting pre- and postconditions.
• Dental semantics operates with concepts typical of mathematics - sets, correspondences, as well as judgments, statements, etc.

Programming paradigm

A programming language is built according to one or another basic computing model and programming paradigm.

Despite the fact that most languages ​​are focused on the imperative model of computing, given by the von Neumann computer architecture, there are other approaches. We can mention languages ​​with a stack computing model (Forth, Factor, PostScript, etc.), as well as functional (Lisp, Haskell,,, REFAL, based on the computing model introduced by the Soviet mathematician A. A. Markov Jr., etc.) and logic programming (Prolog).

Currently, declarative and visual programming languages ​​are also actively developing, as well as methods and tools for developing problem-specific languages ​​(see Language-Oriented Programming).

Ways to Implement Languages

Programming languages ​​can be implemented as compiled, interpreted, and embeddable.

A program in a compiled language with the help of a compiler (a special program) is converted (compiled) into machine code (a set of instructions) for a given type of processor and then assembled into an executable module that can be launched for execution as a separate program. In other words, the compiler translates the source code of the program from a high-level programming language into binary codes of processor instructions.

If the program is written in an interpreted language, then the interpreter directly executes (interprets) the source text without prior translation. The program remains in its original language and cannot be run without an interpreter. The processor of a computer, in this connection, can be called an interpreter for machine code.

The division into compiled and interpreted languages ​​is conditional. So, for any traditionally compiled language, such as Pascal, you can write an interpreter. In addition, most modern "pure" interpreters do not execute language constructs directly, but compile them into some high-level intermediate representation (for example, with variable dereference and macro expansion).

For any interpreted language, you can create a compiler - for example, the language Lisp, originally interpreted, can be compiled without any restrictions. Code generated at runtime can also be dynamically compiled at runtime.

As a rule, compiled programs run faster and do not require additional programs, since they have already been translated into machine language. At the same time, each time the program text is changed, it needs to be recompiled, which slows down the development process. In addition, a compiled program can only run on the same type of computer, and usually under the same operating system, for which the compiler was designed. To create executable file for a machine of a different type, a new compilation is required.

Interpreted languages ​​have some specific additional features(see above), in addition, programs on them can be run immediately after the change, which facilitates development. An interpreted language program can often be run in different types machines and operating systems without additional effort.

However, interpreted programs run noticeably slower than compiled programs, and they cannot run without an interpreter program.

This approach, in a sense, allows you to use the advantages of both interpreters and compilers. It should be mentioned that there are languages ​​that have both an interpreter and a compiler (Forth).

Low level programming languages

The first computers had to be programmed with binary machine codes. However, programming in this way is a rather time-consuming and heavy task. To simplify this task, low-level programming languages ​​began to appear, which made it possible to set machine instructions in a human-understandable form. To convert them to binary code special programs - translators were created.

An example of a low level language is assembly language. Low-level languages ​​are focused on a specific type of processor and take into account its features, therefore, in order to port an assembler program to another hardware platform, it must be almost completely rewritten. There are also certain differences in the syntax of programs for different compilers. True, the central processing units for computers from AMD and Intel are practically compatible and differ only in some specific commands. But specialized processors for other devices, such as video cards and phones, contain significant differences.

Low-level languages ​​are usually used to write small system programs, device drivers, interface modules with non-standard equipment, programming specialized microprocessors, when the most important requirements are compactness, speed and the ability to direct access to hardware resources.

High level programming languages

The features of specific computer architectures are not taken into account in them, so the created applications are easily transferred from computer to computer. In most cases, it is sufficient to simply recompile the program for a specific computer architecture and operating system. It is much easier to develop programs in such languages ​​and there are fewer errors. The program development time is significantly reduced, which is especially important when working on large software projects.

Now in the developer community, it is believed that programming languages ​​that have direct access to memory and registers or have assembler inserts should be considered programming languages ​​with a low level of abstraction. Therefore, most of the languages ​​that were considered high-level languages ​​before 2000 are no longer considered high-level languages.

The disadvantage of some high-level languages ​​is big size programs compared to programs in low-level languages. On the other hand, for algorithmically and structurally complex programs, when using supercompilation, the advantage may be on the side of high-level languages. The text of programs in a high-level language is smaller, however, if taken in bytes, then the code originally written in assembler will be more compact. Therefore, high-level languages ​​are mainly used to develop software for computers and devices that have a large amount of memory. And different subtypes of assembler are used for programming other devices, where the size of the program is critical.

Symbols used

Modern programming languages ​​are designed to use ASCII, that is, the availability of all graphic ASCII characters is a necessary and sufficient condition for writing any language constructs. Managers ASCII characters limited use: only carriage return CR, line feed LF, and horizontal tab HT (sometimes also vertical tab VT and next page FF) are allowed.

Early languages, which emerged during the 6-bit character era, used a more limited set. For example, the Fortran alphabet has 49 characters (including space): A B C D E F G H I J K L M N O P Q R S T U V W X Y Z 0 1 2 3 4 5 6 7 8 9 = + - * / () . , $" :

A notable exception is the APL language, which uses a lot of special characters.

The use of non-ASCII characters (such as KOI8-R characters or Unicode characters) is implementation dependent: sometimes they are only allowed in comments and character/string constants, and sometimes they are also allowed in identifiers. In the USSR, there were languages ​​where all keywords were written in Russian letters, but such languages ​​\u200b\u200bdid not gain much popularity (the exception is the Built-in programming language 1C: Enterprise).

The expansion of the character set used is constrained by the fact that many software development projects are international. It would be very difficult to work with code where the names of some variables are written in Russian letters, others in Arabic, and still others in Chinese characters. At the same time, new generation programming languages ​​(Delphi 2006, Java) support Unicode to work with text data.

Categories of programming languages

Mathematically based programming languages

These are languages ​​whose semantics is immediate the embodiment of some mathematical model, slightly adapted (without violating integrity) in order to be a more practical language for developing real programs. Only a few languages ​​fall into this category, most languages ​​are designed with priority in terms of being able to translate efficiently to a Turing machine, and have only some subset in its composition, embodying one or another mathematical model - from

The personal computer, until the mid-sixties, was an overly expensive machine that was used exclusively for special tasks and that performed only 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 tasks of a specific plan, for example, for scientific computing, and not. For the reason 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 were idle for a long time without performing any tasks. And to stop this, time-sharing systems were introduced.

The processor time in these systems, as it were, was "cut", and users could receive alternately short segments of this very time. The computer device began to work much faster, which allowed the user to feel at the terminal as if he was working with the system alone. The device, in turn, was idle less, as it carried out the execution of not one, but several tasks at once. Time sharing, to a large extent, reduced the cost of hardware time, and all thanks to the fact that one device could be shared not by one user, or even by two, but by hundreds.

So, when power became cheaper and more accessible, those who created programming languages ​​began to think more and more about writing software more conveniently, and not about the speed of their execution. "Small" operations, that is, operations of the atomic type, which were directly performed by the devices of the devices, were combined into more "voluminous" 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 computer program. With the help of such a language, the programmer will be able to accurately determine what events the PC will respond to, how information will be stored and transmitted, and also what actions need to be performed on these circumstances of various types.

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

What are programming languages ​​for?

The process of running a PC is the execution of a program. To put it more plain language, that is, a batch of commands that follow in a specific order. The type of machine type instruction, which consists of zeros and ones, indicates what actions the central processor should perform. From this it follows: in order to set the PC the sequence of actions to be performed, a sequence of binary type codes of the corresponding commands is set. In machine code, software consists of many instructions. Writing such software is laborious, heavy 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 in its execution. It is much easier to write software in a language that is closer to human natural language and have a PC translate that program into machine type codes. This is how programming languages ​​appeared, which are intended specifically for writing software.

There are now a large number different languages programming. To solve many problems, you can apply each of them. Specialists in their field know exactly which programming language to use to solve any problems, since each of the languages ​​\u200b\u200bis equipped with its own capabilities, orientation to certain types of tasks, and also have their 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 are low level and languages ​​that are high level.

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

But, programming languages ​​that have a high level are most often used for programs by those who create them. Such a language, in principle, just like the human language, has its own alphabet, namely, a large number of symbols that are used in languages. These characters are necessary to form 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. Key words are combined into sentences with each other 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 that has a high level is the link between the PC and the user, offering him to communicate with the PC in a way that is most convenient for the person. Quite often, this language helps to choose the right method of solving problems.

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

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

What are the 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 problems of a scientific and technical type using a digital computer. In addition, like the first computing units, this type of language was used to carry out natural science and mathematical calculations. This language in an improved type has survived to our time, and it is, among modern languages ​​that have a high level, the most used in scientific research. The most common variants today are: Fortran-I2, Fortran-I4, EASIC Fortran and their generalizations.

ALGOL

We continue our theme of programming languages. As you already understood, now we will talk about such a programming language as Algol, which appeared in 1958-1960. In 1964-1968 it was improved, so Algol - 68 appeared. This type of language was developed by a committee, which included scientists from America and Europe, and attributed it to languages ​​that have a high level. Using a language of this type, algebraic formulas could be easily translated into program commands. Algol was popular not only in Europe, but also in Russia. For all programming languages ​​created after some time, this type of language had a noticeable impact, and in particular, this affected the Pascal language. This type of language, in principle, just like the Fortran language, was created to solve problems of a scientific and technical type. In addition, the language was used as a means of teaching the basics of programming, that is, the art of compiling 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 the development of applications for business and for solving problems of an economic type, for processing banking data, for insurance companies and other institutions. Cobol's "inventor" is Grace Hopper. Usually, for cumbersomeness and verbosity, COBOL is criticized, since one of the goals of the creators of this language was the maximum approximation to English language. At the same time, the programming language had for its time excellent means for carrying out activities with data structures and files, and this, by the way, provided it with a long life in business applications. At least in the US, that's 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 widely used to process information in the form of symbols and is used to create software that mimics the activity 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, which are written in the form of a list - one of the main structures of this type of language. The main meaning of the Lisp program is "life" in character 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 a few years it became more convenient for text processing and matrix arithmetic. This kind of programming language was originally implemented on the GE-265 mainframe, which supports a large number of terminals. At the time of its inception, contrary to popular belief, it was a compiled language.

This kind of programming language was designed so that students could write programs using time-sharing terminals. It was created not only to solve a problem that is associated with problematic, older languages, but also it was intended to be used by "simple" users who are not interested in the speed of the program, but are interested in the possibility of using a PC to resolve their tasks. Most novice programmers, due to the simplicity of this type of language, start 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 the tasks of controlling various kinds of systems after its creator, Moore Charles, wrote software on it that was intended to control the radio telescopes of 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 tool-type tools. The obvious applications of this kind of programming language are embedded control systems. In addition to all of the above, he also found application in programming PCs running various kinds of operating systems.

Pascal

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

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

Continuing the topic of programming languages, we decided to talk about another type of language - the Ada language. The programming language Ada was created from Pascal in the late seventies and named after Ada Lovelace, a gifted female mathematician. It was this talented woman who in 1843 explained to the whole world the possibilities of Charles Babbage's Analytical Unit. This type of language was developed by order of the US Department of Defense, and was originally 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 tools. Syntax programming language of this type is taken from Pascal and Algol, it has been expanded and executed in a logical and strict style. Ada is a programming language that has strong typing, and it completely eliminates work 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 2 languages, namely, BCPL and B. Martin Richards created BCPL in 1967 as a language that was intended for writing system software and compilers. What it is, we will describe below. Ken Thompson used a DEC PDP-7 on a PC in 1970 to build earlier versions of UNIX. In both the first and second languages, variables were not divided into types - each data value had one word in memory.

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

In the traditional programming language - the C language has become 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 on 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. Experts from the University of Marseille took part in the development. They named it from the words "PROGRAMMING IN THE LOGIC LANGUAGE". The programming language was created on the basis of 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, that is, descriptive languages.

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

Compiler and interpreter

It is not enough to develop a language that would be convenient for writing a program. Each language must have an interpreter, who is special program- 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 compiler, which is also a program. It is intended for translating software written in any language into software in machine type codes. This process is called compilation.

There is another way 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 type codes, then the first line of the software is executed. When the execution of the first line is completed, the 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, it seems that's all for today, now you know what are programming languages and what they are.

It is well known that Information Technology are one of the fastest growing areas of modern life. New technologies, projects, names and abbreviations appear almost every day. And in the 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 the 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 get up on your tiptoes again...

I was inspired to write this article by a discussion that flared up on one of the dotSITE forums after a post there that sharply criticized C#, one of the main components of the new .NET platform from Microsoft. The message contained already rather banal criticism of Microsoft in general and in particular (I'm not saying here that there is nothing to criticize Microsoft for, it's just that this criticism has already pretty much set the teeth on edge), as well as some statements specifically about C#. In the course of the ensuing discussion, several curious remarks were made, while some questions remained untouched. All this prompted me to write an article in which an attempt is made to "reconcile" in some way the carriers of 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 some general trends with examples. Perhaps I can convince someone of the futility of holding discussions like the one above. I do not pretend either to be objective (although I will try to be so), or to be complete. It's just an attempt to "stand on tiptoe and look around"...

1. The first universal languages

So, let's begin. Let us turn to the origins of the development of computer technology. Let's remember the very first computers and programs for them. This was the era of programming directly in machine codes, and punched cards and punched tapes were the main carrier of information. Programmers were required to know the architecture of the machine thoroughly. The programs were quite simple, which was caused, 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 way 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 could not even dream of. For example, such an opportunity as a 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 it's far from full list techniques, the possession of at least one of which now immediately promotes you to the level of an extra-class "guru".

2. Assembler

The first significant step seems to be the transition to assembly language (let's allow ourselves a small lyrical digression: English name assembly language, or assembler, is translated into Russian with exactly the term that was used above. In this case, the beginner gets the impression that the language is named after a certain person named assembler. Quite a funny situation, isn't it?). A seemingly not very noticeable step - the transition to symbolic coding of machine instructions - was in fact of great importance. The programmer no longer had to delve into the intricate 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 coding of the mov instruction in Intel processors: there are several completely different encoded command options; the choice of one or another option depends from the operands, although the essence of the operation being performed is the same: put the contents (or value) of the second operand into the first). There was also the possibility of using 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 common assembler for them, while there was no need to ensure binary compatibility.

At the same time, the transition to a new language was fraught with some negative (at least at first glance) sides. It became almost impossible to use all sorts of ingenious tricks akin to those mentioned above. In addition, for the first time in the history of programming development, two representations of the program appeared here: in source texts and in compiled form. At first, while assemblers only translated mnemonics into machine codes, one was easily translated into the other and vice versa, but then, as features such as labels and macros appeared, disassembly 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 reverse conversions, 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 quite rare.

3. Fortran

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

The significance of this event cannot be overestimated. It is the first high-level programming language. For the first time, a programmer could truly abstract from the peculiarities of machine architecture. The key idea that distinguishes new language from assembler, was the concept of subroutines. Recall that this modern computers support subroutines at the hardware level, providing the appropriate commands and data structures (stack) directly at the assembler level, 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 difficult for machine processing, primarily due to the fact that spaces were not used as syntactic units at all. This created a lot of opportunities for hidden errors, such as:

In Fortran, the following construct describes "a for loop up to label 10 when the index changes from 1 to 100": DO 10 I=1,100 If we replace the comma with a dot here, we get an assignment statement: DO10I = 1.100 It is said that such an error caused the rocket to explode in start time!

Fortran was used (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 also aware of this. According to Backus himself, they were faced with the task of developing a compiler rather than a language. The understanding of 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 decrease 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 some small problem by hand, will write code that works faster than the code obtained as a result of compilation. 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 with the drop in efficiency, which was previously considered threatening, it became possible to put up with it. The advantages of high-level languages ​​have become so obvious that they have prompted developers to create new languages, more and more perfect.

4.Cobol

In 1960, the Cobol programming language was created. It was conceived as a language for creating commercial applications, and it has become one. Thousands of applied commercial systems are written in Kobol. A distinctive feature of the language is the ability to work effectively with large data sets, 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 resembles Fortran in many ways), new dialects and implementations of it appear. So recently, a Microsoft .NET-compatible implementation of Cobol has appeared, which probably required some features of an object-oriented language to be introduced 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 possessed an exceptional wealth of syntactic constructions. It introduced exception handling and concurrency support for the first time. It should be noted that the syntactic structure of the language was extremely complex. Spaces were already used as syntactic separators, but keywords were not reserved. In particular, the following line is a perfectly normal PL/1 statement: IF ELSE=THEN THEN THEN; ELSE ELSE

Due to such features, the development of 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 means of learning and as the first programming language to be learned. It was supposed to be easy to interpret and compile. I must say that BASIC has really become the language in which people learn to program (at least it was so a few years ago; now this role is being taken over by Pascal). Several powerful implementations of BASIC have been created that support the most modern programming concepts (the clearest example is Microsoft Visual Basic).

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 appeared a new version language. It did not find as wide a practical application as the first version, but was very popular among theoreticians. The language was quite interesting, as it had many characteristics that were unique at that time.

8. Further development programming languages

At this point I would like to stop and make some remarks. The creation of each of the above languages ​​(with the possible exception of Algol) was driven by some practical requirement. These languages ​​provided the foundation for later developments. They all represent the same programming paradigm. The following languages ​​went much further in their development, towards deeper abstraction.

I will give information about later languages ​​in the form of a description of families of languages. This will allow you to better trace the relationship between individual languages.

9. Pascal-like languages

In 1970, Niklaus Wirth created the Pascal programming language. 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 widely used). For the first time, the unconditional branch operator has ceased to play a fundamental role in controlling the order in which operators are executed. This language also introduced strong type checking, which made it possible to detect many errors at compile time.

The negative feature of the language was the lack of means in it for breaking the 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. Oberon and Oberon-2 are the logical continuation of Pascal and Modula. They are characterized by a movement towards object and component orientation.

10. C-Like Languages

In 1972, the C programming language was created by Kernighan and Ritchie. It was created as a language for developing the UNIX operating system. C is often referred to as "portable assembler", meaning that it allows you to work with data almost as efficiently as assembler, while providing structured control constructs and high-level abstractions (structures and arrays). This is the reason for its immense popularity to this day. And this is precisely its Achilles' heel. The C compiler has very little control over types, so it is very easy to write a program that looks perfectly correct but is logically wrong.

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 fixing some of the language's bugs and bad decisions. C++ continues to improve at the present time, so in 1998 a new (third) version of the standard was released, containing some fairly significant changes. The language has become the basis for the development of modern large and complex projects. He also has, however, weaknesses arising from efficiency requirements.

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

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

11. Languages ​​Ada and Ada 95

In 1983, the Ada language was created under the auspices of the US Department of Defense. The language is remarkable in that a lot of errors can be detected at the compilation stage. In addition, many aspects of programming that are often left to the operating system (parallelism, 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 the military and other large-scale projects (aviation, rail transport). The main reason is the difficulty of mastering the language and the 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 oriented or optimized for use in any particular data structure or for use in any particular area. A large number of languages ​​have been developed for quite specific applications. Below is a brief overview of such languages.

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

14. Snobol and Icon

In 1962, the Snobol language (and in 1974 its successor Icon) appeared, designed to process strings. 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 the special semantics associated with these functions. The modern equivalent of Icon and Snobol is Perl, a string and text processing language that adds some object-oriented features. It is considered a very practical language, but it 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 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

Recently, due to the development of Internet technologies, the widespread use of high-performance computers and a number of other factors, the so-called scripting languages ​​have become widespread. These languages ​​were originally oriented to be used as internal control languages ​​in all sorts 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, the simplicity of the 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 statements takes time that is not comparable with the time they are parsed. A fairly large number of such languages ​​have been created, we list only the main and most commonly 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 marketing considerations. Interpreted by the browser when rendering a web page. The syntax is similar to Java and (remotely) to C/C++. Has the ability to use the browser's built-in object functionality, but is not a true object-oriented language.

19.VBScript

The language was created by Microsoft in many ways as an alternative to JavaScript. Has a similar scope. It is 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. Pearl

The language was created to help the system administrator of the operating system. Unix systems for processing various kinds of texts and extracting the necessary information. Developed to a powerful tool for working with texts. It is an interpreted language and is implemented on almost all existing platforms. It is used in word processing, as well as for dynamic generation of web pages on web servers.

21.Python

An interpreted object-oriented programming language. Similar in structure and scope to Perl, but less common and more rigorous and logical. There are implementations for most existing platforms.

22. Object Oriented Languages

The object-oriented approach that replaced the structural approach 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 for describing the properties of model objects.

24.Smalltalk

The popularity of object-oriented programming was brought about 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 the large memory requirements and the low performance of the resulting programs. This is due to the not very successful implementation of object-oriented features. The popularity of C++ and Ada 95 is due precisely to the fact that object-oriented implementation is implemented without a significant performance penalty.

25.Eiffel

There is a language with a very good object-oriented implementation that is not an add-on to any other language. This is the language of Eiffel (1986). Being a pure object-oriented programming language, it also improves the reliability of the program through the use of "control assertions".

26. Parallel programming languages

Most computer architectures and programming languages ​​are oriented towards sequential execution of program statements. At present, however, there are software and hardware systems that allow organizing the parallel execution of various parts of the same computational process. Programming of such systems requires special support from programming tools, in particular, programming languages. Some general-purpose languages ​​contain elements of support for parallelism, but the programming of truly parallel systems sometimes requires special techniques.

27. Occam language

The Okcam language was created in 1982 and is intended for programming transputers - multiprocessor systems for distributed data processing. It describes the interaction of parallel processes in the form of channels - ways to transfer information from one process to another. We note a feature of the syntax of the Uccam language - in it, the sequential and parallel orders of the execution of operators are equal, and they must be explicitly specified 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 through the use of a global tuple space. A process can put a tuple with data there (that is, a collection of several, possibly heterogeneous, data), and another process can wait for some tuple to appear in the tuple area and, after its appearance, read the tuple with its possible subsequent removal. Note that a process may, for example, place a tuple in a region and terminate, and another process may use the tuple after some time. This provides the possibility of asynchronous communication. Obviously, with the help of 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 the existence of a global tuple area with a potentially unlimited amount of memory.

29. Non-imperative languages

All the languages ​​discussed earlier have one thing in common: they are imperative. This means that the programs on them, in the end, are a step-by-step description of the solution of a particular problem. You can try to describe only the problem statement, and entrust the compiler with solving 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 (i.e., functions whose value is determined only by their arguments, not by the execution context). The assignment operator is not used in such languages ​​(or at least not encouraged). Imperative options are usually available, but their use is severely limited. There are languages ​​with lazy and energetic semantics. The difference is, roughly speaking, that in languages ​​with energetic semantics, the evaluation is performed in the same place where they are declared, while in the case of lazy semantics, the evaluation is performed only when it is really necessary. The former languages ​​have a more efficient implementation, while the latter have better semantics.

Of the languages ​​with energetic semantics, let's mention ML and its two modern dialects - Standard ML (SML) and CaML. The latter has an object-oriented child - Objective CaML (O'CaML).

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

More information about functional languages ​​is available HERE:

31. Logic programming languages

Programs in logic programming languages ​​are expressed as formulas of mathematical logic, and the compiler tries 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 details we refer the reader to the specialized literature.

32. Instead of a conclusion

Let me highlight some general trend in the development of programming languages. The astute reader has probably guessed a long time ago what I'm going to say. Languages ​​are evolving towards more and more abstraction. And this is accompanied by a drop in efficiency. Question: is abstraction worth it? Answer: worth it. Worth it, because increasing the level of abstraction entails increasing the level of programming reliability. Low efficiency can be combated by creating more fast computers. If the memory requirements are too high, you can increase the amount. This, of course, requires time and money, but it can be solved. But there is only one way to deal with errors in programs: they must be corrected. Better yet, don't do it. Better yet, make them as difficult as possible. And this is what all research in the field of programming languages ​​is aimed at. And you have to put up with the loss of efficiency.

The purpose of this review was an attempt to give the reader an idea of ​​the diversity existing languages programming. 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 offset the first factor. As for the rest, I can only say that a true professional should constantly strive to improve his professional skills. And for this you need not be afraid to experiment. So what if everyone around writes in C/C++/VB/Pascal/Perl/Java/… (underline as appropriate)? Why not try something new? Would this be more efficient? Of course, before you start using a new language, you need to carefully study all its features, including the presence 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 the one who does nothing is not mistaken.

And further. I have heard and sometimes even participated in discussions of the form “language A is better than language B”. I hope that after reading this review, many will be convinced of the futility of such disputes. The maximum that can be discussed is the advantages of one language over another in solving a particular problem in certain conditions. Here, indeed, there is sometimes something to argue about. And sometimes the solution is by no means obvious. However, arguing “in general” is obviously stupid.

This article was meant to be a response to those who yell "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, and educational value.