History of programming languages: Algol - a victim of a conflict of interest

The impact of Algol on the IT industry

The name of the language Algol (ALGOrithmic Language), the first version of which appeared in 1958, underlines the fact that it is intended for writing algorithms. Thanks to its clear logical structure, Algol has become a standard means of recording algorithms in the scientific and technical literature. However, he could not fully compete with the Fortran language, and it was difficult to compare it with COBOL due to the lack of some important features of Algol - the same word processing, for example, or input / output formatting.
')
The “births” of Algol were very hard. For some of its creators, frankly, in agony. Scientists and industry experts could not come to a common opinion on many issues.

As a result, the new language aroused interest rather than attracted consumers. Grace Hopper described it as follows: "Looks like a great poem: simple and clear from the point of view of mathematics, but by no means practical."

Prehistory

In the mid-50s, the role of programming in machine codes began to decrease. Higher level languages ​​appeared - Fortran, Algol, COBOL and so on.

The first of these and one of the most common was Fortran (FORmula TRANslator - formula translator), developed by a group of IBM programmers in 1954 (the first version). This language was focused on scientific and technical calculations of a mathematical nature.


Grace Hopper is an American scientist and Rear Admiral of the US Navy. Harvard Computer Programmer Mark I.

In 1954, a group led by Grace Hopper developed a system that includes a programming language and a compiler, which was later called Math-Matic. After the successful completion of the creation of Math-Matic, Hopper and her group began to develop a new language and compiler that would allow users to program in a language close to ordinary English. In 1958, the Flow-Matic compiler appeared. The Flow-Matic compiler was the first commercial data processing language.

Developments in this direction led to the creation of the COBOL (Common Business Oriented Language) language. It was created in 1960. In this language, mathematical tools were less developed, but text-processing tools and the organization of data output in the form of a required document were well developed. He was conceived as the main language for mass data processing in the areas of management and business.

Best the enemy of the good

In the 50s of the twentieth century, the entire scientific world waited for the solution of the problem of determining a single language for scientific programming. The first to offer their version of the United States. In 1957, Fortran began to actively spread. But the European community feared IBM's hegemony (Fortran was created there) and other aggressive American firms. Therefore, they decided that in the European market a new “star” is bound to rise.

In 1958 in Zurich, on the basis of the Federal Technical University, a special committee was established. On May 27, the first meeting was held, which brought together eight of the most respected authorities in the field of computers: four from Europe and four from the United States. The meeting was attended by Fortran creator John Backus and Joseph Wagsten, who later became chairman of the short-term COBOL committee.


Federal Technical University. Zurich

The conference under the motto “The best is the enemy of the good” in fact did not correspond to this statement. From this work progressed slowly. Americans insisted on a language that would be close to those already used on computers. Europeans were interested not so much in computers as in the power of the language in solving complex mathematical problems. On the second day, the discussion almost reached a dead end because of a small, but provoking point of emotion - a decimal point.

One of the Europeans, striking his fist on the table, exclaimed: “No! I will never use a dot in decimal fractions! ”But the Americans scornfully reacted to the European habit of using decimal fractions. Then Joseph Wagsthen assumed the peacemaking role and tried to calm the "decimal storm."

The final solution proposed by Wagsten provided the new language with one of its most remarkable properties. He proposed a three-level model of language: the level of descriptions, publications and implementation.

Minor issues, such as the choice between a point and a comma, or the alphabet used, were moved to the second or third level, which made it possible to quickly resolve fundamental issues. At the level of publications, agreed later, the use of national keywords and data presentation standards (including the decimal point) was allowed; the level of implementation defined the language perfectly strictly - according to it, the translators had to be built.

Further discussions went exclusively at the first level, which allowed us to move on and not get stuck on minor details.

Semifinished

The language created at the conference in Zurich inherited much from Fortran, but in Algol the basic concepts were assembled into a more logical, one might even say, elegant structure. But due to the lack of time and the need for compromise, many missteps were made. One of them was the lack of data entry and output procedures. The meeting participants deliberately did not address this area, where much depends on the type of computer, believing that the developer of the language compiler should write the input and output procedures.

However, the unanimity of the committee was not absolute: some delegates left the conference, believing that the work was done in the roughest approximation, while the other part believed that what had been done was enough for Algol to become a “star” and a new international standard.



One such optimist was John Backus. In February 1959, he convinced the influential organization SHARE (which included users of IBM computers) to rely on a new programming language. After that, the organization urged IBM to implement Algol.

In words, the company went to meet its customers, but in fact there was almost no work in this direction. At that time, IBM was the world leader in the computer market and was actively implementing Fortran, which is quite expected. The members of SHARE, in fact, did not have a clear position either. When their enthusiasm faded away, as if nothing had happened, they continued to support Fortran.

And Backus, despite the failure, continued to actively promote Algol.

Returning to Zurich, he became interested in grammar, that is, the correct arrangement of words and characters in the language. Backus developed a rigorous and accurate system for defining each language structure in a logical way. For example, when defining the element “digit”, he wrote: “<figure>: = 0 | 1 | 2 | ... | 9 |”.

Soon, programmers began to call this approach to the description of syntax the normal Backus form, or BNF. (The subsequent refinement of this work by the Danish astronomer Peter Naur led to the fact that this approach was often called the Backus-Naur form , (the reduction remained the same - BNF). BNF had a significant impact on the development of programming languages, in particular, it was taken second stage of the development of Algol.

Meanwhile, the Algol-58 did not become successful: serious improvement was required.

Algol-60

In January 1960, 13 representatives from Europe and the USA, including 7 people from the last Zurich group, met in Paris to “patch the holes” that remained in the first version. One of the new arrivals was Naur, who proposed a variant of the modified language Algol, recorded using the BNF.


Syntax Diagrams and Parsing Tree

After eight days of difficult negotiations, the conference participants left Paris in high spirits, believing that agreement had been reached and even the most ardent critics of Algol should no longer be silent.


With a rare consensus, the Algol-60 design committee “votes” for this group photograph taken at a conference in Paris in 1960. Among the participants are American computer specialist John Backus (closest to the camera on the right) and Danish astronomer Peter Naur (fourth from left), after whom the system for describing programming languages ​​was called the Backus-Naur form. (The photo was taken by John McCarthy, the creator of the LISP language)

But as soon as the American participants in the conference got off the plane, a harsh criticism from Algol-60 struck. In addition, a small group of conference participants pointed out the ambiguities remaining in the language, and began to “promote” them. Other critics have stressed that the language I / O is not included in the language.

In America, the Algol-60 met coldly. Moreover, it turned out that it is very difficult for him to write a compiler: even the most advanced computers of that time could not perceive a set of 116 letters that were found in the description language.

In Europe, they reasoned differently: the new language made it possible to exchange interesting and complex ideas, regardless of borders and language barriers. More importantly, he allowed the European computer industry to become independent of American technology.

Algol 68

In 1962, under the auspices of the International Federation for Information Processing (International Federation for Information Processing, IFIP), a new committee was created, whose task was to further improve Algol. The new committee included many world-renowned scientists, in particular, Edsger Dijkstra , Niklaus Wirth and Tony Hoar.

One of the drawbacks of the previous version was the lack of I / O. The neglect at this point was explained by the academic orientation of the language: for scientists, the algorithm itself is of primary interest, and in what form the output will be presented is a secondary matter. For industrial needs, this approach was not suitable.

The second serious drawback was the low speed. Therefore, an important task was to increase the efficiency of work at the stage of program implementation.

For some reason, the head of the language development group was A. Van Wiingaarden, director of the Amsterdam Mathematical Center. Being a pure mathematician, he, using his authority, made decisions that programmer practitioners did not agree with, which had a negative effect on the resulting language.

Unfortunately, the authoritarian style of leadership van Waingaardena often led to quarrels in the team and even caused Hoare and Wirth to leave the team. How hard this loss was for the team can be judged by the following fact: Wirth's proposals, which were not accepted by the committee, formed the basis of the Pascal language.

In Algol 68 several interesting ideas were implemented (for example, language extension mechanisms, as well as tools for parallel computing), but it received limited application.



In Russia there were enthusiasts who actively used it in their work, and the language based on Algol 68 was once the basis for programming the domestic computer "Elbrus".

Language features

As in most other programming languages, the Algol program consists of a main program and a set of subroutines.

begin procedure SUM(V,N); valueN; realarray V; integer N; begin integer I; real TEMP; TEMP:=0; for I:=1 step1 until N do TEMP:=TEMP+V[I]; SUM:=TEMP end; integer K; START: inreal(1,K); if K>0 then begin realarray A[1:K]; inarray(1,A); outreal(2,SUM(A,K)); gotoSTART end end 

The data structures created inside the block are local within it and are destroyed when they exit the block. In this way, you can control the lifetime of the data and the scope of their identifiers. Dynamic memory allocation for variables in a block allows recursion to be used effectively.

Blocks can form nested structures, that is, a block can be nested inside a block, another block can be embedded in it, and so on. An important feature of the language is also the fact that the block is a kind of operator - a composite operator and can be used wherever a normal operator is allowed.

In Algol, the logical, integer, and real types are implemented, and from data structures it is only a homogeneous array. True, arrays are dynamic, which allows you to effectively manage the allocation of memory. Unfortunately, the types and data structures in the language are not too diverse. Perhaps this determined the fate of the language, which was used primarily for scientific computing.

The features of the language can also include mechanisms for passing parameters to subroutines. There are two of them: a well-known program by value and a rather exotic program by name.
The expression passed to the procedure is evaluated each time - as if instead of the formal parameters, their values ​​were calculated, which were calculated in the context of the calling program. In essence, this is a cross between a macro substitution and a subprogram call.

 Begin procedure p (a,b); name a, b; integer a, b; begin for a:=1 step1 until 10 do b := 0 end p; integer i; integer array s [1:10]; p (i, s[i]) end 

When the p procedure is performed at each step of the loop, i is substituted for a, and s [i] is substituted for b, and this procedure simply resets the s array. There are a lot of problems with this method of parameter transfer, so the transfer of parameters by name remains the prerogative of Algol. But this method of passing parameters had an impact on the further development of programming languages.

Role in history

Just as the US Department of Defense at one time actively supported the COBOL language, the independent research council of Germany and other government organizations in Western European countries supported Algol.

Because of this, the language has spread from Britain to the Soviet Union. Most compilers were successful, and Algol was soon recognized by the international language of European programmers.

Algol did not become a universal international standard, as some had hoped, since such a status would seriously hurt American interests. He scored a little popularity in the United States, but remained in the shadow of Fortran forever.

However, many languages ​​that emerged later were based (at least partially) on Algol, and its contribution to their development is associated with several basic ideas.

One of the most important is the block structure, which allows dividing programs into closed units that are developed independently. Another idea is recursion. The third idea is the BNF, a formal definition of syntax.

These and other fundamental ideas were inherited by the developers of other languages.