Who was the first to write a computer language? The first high-level programming language is Plankalküll

It always seemed to me that Fortran was the first, which is, in particular, reflected in probably the most famous diagram of the history of programming languages. In fact, in terms of influence and popularity, Fortran was of course the first. However, from a historical point of view, no.

[To be completely precise, the truly first programming language was, apparently, the notation with which Charles Babbage's programs were written in the famous article by Ada Augusta Byron, Countess of Lovelace "Sketch Of the Analytical Engine" (the article was translation of an article by the Italian Menabrea on the operation of Babbage's difference engine and contained a significant addition written by Ada Augusta herself). However, it was not quite a programming language, and the machine for which it was intended existed only in the mind of a brilliant person. By the way, I note that in 1991 the Science Museum in London created his machine based on Babbage’s drawings and it now exists in working condition]

So, the first programming language. It was not Fortran at all, but a language with an amazing name - Plankalkül, that is, translated from German as “Calculus of Plans” or “Plan of Calculations”, was developed by the German scientist, inventor and designer Konrad Zuse in Nazi Germany between 1942 and 1945.

[Zuse also designed several different models of computers. For example, his Z3 was also created before the famous Marc I and ENIAC and was at the same time a completely full-fledged machine. ]

It is alleged that Zuse achieved all his achievements absolutely independently, without having information about the work of the Americans and British carried out at a close time, and without even knowing about the work of Babbage.

The creation of a programming language was a natural continuation of the work on creating the “hardware” part of computers. Zuse himself tried to use it to write a program for playing chess. Work on the language was completed around 1946, but the language was not developed and even the written manual was published only in 1972. Because of this, the language turned out to be unknown and did not have a significant impact on the further development of the industry (in comparison, for example, with Fortran).

However, Plankalkül was undoubtedly the world's first high-level programming language. Basic concepts of the language include:

• The presence of subroutines (and this is in the 1940s!!!)
• Presence of assignment operator (=>)
• Cycles
• Conditional statement (if)
• Ability to manipulate arrays
• Ability to manipulate lists

When creating the language, Zuse collected many problems that were posed by engineers and scientists. To demonstrate that the language is truly capable of solving these problems, a huge number of example programs were written (in particular, about 60 pages of examples for a program playing chess).

One of the problems of the language was its extremely complex syntax, which was very unusual for a modern programmer. Here is an example of the assignment A = A+1 in the Plankalkül language.

With this text I want to begin a series of articles about the history of the development of programming languages. It is an adapted version of this collection.

Programming appeared long before the 50s of the 20th century. The first ideas were expressed by Charles Babbage (1792-1871), who is rightfully considered the father of the computer. He did not know about transistors, microcircuits and monitors, but quite accurately described the basic principles on which all computers would be built. The idea was developed by Countess Ada Lovelace (1815-1852). Her place in history still causes a lot of controversy, but one thing is absolutely certain - it was Ada who actually became the first famous programmer. Thanks to her work, it became clear that the way to effectively use machines is through algorithms described in code.

Babbage's Analytical Engine

But programming could not develop in isolation from computers. Without them, it's just mind games, abstraction, regardless of the quality of the ideas. Therefore, until the 1950s, programming languages ​​were a set of machine instructions, often highly specialized and dying out along with the target device.

The essence of the problem

Today you don’t need to know anything about computer architecture; for most programmers, only the language is important, everything else is secondary. In the 1950s, everything was different - you had to work with elementary machine codes, and this is almost the same as programming with a soldering iron.

Another problem was that the development of languages ​​was the responsibility of people directly involved in the creation of computers - primarily engineers and only programmers. That's why they represented the language as a sequence of operation numbers and memory cells. Roughly speaking, it looked like this:

01 x y – adding the contents of memory cell y to cell x;

02 x y – similar procedure with subtraction.

As a result, the program code turned into an endless series of numbers:

01 10 15 02 11 29 01 10 11…

This code may seem like horror to you today, but in the early 1950s it was the norm.

Computer from the 1940s

Programmers had to learn machine commands for a long time, then carefully write the code, and after completion, recheck it several more times - the risk of error was high. Problems arose when the development of machines began to be hampered by a lack of personnel to write programs. An urgent solution was required.

First picker

The solution was obvious: it was necessary to translate the digital designations of operations into letters. That is, instead of “01 10 15” use “ADD 10 15”. This required additional translation of characters into the machine instruction, but given the problem, the sacrifice was minimal.

The solution turned out to be so obvious that it is not known for certain who first invented Assembly language. Most likely, he appeared in several places at once. The authors of the book “The preparation of programs for a digital computer” Wilkes, Wheeler and Gill are considered responsible for the name and popularization. It is not difficult to guess that the name Assembler comes from the English word assemble - to assemble, mount, which quite accurately describes the process. Later, symbols began to concern not only the simplest operations, but also addressing, which greatly simplified the readability of the code.

Now this seems like an elementary solution, but then the implementation was a complex process, requiring the creation of correspondence tables, assigning a designation to each memory cell. This led to three fundamental things:

• The emergence of the concept of a symbolic variable or simply a variable.
• Creating tables with which you could find correspondence between symbols, operations and memory cells.
• Understanding that programming can become an art.

This became the catalyst for a language breakthrough.

Compilers and biases

The assembler made it possible to create simple transformations. For example, transferring 01 to ADD. Macro assembler expanded on this idea and gave programmers the ability to collapse multiple instructions into one. For example, if in a program you were constantly adding a value to a memory location and checking to see if it was full, you could write all this into an INCRT macro and use it, changing only the variables. In fact, macro assemblers became the first high-level languages.

But there was an important problem with this approach - each time before creating code, it was necessary to collapse the basic operations into macros. A tool was needed that would free programmers from constant copying. This is how the compiler appeared.

Now we know that thanks to the compiler we can create a programming language with absolutely any syntax, the main thing is that it correctly translates our code into machine commands. And at that time, experts were skeptical about high-level languages. This was partly due to the performance of computers - simplifying syntax with complex transformations was expensive, and could set technological progress back several years. Part of the reason was emotions - it was difficult to move away from the form of machine commands, to lose control over processes. Programmers were seriously afraid that after compilation they would not be able to understand the executable commands. Today we don't care what machine code looks like, but back then it seemed like an important issue.

Nevertheless, the compiler became the only way out of the situation, but here another difficulty appeared - arithmetic expressions. Their execution is not the same as how the machine reads the code. From the school course we know the order of calculations in the expression “2+3*5”, but the machine reads the code in one direction, so the answer will be incorrect. Yes, the above example can be solved by creating a macro, but complex expressions at the level “(2 + 3 * 5 + 4/6) * 10 + 16- (14 + 15) * 8” required a fundamentally different approach.

The era of a new formation

John Backus, the creator of Fortran, managed to find an algorithm for stack analysis. He started working on it in 1954 and it took him almost 5 years to prove the right of high-level languages ​​to exist. The full name of Fortran is The IBM Formula Translating System, or FORmula TRANslator. Despite being 60 years old, it remains one of the most popular programming languages ​​and is incredibly in demand in Data Science. During this time, we have seen many versions: Fortran 1, II, 66, 77, 90, 95, 2008, and next year another one will be released (Fortran 2015 was planned, but due to delays the name may change to 2018). It was in Fortran that many attributes of a high-level language were simultaneously implemented for the first time, including:

• arithmetic and logical expressions;
• DO loop (early form of FOR loop);
• conditional IF statement;
• subroutines;
• arrays.

Another important legacy of Fortran that modern programmers are not even aware of is the use of variable constraints for integers. They all had to start with one of the 6 characters I, J, K, L, M, N (derived from I-Nteger). This is where the habit of taking variables i, j, etc. for enumerations came from.

IBM 704 - the machine on which Fortran was created

At the same time, Fortran remained a language close to machines. For example, there was this:

If (expression) doneg, dozero, dopos

The reason was the IBM computer architecture, which required a command to use the correct register: negative, zero or positive. The closeness to machines was also manifested in the famous GOTO command (later it was inherited by Basic), which meant a direct transition to one or another command.

Returning to the problem of arithmetic expressions, the stack brute force algorithm (that is, analyzing the entire string) was not an efficient solution, but it proved how simple and logical the implementation could be.

Languages ​​for everyone

Fortran 1 was a scientific language based on complex number and floating point operations. He didn’t even know how to process text; to do this he had to convert it into special codes. Therefore, Fortran turned out to be unsuitable for business, where the Cobol language was specially created.

Its syntax is fundamentally different, as close as possible to natural English. There was practically no arithmetic, only expressions like:

Move Income To Total Subtract Expenses

Cobol has become the personification of the maximum distance from previous machine-arithmetic thinking to universal human thinking. And most importantly, it was now possible to work with text and records.

The next fundamental language was Algol (ALGOrithmic Language), intended for scientific reports and publications. For the first time, things that were natural to us appeared in it:

• differences between assignment:= and logical equality =;
• using a for loop with three arguments: initial value, limit, step;
• block structure of programs between begin and end, this eliminated the need to use GOTO.

It is from Algol that C, C++, C#, Java and many other popular languages ​​today originated.

The fourth whale of the 1950s was Lisp (LISt Processing language), developed specifically to serve artificial intelligence. Its main feature was working not with imperative data, but with functions. To do this, John McCarthy had to provide many mechanisms for normal operation: dynamic typing, automatic memory allocation, garbage collector. Ultimately, it was Lisp that became the progenitor of languages ​​such as Python and Ruby, and it itself is still actively used in AI.

Thus, the 1950s changed the way programmers think, gave birth to four fundamental languages, and set the world on the path to the computer revolution.
Next time we'll talk about how languages ​​and the world of programming developed in the 1960s.

If you are thinking of learning programming, the programming language you decide to choose first is of great importance, it should be related to what you want to do in the future and be relevant. While programming in general is not for the lazy, some languages ​​are easier to learn than others and have communities that are dedicated to learning and offer useful skills for learning other programming languages.

Selection scheme

There are questions that are asked so often that entire diagrams are created to answer them. Here, for example, is one of them, dedicated to choosing the first programming language.

When choosing your first programming language, you should soberly evaluate the following factors:

• Labor market.
• Long-term prospects for language.
• Difficulty learning a language.
• What exactly can you create in the process of studying, and, showing others, maintain motivation.

Popularity and demand

JavaScript

JavaScript, not to be confused with Java, is a programming language that was developed in the 90s by Brendan Eich, formerly of Netscape Communications and now of the Mozilla Foundation. JavaScript is one of the fundamental technologies that powers the web community as we know it. Don't be fooled, although JavaScript exists outside of the browser, it exists primarily in the context of connected applications and services.

The language itself is dynamic and gives programmers the flexibility to use object-oriented programming styles (since the language itself is primarily object-oriented), as well as functional and imperative. It derives most of its syntax from C, and if you plan to do any web development in any way, learning JavaScript should be on your list.

Luckily, JavaScript is relatively easy to learn, already in your browser for you to play with, and although it's been around for a while, it's quickly gaining popularity. Many of you who have nominated it have noted that your bang for the buck when learning JavaScript is huge because you can immediately use it to build things for the web, which may very well be what a lot of people learn to code.

Python

I can also recommend Python.

Despite a number of problems historically inherent to Python, it continues to be a leading tool in a number of niches:

Impressive, isn't it? As for large and popular projects written in Python, these are such monsters as:

You can also find on our website.

Computers still have a poor understanding of the natural languages ​​that humans use to communicate, or at least not yet.

In turn, people do not understand machine languages ​​well. Therefore, programming languages ​​were created that cover this gap in understanding, in the thinking model between man and computer.

Programming languages ​​can be:

• simple,
• complex and
• incomprehensible (for example, graphic).

History of programming languages

There are several hundred programming languages ​​in use today, but many more are no longer in use. Over time, new programming languages ​​were developed for new tasks.

Zero generation

• (electro)
• programmed by the structure of their own device
• highly specialized,
• Programming options are limited.

Jacquard loom

An example of such machines is a jacquard weaving machine with a programmable device. It was made in 1804 by the Frenchman Joseph Marie Jacquard. By the way, in his honor, patterned, decorative fabric is called jacquard or jacquard.

Using the machine, it was possible to easily and en masse produce embroidery on fabric using punched cards, shown in the figure below:

Rice. 1. Punch cards for Jacquard loom

Punch cards were programmed with a sequence of actions for machines to reproduce a design on fabric.

Babbage's machine

Internet and Web

Specialized languages ​​have appeared:

• JavaScript.

Many websites are written using PHP and JavaScript.

Some pre-existing languages ​​with the advent of the Internet and the Web found new niches and became web-oriented:

• Ruby,
• Pynton,
• Java.

By the 2000s, old programming languages ​​are gradually dying, new ones are appearing, but there is no generally accepted concept of what happens to these things.

Any programming language is an artificial language that has its own life cycle. Similarly, operating systems of the Windows family also have their own life cycles: .

Life cycle of a programming language:

• Creation,
• early adoption (initial use of language),
• (industrial) success,
• fading, replacement by other languages.

In the modern world, the bulk of software is written in 10-15 languages, although over the entire time that we know, more than hundreds of programming languages ​​have been created. There are 300 or 400 languages ​​officially registered.

What is a programming language

Language is

• syntax (rules for writing programs),
• semantics (the behavior of elements that are included in the rules of writing and are built into the language),
• runtime (runtime environment).

Syntax determines the form of textual representation of programs, that is, how they should be written, what words are included in the language, how to put commas, spaces, etc.

Syntax using Lisp as an example

One of the simplest programming languages ​​that have a formal grammar is the list language LISP.

Rice. 10. LISP program

LISP is a very old language that produces lists. The grammar of such a language is a grammar of lists, read from top to bottom.

• In Lisp there are expressions: there can be one atom, or a list;
• atom is a number or symbol,
• number – a number, that is, with a plus or minus digit, at least one,
• symbol – these are letters, as many times as you like, you can even many times,
• list – list, expressions in brackets more than once.

A Lisp program is a list of lists. There are no punctuation marks in Lisp, but there are parentheses. There can be such long programs in Lisp, where at the end there are 2-3 sheets, consisting of only closing brackets.

The simplest Lisp interpreter takes only 19 lines! No other language has this luxury.

Semantics

If grammar describes the forms of representation: letters, numbers, brackets, then semantics describes how the program works, what these letters, numbers, brackets mean, how they work, interact with each other, etc.

The options for representing semantics are quite limited.

The semantics could be:

• described in natural, human language. Many languages ​​can only be described this way. In fact, this is the main case when there is simply a document where it is described in Russian or English that such and such a thing works in such and such a way, one team does this, another does such and such things, etc. ;
• specified formally (in specialized languages, for example, for some calculations, the behavior of elements can be described formally);
• defined by the original implementation (rarely used, but this is the “last hope” for a description when the semantics are too complex or not very important);
• described by a set of tests (cases), namely, that this should work this way, and this should work this way.

Semantics is divided into two parts:

• static,
• dynamic.

Static semantics

• gives meaning to lexical constructions;
• determines acceptable values ​​of variables and parameters;
• describes syntactic restrictions, for example, using syntax it will not be possible to describe that you cannot add strings with numbers.

Dynamic or frontal runtime semantics

• determines the general nature of program execution;
• describes how built-in operations and built-in libraries work. This is the main part of the semantics that is needed to understand how the program will live and work after it is written;
• specifies the requirements for the interpreter.

System of data types in programming languages

An important part of semantics is the type system - a set of rules and expressions for methods that are written in the ideology of the language and how they interact with each other.

Typically, a programming language has a system of data types - strings, numbers, lists, etc. There is, for example, the Force language, where all data is just , in other words, there are languages ​​where data types are not built in at all.

If a type system is present, then programming languages ​​can be divided into two independent classes, which are given below.

Data type system:

• typed or untyped language
• static or dynamic typing
• strong or weak typing

If the typing is static, then the types of all expressions that are written in the program are known until the moment of its execution, that is, when functions, classes, variables are described, then conditions are immediately set or explicitly provided so that the type of such a construction is known from the very beginning. started.

If the typing is dynamic, then, on the contrary, the type of objects of the context language is unknown until the moment of execution, that is, the type of a function or anything will be unknown until the very end.

Strong typing means that if an entity has a type and it is known, then this type can be replaced, but the object itself has a fixed type and does not change.

With weak typing, the type of an object can be different depending on the context and what you do with it.

You have to keep track of the language's type system. Due to the incorrectly specified type of just one, not very noticeable symbol at the beginning of the program, the type of the entire expression changes and therefore very strange errors can result.

The next important characteristic of language is

Programming language paradigm

• from Greek - template, example, sample;
• this is a system of ideas and concepts that determine the style of writing programs in this language - the way the language involves writing programs in it (wiki);
• language “favors” one or more paradigms (multi-paradigm).

Main Paradigms

• imperative: a program is a set of sequential instructions that change the internal state of the computer, data, etc. That is, a program is an instruction;
• functional: a program is a set of mathematical functions. The work of the program is calculating the value of functions;
• object-oriented: the subject area is described using objects with properties and methods. A program is a process of interaction between objects;
• logical: a program is a set of statements about the subject area. The work of the program is to establish the truth of statements about this subject area.

Often the same practical problem can be achieved using any of the paradigms listed above.

Another important part of a language to consider when using a language is Runtime - how the language runs.

Runtime - program execution

The program can be executed in different ways:

1. The simplest and most naive way to execute a program is interpretation - reading the source code at the time of launch. This is how lightweight, scripting languages ​​work. The programmer himself also works: when he has written a program, he looks with his own eyes at his own program and figures out how his program will work and what to do;
2. A common way to run programs is to compile them into machine code, a separate step before running them. There is a separate tool - a compiler, where program sources are read, something is done with them, converting them into machine codes that are understandable to the current system. Then this code is executed directly by the hardware;
3. The hybrid method is byte compilation and execution in a virtual machine. The compiler reads the source code and then produces bytecode that is executed in the virtual machine.

The three methods listed are different and are used for different purposes. These techniques can be combined - the interpreter can compile some parts of the program on the fly to make it work faster. Dynamically generated code can be interpreted without compilation.

Representatives of languages

C language

– one of the most popular, one of the most important in terms of the code physically written on it, practically it is “our everything”.

It was created in 1972, the creators are Dennis Ritchie and colleagues. D. Ritchie also created the Linux system and many other useful things.

• imperative,
• compiled,
• manual memory management (using some operations built into the language, you need to allocate memory elements to variables and then free them when they are no longer needed).

By the way, C is still relevant today, used for:

• system programming (for example, the Linux kernel is written in C),
• number-crunching (the so-called number crushers, that is, for large calculations where speed is important),
• programming microcontrollers and embedded systems.

C is a low-level language, we can say that it is Assembler with a human face, because a person can manually convert almost any C construction into Assembler and the results will be quite understandable operations.

C programs are very compact. They are not much larger than if similar programs were written in Assembly. Moreover, development in C is much faster than in Assembly.

Therefore, C is now used for tasks where performance is required, memory management is very important, and the compact size of the program itself is of great importance. If you have a small microcontroller that is built into some device, then the program for it will most likely be written in either Assembly or C.

Rice. 11. Example of a simple C program.

Java

• Created in 1995,
• creators: James Gosling and Sun Microsystems (Gosling worked for this company).
• Object-oriented, imperative (C is imperative, but NOT object-oriented),
• strictly and statically typed,
• byte-compiled with virtual machine,
• no memory access, automatic garbage collection (the latter works well if there is a third or a quarter of free memory).

In the 90s, JAVA gained great popularity as a multi-platform language. Once you have written a virtual machine for a certain platform, say for Windows or Linux or Mac, you can run any JAVA programs on it without recompilation. Therefore, the language was popular in the web era, when there were different platforms (different versions of Windows, different Macs). JAVA programs worked quickly and quite well on different platforms.

Is used for:

• application programming, including web programming,
• embedded systems (if C is used for microcontrollers, then JAVA is used for mobile phones, terminals, etc.),
• highly loaded systems with a large number of users (banking programs, air traffic control systems, etc.).

A distinction must be made between the Java language specifications and the various JVM implementations:

• Sun JDK (from Sun, now Oracle),
• IBM JDK (sold for money),
• OpenJDK (totally free)
• and so on.

Rice. 12. An example of a simple program in JAVA.

As can be seen in Fig. 12, you have to write a lot of letters to perform simple actions. Java is often called the new Cobol because it contains the same negative properties that once made Cobol a bad language.

Nevertheless, JAVA is very popular, in particular, the client part of the operating system is written in it.

Lisp

• He really finishes Lis t P rocessor(LisP);
• created in 1958;
• creators: John McCarthy;
• a pure functional language, despite the rather strange syntax;
• strongly and dynamically typed;
• generally interpretable;
• no memory access, automatic garbage collection, which falls on the interpreter and not on the virtual machine.

Is used for:

• scientific programming and research;
• artificial intelligence – Lisp was created at the very beginning by searching with intelligence. In the late 1950s and early 1960s, there was a strong feeling in scientific circles that artificial intelligence was about to be created. Then it was believed that the key features of artificial intelligence would be the ability to operate with natural language, text, read, speak and do some intelligent things. Lisp was created to process semantic data from text; it allows you to do such things well;
• anything, but, as a rule, it is not used very effectively.

The Lisp language, developed in 1958, has undergone many changes.

It has many implementations and dialects:

• CommonLisp (created in the 1970s) is a classic implementation that is considered the main one;
• Scheme (scheme) is a simplified dialect that throws out some things from CommonLisp and makes it easier to do;
• Clojure is a dialect of Lisp in terms of language, but it runs on top of a JAVA machine, that is, it is compiled into bytecode and executed as if it were a JAVA program.

Rice. 13. LISP program: bubble sort

Python

• Named after the 1970s British show Monty Pynton's Flying Circus (the jokes are old, but funny)
• created in 1991
• creator – Dutchman Guido van Rossum
• multi-paradigm language, object-oriented, imperative, functional
• strongly and dynamically typed
• interpreted, byte-compiled with virtual machine (depending on implementation)

Is used for:

• script programming
• web programming
• scientific programming (there are large, powerful packages for working with modeling, probability, statistics and other areas that combine experience gained in other areas)

Python is a language specification. There are several basic implementations:

• CPython – main (reference)
• Jython - on top of the JVM
• PyPy – Python in Python (“Python in Python” works faster and better than CPython and Jython)

Rice. 14. Python Program: Bubble Sort

Python has an important feature - instead of brackets (round, curly), indentations using spaces are used to highlight code blocks and structural elements, which is quite unusual for all languages. Apart from Python, almost no one has this feature.

Choosing a language for the task

How to choose a language for a task when you know what you need to do, but don’t know in what?

Important advice: use what you know how to program. This is much better than using something you DO NOT know how to program.

Ecosystem

The language you want to take should not be a “bare” language, it should have an ecosystem that includes:

• development tools (user-friendly IDE)
• ready-made libraries and frameworks
• testing tools for running test cases: test frameworks and tools
• packaging and deployment systems so that the written code can be packaged and posted somewhere so that others can easily use it. The C language does not have this feature, but the Ruby and Python languages ​​do.
• community. There is no need to use dead languages, no matter how cool they are. If you have no one to ask, you will remain at a complete dead end. It is believed that some communities are more friendly, others less so. For example, the Ruby community is great, but the Java community is terrible - you don’t even need to ask anything there.

Popularity

It is difficult to find people on a team who write code in a rarely used language, for example Eiffel. On the other hand, a lot of people will flock to a vacancy in the mega-popular JAVA language, in which the entry threshold is low, but it will not be easy to find people who write it really well.

The more popular a language is, the more libraries, communities, frameworks and other things it has that grow on their own from above.

Learning rate

Almost no one knows the language completely. As you work, you will need to learn the language more and more. Some languages ​​are easy to learn, while others are very difficult.

JAVA is a language that is easy to learn and simple in its capabilities, and then everything is built not through the language, but through the tools.

It is impossible to fully learn C++, because there are very complex things with code generation.

Niche languages

Specific languages ​​are better suited for solving certain niche problems.

Example 1: a web application that

• interacts with the database
• internal service in the company
• We need quick development, because the boss really asks for it.

For such a task, Python or Ruby will most likely be suitable. No need to do this in JAVA

Example 2: mobile operator billing system

• thousands of operations per second, a lot of different payments and transfers
• high reliability and fault tolerance
• flexibility in configuration, problem diagnosis

In this case, our choice is Java, C++, Erlang - rich languages ​​with rich tools.

Example 3: on-board computer code for a satellite

• limited resources (only megabytes of memory and very low clock speed)
• hard real time so that the satellite does not lose orientation, break down or explode
• strictly known tasks, no flexibility and no settings
• a large number of calculations

Our choice is C and C-like languages ​​(and even assembler), because there are very few resources and these requirements must be met.

The article is based on the video:

How to choose the right programming language - Ivan Kalinin

The video was filmed in December 2014, however, all information is relevant and has no statute of limitations. Many materials from the perspective of today's realities are of undoubted interest, for example, that scientists back in the late 1950s - early 1960s believed that artificial intelligence was already on the threshold and with its help it would soon be possible to work on a computer with natural, ordinary, human language.

It is very important to know the general history of programming languages ​​and the history of the development of known and unknown languages. In this article you will get acquainted with this, but first let’s remember “What is a programming language?”

Programming language is a system of notation and rules that allows you to write a program for solving a problem in the form of a sequential text in a form convenient for a person.

50s

In the fifties of the twentieth century, with the advent of vacuum tube computers, the rapid development of programming languages ​​began. Programming began with writing programs directly in the form of machine instructions (in codes, as programmers say). Computers, which at that time cost significantly more than the development of any program, required highly efficient code.

To make coding easier, machine-oriented was developed, which made it possible to write machine instructions in symbolic form. Assembly language depended on the instruction system of a particular computer. It was convenient enough for programming small tasks that required maximum execution speed.

However, large projects were difficult to develop in Assembly language. The main problem was that a program written in Assembly was tied to the architecture of a particular computer and could not be transferred to other machines. When the computer was improved, all programs in Assembly had to be rewritten anew.

Almost immediately with the advent of computers, high-level languages ​​were developed, i.e. languages ​​that do not depend on a specific architecture. To execute a program in a high-level language, it must first be translated into machine command language. A special program that performs such translation is called a translator or compiler.

The translated program is then executed directly by the computer. There is also the possibility of translating the program into an intermediate language that does not depend on the architecture of a particular computer, but, nevertheless, is as close as possible to the machine command language.

The intermediate language program is then executed by a special program called an interpreter. It is also possible to compile on the fly, when the executed program fragment is translated from an intermediate language into the machine command language immediately before execution.

In the mid-50s, under the leadership of John Backus, the high-level algorithmic programming language FORTRAN was developed for IBM. Despite the fact that there were already developments in languages ​​that converted arithmetic expressions into machine code, the creation of the FORTRAN language (FORmula TRANslator), which provided the ability to write a calculation algorithm using conditional statements and input/output operators, became the starting point of the era of high-level programming languages.

As an alternative to the FORTRAN language, originally aimed at the IBM architecture, ALGOL (ALGOrithmic Language) was developed under the leadership of Peter Naur in the late 50s. The main goal pursued by the developers of this language was independence from the specific architecture of the computer system.

In addition, the creators of the ALGOL language sought to develop a language convenient for describing algorithms and using a notation system close to that adopted in mathematics. FORTRAN and ALGOL were the first languages ​​focused on computational programming.

60s

In the late 60s, under the leadership of Nayard and Dahl, the Simula-67 language was developed, using the concept of user-defined data types. In fact, it is the first language to use the concept of classes.

70s

In the mid-70s, Wirth proposed the Pascal language, which immediately became widely used. At the same time, at the initiative of the US Department of Defense, work began on creating a high-level language called Ada - in honor of Ada Lovelace, a programmer and daughter of Lord Byron.

The creation of the language began with defining requirements and developing specifications. Four independent groups worked on the project, but they all used Pascal as a basis. In the early 1980s, the first industrial compiler for the Ada language was developed.

C development

The universal programming language was developed in the mid-70s by Denis Ritchie and Ken Thompson. The language became a popular systems programming language and was at one time used to write the kernel of the UNIX operating system.

The C language standard was developed by an ANSI working group in 1982. The International Standard for the C language was adopted in 1990. The C language formed the basis for the development of programming languages ​​and Java.

The C language made it possible to actually get rid of Assembler when creating operating systems. For example, almost all the text of the Unix operating system is written in C and, thus, does not depend on a particular computer.

The main advantage of C is its simplicity and the absence of pseudoscientific solutions. The mechanism for passing parameters to a function (by value only) is described simply and clearly. A programmer creating a C program always clearly understands how this program will be executed.

The concept of a pointer, static and automatic (stack) variables of the C language most closely reflect the structure of any modern computer, therefore C programs are effective and convenient for debugging.

Currently, the vast majority of programs are written in C and C++. The interface of any operating system (the so-called API - Application Program Interface), i.e. a set of system calls intended for application developers is usually a set of functions in the C language.

Along with algorithmic languages, languages ​​intended for processing business information, as well as artificial intelligence languages, developed in parallel. The first includes the COBOL (COmmon Business Oriented Language) language, and the second includes the LISP (LISt Processing) and Prolog languages.

The LISP language, developed in the 60s under the leadership of J. McCarthy, was the first functional list processing language that found wide application in game theory.

90s

In the 90s, with the spread of the Internet, the possibilities of distributed data processing expanded, which also affected the development of programming languages. Languages ​​focused on creating server applications have appeared, such as Perl, Document Description Languages, and XML.

The traditional programming languages ​​C++ and Pascal also underwent changes: a programming language began to mean not only the functionality of the language itself, but also the class libraries provided by the programming environment.

The emphasis was shifted from the specification of the programming languages ​​themselves to the standardization of the mechanisms for interaction of distributed applications. New technologies have appeared - COM and CORBA, which specify the interaction of distributed objects.

Areas of application of programming languages

Currently, programming languages ​​are used in a wide variety of areas of human activity, such as:

• scientific computing (languages ​​C++, FORTRAN, Java);
• system programming (languages ​​C++, Java);
• information processing (languages ​​C++, COBOL, Java);
• artificial intelligence (LISP, Prolog);
• publishing activities (Postscript, TeX);
• remote information processing (Perl, PHP, Java, C++);
• description of documents (HTML, XML).

Based on the history of programming languages, we can say that over time, some languages ​​have developed, acquired new features and remained in demand, while others have lost their relevance and today are, at best, of purely theoretical interest.