The history of programming languages: how Fortran allowed users to communicate with computers on "you"

Fortran marks its 60th anniversary in 2017. During this time, the language was refined several times. Fortran 90, 95, 2003, and 2008 are considered “modern” versions. If initially it was a high-level programming language with a purely structural paradigm, then in later versions tools for supporting OOP and parallel programming appeared. Fortran is currently implemented on most platforms.

Before the Fortran language, developers programmed using machine code and assembler. A high-level language quickly gained popularity, as it was easy to learn and provided the generation of effective executable code. This greatly simplified the life of programmers.

In 1950, when John Beckus was 25 years old, he received a master's degree in mathematics from Columbia University and got a job as a programmer at IBM. Soon, he led the group developing an interpreter called "Fast Encoder" for a computer brand IBM-701. He then worked as part of a team to create a more powerful successor to the 701, the IBM-704.



In 1953, Beckus launched a rationalization initiative. He proposed creating a language and a compiler for it, which were supposed to simplify the programming of the IBM-704 model. The system allowed writing programs in algebraic form, and the compiler had to automatically translate it into machine codes.

With this proposal, John Beckus, as they say, was in the right place, at the right time. Entering the market late, IBM was having difficulty increasing sales of its computers. For this reason, she supported computer science research at Columbia, Harvard, and several other universities. In addition, IBM itself was looking for ways to reduce the cost of programming, and also tried to simplify the work with computers to make them more attractive, "friendly" for users.

The fact is that at that time scientists, engineers and teachers worked with computers. Computing machines were used for scientific calculations. However, these people experienced great difficulties, since they had to use machine codes and assembly language. And this required a fairly deep knowledge of the device and the operation of the computer itself.

Therefore, they would surely agree to learn a high-level language, especially if it resembled the familiar algebraic formulas. These considerations led IBM to develop Fortran.


Ibm-704

The researchers at IBM who created Fortran were unaware of how significant the language would be. When they started work at the beginning of 1954, computer science developed spontaneously, and everyone worked on a hunch. This led to the emergence of professional programmers and computer scientists.

One of the IBM managers decided that good programmers are made from chess players, so he made conversations with possible candidates for programmers during chess games with one of the IBM employees (who, incidentally, was the US chess champion).

Few of the eight people involved in developing Fortran were seriously familiar with computers. They came from universities and airlines, as well as from IBM’s own programming teams.

Even the head of the Fortran development team, John Beckus, had only a few years of computer experience when he set about creating a new programming language.

Before college, Beckus was a mediocre student (“I went to more schools than I can remember”). After serving in the army during World War II, he ended up in New York, where he entered the radio engineering school. “The limit of my aspirations was to make a high-quality sound reproducing device,” Beckus later admitted.

However, the television and radio repair instructor aroused Beckus' interest in mathematics and convinced him to continue his studies at Columbia University. So modestly began one of the most fruitful careers in the history of computer technology.

So, the developers, led by Beckus, are located at IBM headquarters on Madison Avenue in New York.

They identified the basic concepts of the new language, in particular, the assignment operator (for example, N = 100), which set certain values ​​for the variables, introduced indexed variables that told the computer which element from the list of variables was needed (for example, X (3) means the third element of the list, named X), they proposed a very important DO operator, which allowed us to repeat the desired sequence of operators a given number of times.

As Beckus stated, most people believed that Fortran's main contribution was the ability to write programs in the form of algebraic formulas, and not in machine language. But actually it is not. In his opinion, Fortran primarily automated the organization of cycles. The importance of this task in the development of scientific applications is difficult to overestimate. Work on the language went quickly.

However, a completely different matter is compiler development. Beckus understood that dispelling doubts about the possibilities of "automatic" programming, that is, writing programs in high-level languages, is not easy. This will happen when programs obtained with Fortran are as fast and reliable as those written in machine code or in assembly language, he thought.

According to the plan for the development of the compiler, six months were allotted, however, work on it took more than two years.

At the end of 1956 and in 1957, the intensity of work on debugging and debugging the compiler increased sharply. During this period, group members often rented a room in the nearest hotel, where they slept in during the day, working by car at night, in order to have as much continuous machine time as possible. Errors were eliminated one by one, and in April 1957 the compiler was ready for use by the owners of the IBM-704 machine.

"Big embarrassment"

By mistake, which Beckus called "great embarrassment," the compiler was sent to the Westinghouse-Bettis lab in the form of a deck of punch cards and without any instructions; which allowed Herb Bright of the Westinghouse Bettis Laboratory to launch Fortran blindly. The remaining users received a tape system along with a manual for the operator.



One Friday, April 1957, a postman delivered a mysterious parcel to a computer center at the Westinghouse-Bettis Nuclear Laboratory near Pittsburgh. The programmer Herb Bright and two of his colleagues opened a box on which there were no marks, and found there a stack of about 2 thousand punch cards, without a single instruction.

Looking at punch cards, Bright remembered that IBM was just final debugging a high-level language intended for use on IBM-704. Perhaps the postman brought this long-awaited compiler? Bright and his friends decided to download the mysterious cards to the computer and see what happens.

Bright put a test program written in Fortran into a computer reader and pressed the start button. The new compiler issued a message to the printer: "an error was detected on the map number 25 in the operator - a comma is missing."

Programmers, accustomed to messy messages in the form of numerical codes, were amazed at the clarity of this information. The incorrect operator was corrected and the start button was pressed again. The tapes began to spin, and the computer issued a stack of punch cards of the program. When the cards were loaded into the reader, the printer started working and printed 28 pages without stopping. The computer was only slightly mistaken in the output format. “But the numbers were correct! The numbers were correct! ”Later exclaimed Bright.



In fact, at about the same time with Fortran, two more high-level languages ​​appeared - Kobol and Algol. Since the end of the 50s, they have long been leaders in the computer world. Most modern programs are written in languages ​​that are descendants of these three languages.

Distribution and Adaptation

But at first Fortran was taken without much warmth. Programmers, as Beckus recalled, “were very skeptical about all our applications.” However, compared to its predecessors, Fortran was relatively easy to learn and use.

In addition, IBM supplied all 704 Fortran models for free. As a result, by 1958, more than half of all machine instructions on 60 computers of the company were not received manually, but “automatically”, using a new high-level language.

Beckus understood that competing manufacturers would also be developing high-level languages ​​for their computers. However, Fortran quickly became the norm and was adapted for various computer models. The first adaptation was carried out by IBM itself. Five years later, Fortran was used on six different models of IBM computers, as well as on Sperry Rand, Filko, and others.

A small group, which included David Hemmis, quickly adapted Fortran to an IBM-650, smaller than the IBM-704. Hemmis and his colleagues developed the FORTRANSIT system (FOR TRANSIT - for the transition); later, these two words merged into one. Thus, the FORTRANSIT system became the first source translator to work on a computer of several models.


David Hemmis is one of the first computer language developers to drive his 1928 car. Photograph taken in Westhampton, NY, during the 1957 automobile race.

Completion

Nevertheless, work on the new language had to be continued for a long time: it became clear at the beginning of 1957, when the debugging process continued. Beckus and other developers understood that the language needed a more accurate system for diagnosing software errors. In addition, it was necessary to realize the possibility of separate and independent writing of subprograms and program modules. Thus, the language would have one more advantage - code reuse.

Thanks to the efforts of developers, just a year after creating the original, Fortran II appeared. One of the advantages of the new language was that it allowed you to insert assembler code fragments into programs. A later version, Fortran III, was created in 1958. Fortran IV, which further expanded the capabilities of the language, became known in 1962.

The core of the language, its basic operators and expressions, have remained virtually unchanged for many years. But, as Fortran repeatedly adapted to all new machine systems for which it was not intended, differences gradually accumulated. Some opportunities were lost, new ones arose. This inevitably created confusion.

For example, not all compilers interpreted the most important DO statement the same way: some always executed the loop at least once, without checking whether it should be performed at all, others carried out such a check. To restore order in such matters, computer manufacturers and users agreed to standardize the language.

In 1966, the first standard was named Fortran 66. In 1977, accordingly, the Fortran 77 standard was released. In 1991, the Fortran 90 appeared. Fortran 95 was created in 1997.

Fortran in the USSR

In the Soviet Union, Algol-60 fell to the court more. Therefore, Fortran in this country appeared later. However, he gradually came out on top in popularity. Compilers (translators) were developed for most domestic computers - Minsk-32, BESM-4, BESM-6, AS-6, EU computers, SM computers, MVK Elbrus and so on.

In IPM them. At different times, several translators were developed by Keldysh. Two of them - Fortran-Almo and Forshag (Fortran stepper) were written in the Almo language and the code was generated in the same language. This made it possible to install translators on several different types of computers. Both translators implement the Fortran 66 standard.



The foresight also included a dialogue language, which allowed you to create, edit and translate code in an interactive mode. In addition, a complex of graphic programs for Fortran - Grafor was developed, which was actively used on various computers.

*****

Fortran to this day remains popular among scientists. This is the first high-level programming language that has a translator that has received practical application and further development. As stated in an IBM manual released in 1957, “Fortran provides an efficient way to create software for the 704, is easy to learn, and does not require deep computer knowledge.”

Since then, scientists, engineers and students have been able to communicate with a computer without the help of professional assembler programmers.

However, the next generation of programmers began to treat Fortran as a "fossil." Edsger Dijkstra sarcastically noted that teaching students this language should amount to a serious crime.