Fortran programming language. Why physicists still use Fortran

In 2017, the Fortran language turns 60 years old. During this time, the language was refined several times. "Modern" versions are considered Fortran 90, 95, 2003 and 2008. If it was originally a programming language high level with a purely structural paradigm, then in later versions there were tools to support OOP and parallel programming. Today, Fortran has been implemented on most platforms.

Before the advent of Fortran, developers programmed using machine code and assembly language. The high-level language quickly gained popularity because it was easy to learn and generated efficient executable code. This made life much easier for programmers.

In 1950, when John Backus 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 headed a team developing an interpreter called “Fast Encoder” for the IBM-701 computer. He then worked as part of a team to create a more powerful successor to the 701, the IBM-704.

In 1953, Backus came up with a rationalization initiative. He proposed creating a language and a compiler for it, which should simplify programming the IBM-704 model. The system allowed programs to be written in algebraic form, and the compiler was supposed to automatically translate it into machine codes.

With this proposal, John Backus, as they say, was in the right place, in right time. Having entered the market late, IBM had 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 in order to make them more attractive and “friendly” for users.

The fact is that at that time it was mainly scientists, engineers and teachers who worked with computers. Computers 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 structure and operation of the computer itself.

Therefore, they would probably agree to learn a high-level language, especially if it resembled the algebraic formulas they are familiar with. Such considerations prompted IBM to develop Fortran.

IBM-704

The IBM researchers who created Fortran had no idea how great importance will acquire this language. When they started work at the beginning of 1954, computer science was developing spontaneously, and everyone worked on a whim. This led to the emergence of professional programmers and computer scientists.

One of the managers of IBM decided that chess players make good programmers, so he started conversations with possible programmer candidates during chess games with one of the IBM employees (who, by the way, was a US chess champion).
Few of the eight people involved in the development of Fortran had any serious knowledge of computers. They came from universities and airlines, as well as IBM's own programming groups.

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

Before college, Backus 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 City, where he attended radio engineering school. “The limit of my aspirations was to make a high-quality sound-reproducing device,” Beckus later admitted.
However, a television and radio repair teacher sparked Backus's interest in mathematics and convinced him to continue his studies at Columbia University. This was the humble beginning of one of the most rewarding careers in the history of computing.

So, the developers, led by Backus, settled down at the 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 assigned variables certain values, introduced indexable variables that told the computer which element from a list of variables was needed (for example, X(3) means the third element of a list called X), introduced the very important DO operator, which allowed the desired sequence of statements to be repeated given number once.

As Backus stated, most people believed that Fortran's main contribution was its ability to write programs as algebraic formulas rather than in machine language. But actually it is not. In his opinion, Fortran primarily automated the organization of loops. The importance of this task when developing scientific applications is difficult to overestimate. Work on the language went quickly.

However, developing a compiler is a completely different matter. Backus understood that it was not easy to dispel doubts about the possibilities of “automatic” programming, that is, writing programs in high-level languages. This will happen when programs produced using Fortran are as fast and reliable as those written in machine codes or in assembly language, he thought.

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

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

"Great embarrassment"

In a mistake that Backus called “a great embarrassment,” the compiler was sent to the Westinghouse-Bettis laboratory in the form of a deck of punched cards and without any instructions; which allowed Herb Bright of the Westinghouse-Bettis laboratory to run Fortran blindly. Other users received the system on magnetic tape along with an operator's manual.

One Friday in April 1957, a mailman delivered a mysterious package to the computer center of the Westinghouse-Bettis atomic laboratory near Pittsburgh. Programmer Herb Bright and two colleagues opened an unmarked box to find a stack of about 2,000 punched cards, without a single instruction.

Looking at the punch cards, Bright remembered that IBM was in the process of finalizing a high-level language for use on the IBM-704. Maybe the postman brought exactly this long-awaited compiler? Bright and his friends decided to load the mysterious cards into the computer and see what happens.

Bright put it in the computer reader test program, written in Fortran, and pressed the start button. The new compiler sent a message to the printer: “an error was detected in the operator on card No. 25 - a comma was missing.”

Programmers accustomed to confusing messages in the form of numeric 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 spit out a stack of punched program cards. Once the cards were loaded into the reader, the printer started working and printed 28 pages without stopping. The computer only made a slight error in the output format. “But the numbers were right! The numbers were right!” - Bright exclaimed later.

In fact, at about the same time as Fortran, two more high-level languages appeared - Cobol and Algol. Since the late 50s, they for a long time were in the lead in computer world. Majority modern programs written in languages that are descendants of these three languages.

Distribution and adaptation

But at first Fortran was not received with much warmth. The programmers, as Backus 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 models with Fortran free of charge. As a result, by 1958, more than half of all machine commands on the company's 60 computers were obtained not manually, but “automatically,” using a new high-level language.

Backus understood that competing manufacturers would also develop 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 in use on six various models computers from IBM, as well as on computers from Sperry Rand, Philco and others.

A small group, including David Hemmis, a short time adapted Fortran to the IBM-650, a smaller machine than the IBM-704. Khemmis and his colleagues developed the FORTRANSIT system (FOR TRANSIT - for transition); later these two words merged into one. Thus, the FORTRANSIT system became the first translator of the original, working on several computer models.

David Hemmis - one of the original developers computer languages, driving his 1928 car. Photo taken in Westhampton, New York during the 1957 auto race.

Finalization

However, work on the new language had to continue for quite a long time: this became clear at the beginning of 1957, when the debugging process continued. Backus and other developers realized that the language needed more accurate system diagnostics software errors. In addition, it was necessary to implement the possibility of separate and independent writing of subroutines and software modules. Thus, the language would gain another advantage - reuse code.

Thanks to the efforts of the developers, Fortran II appeared just a year after the creation of the original. One of the advantages of the new language was that it allowed fragments of assembler code to be inserted into programs. More 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, has remained virtually unchanged over the years. But as Fortran was repeatedly adapted to new machine systems for which it was not intended, differences gradually accumulated. Some opportunities were lost, new ones arose. This inevitably led to confusion.

For example, not all compilers interpreted the same most important operator DO: some always executed the loop at least once without checking whether it should be executed at all, others did such a check. To bring order to such issues, 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, Fortran 90 appeared. Fortran 95 was created in 1997.

Fortran in the USSR

In the Soviet Union, Algol-60 was more popular. Therefore, Fortran appeared in this country later. However, it gradually came out on top in popularity. Compilers (translators) have been developed for most domestic computers– “Minsk-32”, BESM-4, BESM-6, AS-6, ES EVM, SM EVM, MVK “Elbrus” and so on.

In IPM im. Keldysh in different time Several translators have been developed. Two of them - Fortran-Almo and Forshag (Fortran stepwise) 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.

Foreshag also included a conversational language that allowed code to be created, edited, and translated interactively. In addition, a complex was developed graphics programs for Fortran - Graphor, which was actively used on various computers.

Fortran remains popular among scientists to this day. It is the first high-level programming language to have a translator that has received practical use And further development. As stated in the IBM manual released in 1957, “Fortran provides effective method creating programs for the 704 model, 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 programmers writing in assembly language.

However, the next generation of programmers began to treat Fortran as a “fossil.” Edsger Dijkstra quipped that teaching students this language should be considered a serious crime.

* "PC Magic" 2000 No. 6(28), pp. 49–50.

In 1955, the first high-level algorithmic language was released. FORTRAN(FORmula TRANslator - formula translator). It was used mainly to solve scientific, technical and engineering problems, and was developed by IBM employees under the direction of John Backus. A little later, in 1957, John Backus and his employees installed the first Fortran compiler at IBM (Bestinghouse). Programmers who previously worked exclusively in Assembly were skeptical about the capabilities of a high-level, high-performance language, so the main criterion when developing Fortran standards and creating compilers from this language was the efficiency of the executable code. By the way, the term “compiler” was not yet widely used, although it had already been introduced by Grace Hopper, the only female admiral in the United States, who was also called “the first lady of programming and the grandmother of Cobol.”
Most Fortran statements translated directly into one or two machine instructions, simple syntactic constructs, and active use labels and goto made it possible to get very quick code, and as a result, Fortran programs sometimes ran faster than assembler programs. The internal structure of the translated program itself was also very simple - all code, all subroutines and all data, together with a common block, were located exclusively in static memory, because of which, however, it was impossible to use recursion.
Since Fortran was the first high-level language that met the needs of most users of the time, and was also easy to learn, it spread very quickly.
Due to the widespread use of this language and the emergence of many Fortran programs (mainly of a computational nature), the issue of its standardization has become urgent. At first it was standard Fortran IV 1964, then, as new ideas emerged, it was adopted in 1978 new standard Fortran 77(f77) s a large number more modern and flexible syntactic extensions. Today the most common variant of Fortran is Fortran 90(f90) and Fortran 95. A group of enthusiasts is finishing work on a super version of the F2k language, which will be published this year.
Although new versions of the language sometimes included both unnecessary additions (for example, extensions related to dynamic memory allocation) and useful ones, such as modular organization of the program, working with parts of arrays, etc., today this language cannot be called promising for learning, since its syntax is significantly outdated.
However, those who quite often have to decide various computing tasks, it is not at all necessary to pick up a math textbook every time and “start from scratch.” In 90% similar cases what you are looking for has long been implemented and debugged in Fortran. Therefore, most likely, the life of Fortran is assured for a long time.
There is another, relatively young niche for Fortran - parallel computing, where the strict semantics of the language allows for high-performance programs. Usually the f90 standard is used, slightly expanded with a set of operators to indicate parts of the program suitable for parallelization. Parallel Fortran has its own standard HPF(High Performance Fortran). Nevertheless, Fortran fans, whose motto was the legendary phrase “Why should I learn other languages when I can write everything in Fortran,” felt its obvious unsuitability for large-scale projects due to attachment to the syntax of the 50s, and tried to introduce it fashionable OOP ideas, but object Fortran never emerged as a standard.
Among the freely distributed versions of Fortran, the most famous is f2c, implemented for all UNIX systems and converting the text of a Fortran program into C code. For DOS there is a version bcf77, distributed free of charge. Of the commercial versions, the first to be noted are Microsoft Fortran, which allows you to create dll libraries, and Watcom Fortran, which generates highly efficient code. For tasks requiring high precision computing, a compiler from MicroWay is designed. In general, Fortran compilers of varying quality are available on absolutely all computer platforms.
However, Fortran's main merit lies elsewhere. When the need arose to develop a very major projects, the shortcomings of Fortran, associated primarily with “heavy” debugging, have become unnecessarily burdensome. Therefore, Fortran served as a strong stimulus for the development of the theory of debugging and testing programs. Hundreds of syntactic verifiers for Fortran texts have appeared, catching hidden logical errors. Subsequently, such theoretical areas of programming as equivalent optimizing program transformations, high-level compilation, automatic testing, etc. grew out of this direction. So you can’t forget about Fortran. It probably doesn’t make sense to use it as a toolkit for system integration tasks, but what has been developed the best programmers in 30–40 years, may well speed up the development process. At least, there are now incomparably more software “building blocks” for Fortran than for other programming languages. ■

* * *
John Backus born December 3, 1924 in Philadelphia, Pennsylvania, into a wealthy family, spent his childhood in Wilmington. After graduating from school in 1942, he entered the University of Virginia to study chemistry (at the insistence of his father, a chemist), but after some time he stopped studying and in 1943 he was called up to military service.
Backus began serving in the air defense brigade at Fort Stewart, Georgia, but was subsequently sent to college to study medicine.
For some time he worked enthusiastically at the city hospital, but in 1946 he lost interest in this work, left the army and moved to New York, although he did not know what to do and how to live further.
After some time, Backus entered a radio engineering training school. "I had a very good teacher, and he asked me to calculate the characteristics of some circuits. It was terribly tedious, but extremely interesting."
Backus soon entered Columbia University (New York) to study mathematics, where he received a higher education(1949). Shortly before graduating, he visited a computer center IBM on Madison Avenue. And here luck smiled at him for the second time - in 1950, Backus became a programmer for IBM.
IBM's dominance in the computer industry was first discussed in 1952. It all started with the 701, also known as the Defense Calculator. Immediately after the release of the Model 701, specialists from the Applied Research Division began improving it (1955–1956).

The most serious changes were proposed by John Backus, who later took an active part in the creation of the 704 computer. In particular, thanks to him, the so-called “speed-coding” technology appeared, which made it possible to significantly simplify the writing of programs for the 701. “The possibility of accelerated code generation for machine 701, which was a uniaddress fixed-point computer with no index registers, turned it into a floating-point, random-addressing system with index registers,” Backus recalled. “So users no longer had to struggle with. binary code".
Even then, the first components of the technology for quickly writing programs appeared, which is used today. Actually this system became the predecessor of similar complexes that were released in the 50s and 60s and were subsequently replaced by high-level languages.
And in 1955, Backus “invented” Fortran, the first high-level machine language. Subsequently, recalling this period, Backus will say: “We did not know what to strive for, and did not know how to do it.” Initially, all work was planned to be completed in early 1954, but the development of the language was completed almost two years later.
The first version of the compiler consisted of 25,000 lines of machine code written on magnetic tape. Each IBM 704 was provided with a copy of the program with a 51-page programming manual.
In 1959 Backus developed grammar rules to describe the syntax of high-level languages ( normal form Backus-Naur, abbreviated as BNF).
In 1976, John Backus was awarded the National Medal for his contributions to science, and in 1991 he stopped working in computer science.

Vladimir Buslaev

OCR: fir-vst, 2016

Mid 50's characterized by rapid progress in the field of programming. The role of programming in machine codes began to decrease, and new types of programming languages began to appear, acting as an intermediary between machines and programmers. The time has come for the second and third generations of programming languages

Since the mid-50s. XX century began to create the first high-level programming languages. These languages were Machine independent (not tied to a specific type of computer).

But each language has developed its own compilers - a program that performs the compilation.

Compilation is the translation of a program written in a high-level source language into an equivalent program in a low-level language close to machine code (absolute code, object module, sometimes assembly language)

FORTRAN programming language

The first high-level language was created between 1954 and 1957 by a group of programmers led by John Backus at IBM Corporation and this became the next stage in the development of programming languages. It was the language FORTRAN programming. It was intended for scientific and technical calculations. The name Fortran is short for FORmulaTRANslator (formula translator).

History of the language

At the end of 1953, John Backus proposed to begin developing an effective alternative to assembler for programming on the IBM 704 PC. By mid-1954, the draft specification of the Fortran language was completed. The first manual for Fortran appeared in October 1956, along with the first compiler, shipped in April 1957. The compiler was an optimizing compiler because customers were reluctant to use a high-level programming language that was unable to generate code with performance lower than assembly language.

At the time, the community was skeptical of the new way of programming and did not believe that Fortran would allow faster and more efficient programming. According to John Backus himself, most of his work was aimed at “being lazy.” He really didn't like writing programs for the IBM 701 in assembler.

The language has been widely adopted by scientists for writing computationally intensive programs. Inclusion complex type data has made it particularly suitable for technical applications.

By 1960, there were versions of Fortran for IBM computers 709, 650, 1620, 7090. Its great popularity encouraged competing computer manufacturers to create Fortran compilers for their computers. Thus, by 1963 there were more than 40 compilers for different platforms. This is why Fortran is considered the first widely used programming language.

Fortran in the USSR

Fortran appeared in the USSR later than in the West, since at first Algol was considered a more promising language. Communication between Soviet physicists and their colleagues at CERN played a major role in the introduction of Fortran, where in the 1960s almost all calculations were carried out using Fortran programs.

The first Soviet Fortran compiler was created in 1967 for the Minsk-2 machine, but it did not gain much popularity. Widespread implementation Fortran began after the creation in 1968 of the FORTRAN-DUBNA compiler for the BESM-6 machine. ES computers, which appeared in 1972, already initially had a Fortran translator (“borrowed” from IBM/360 along with other software)

Modern Fortran. Virtues of language

Fortran was widely used mainly for scientific and engineering computing. It is perfect for solving numerical problems, since many libraries have been written over more than 50 years, so the language is used now and is not in danger of being forgotten in the near future. It is still used today, however, not so much because of its successful design, but because large quantity programs written on it, changing and, especially, rewriting which makes no sense.

Probably, if you want to quickly calculate something, then Fortran will be one of the best options. This is precisely why language was invented.

Its structure allows the compiler to optimize calculations very well.

Among scientists, for example, there is a saying that any math problem already has a solution in Fortran, and, indeed, you can find among thousands of Fortran packages a package for matrix multiplication, a package for solving complex integral equations, and many, many others.

Compilers

In 2017, the Fortran language turns 60 years old. 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 support for OOP and parallel programming appeared. Today, Fortran has been implemented on most platforms.

With this proposal, John Backus, as they say, was in the right place at the right time. Having entered the market late, IBM had 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 in order to make them more attractive and “friendly” for users.

Therefore, they would probably agree to learn a high-level language, especially if it resembled the algebraic formulas they are familiar with. Such considerations prompted IBM to develop Fortran.

IBM-704

The IBM researchers who created Fortran had no idea how important this language would become. When they started work at the beginning of 1954, computer science was developing spontaneously, and everyone worked on a whim. This led to the emergence of professional programmers and computer scientists.

One of the managers of IBM decided that chess players made good programmers, so he started conversations with possible candidates for programmers during chess games with one of the IBM employees (who, by the way, was a US chess champion).
Few of the eight people involved in the development of Fortran had any serious knowledge of computers. They came from universities and airlines, as well as IBM's own programming groups.

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

Before college, Backus 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 City, where he attended radio engineering school. “The limit of my aspirations was to make a high-quality sound-reproducing device,” Beckus later admitted.
However, a television and radio repair teacher sparked Backus's interest in mathematics and convinced him to continue his studies at Columbia University. This was the humble beginning of one of the most rewarding careers in the history of computing.

So, the developers, led by Backus, settled down at the 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 variables to specific values, 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, called X), proposed a very important DO operator, which allowed you to repeat the desired sequence of operators a specified number of times.

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

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

"Great embarrassment"

Bright inserted a test program written in Fortran into the computer's reader and pressed the start button. The new compiler sent a message to the printer: “an error was detected in the operator on card No. 25 - a comma was missing.”

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

Distribution and adaptation

Backus understood that competing manufacturers would also develop 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 computers from Sperry Rand, Philco, and others.

A small team, including David Hemmis, quickly adapted Fortran to the IBM-650, a smaller machine than the IBM-704. Khemmis and his colleagues developed the FORTRANSIT system (FOR TRANSIT - for transition); later these two words merged into one. Thus, the FORTRANSIT system became the first translator of the original, working on several computer models.

David Hemmis, an early computer language developer, drives his 1928 car. Photo taken in Westhampton, New York during the 1957 auto race.

Finalization

However, work on the new language had to continue for quite a long time: this became clear at the beginning of 1957, when the debugging process continued. Backus and other developers realized that the language needed a more accurate system for diagnosing software errors. In addition, it was necessary to implement the possibility of separate and independent writing of subroutines and program modules. This would give the language another benefit: code reuse.

Thanks to the efforts of the developers, Fortran II appeared just a year after the creation of the original. One of the advantages of the new language was that it allowed fragments of assembler code to be inserted 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.

For example, not all compilers interpreted the all-important DO statement in the same way: some always executed the loop at least once without checking whether it should be executed at all, while others did so. To bring order to such issues, 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, Fortran 90 appeared. Fortran 95 was created in 1997.

Fortran in the USSR

In the Soviet Union, Algol-60 was more popular. Therefore, Fortran appeared in this country later. However, it gradually came out on top in popularity. Compilers (translators) have been developed for most domestic computers - “Minsk-32”, BESM-4, BESM-6, AS-6, ES Computer, SM Computer, MVK “Elbrus” and so on.

In IPM im. Keldysh, several translators were developed at different times. Two of them - Fortran-Almo and Forshag (Fortran stepwise) 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.

Foreshag also included a conversational language that allowed code to be created, edited, and translated interactively. In addition, a set of graphic programs for Fortran was developed - Graphor, which was actively used on various computers.

Fortran remains popular among scientists to this day. This is the first high-level programming language that has a translator, which has received practical application and further development. As stated in the 1957 IBM manual, "Fortran provides an efficient way to write 704 programs that is easy to learn and does not require extensive computer knowledge."

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

However, the next generation of programmers began to treat Fortran as a “fossil.” Edsger Dijkstra quipped that teaching students this language should be considered a serious crime.

I first heard about Fortran in early childhood from father. He said that in the 70s he had to stand in line for hours at almost the only computer in the university in order to run a primitive code using a punched card. I admit honestly, from then until recently (despite the technical education I received) I was in full confidence that Fortran remained somewhere far out there, in a world where information carriers are strange cardboard boxes with holes, and computers are so expensive, that are perceived as a real attraction.

Imagine my surprise when I learned that Fortran is not only still used somewhere, it is being developed, in demand and is still relevant. If you also believed until this moment that Fortran had long been dead, then here are a few for you: interesting facts why is he still walking?

Survived at least 10 updates

In fact, the Fortran you hear about from teachers at school or university was created between 1954 and 1957. It went down in history as the first fully implemented high-level language, made a small breakthrough in the IT world, but in essence it was not very convenient and functional. IBM began to “finish” it almost immediately; already in 1958, FORTRAN II appeared and, in parallel, FORTRAN III. But it acquired a more or less decent appearance only in the 70s, when fairly portable machines appeared, when a full-fledged IBM FORTRAN IV standard was developed, and FORTRAN 66 appeared with cycles, labels, conditional statements, input/output commands and other primitive capabilities by modern standards.

The latest version appeared in 2010, its name is Fortran 2008 (as you can see, in the course of history, the name stopped being written exclusively in capital letters), distinctive feature which are all kinds of parallel calculations, which have a positive effect both on the speed of data processing and on the dimension of the processed arrays. In addition, the release of Fortran 2015 is planned for 2018. From the announcement it follows that it will improve integration with C and also eliminate current shortcomings.

Among the 30 most popular programming languages

To date, 0.743% of requests in search engines Regarding programming languages, it is devoted specifically to Fortran. To give you an idea of how cool this is, just imagine that languages like Lisp, Scala, Clojure, LabVIEW, Haskell, Rust, and VHDL are ranked lower.

Can work on Android (and more)

Over its long history, compilers for Fortana have been developed by companies such as IBM, Microsoft, Compaq, HP, Oracle, thanks to which today the language is compatible with Windows, Mac OS and Linux. Moreover, convenient application with the compiler can now be taken with you, thanks to the CCTools application for Android. You can run the compiler on your iPhone, but in this case you need to do a little magic.

Competes with MATLAB

So far, this text has not said the main thing, namely the scope of Fortran. So this is a language in demand in science and engineering, used in whole or in part for weather forecasting, oceanography, molecular dynamics, and seismological analysis. In general, this is a real “Data Science” language from the time when the calculator first went on mass sale.

It is worth recognizing that Fortran owes part of its popularity to its heritage. Over the years, with virtually no competition, the language has grown huge base clients, libraries and add-ons. In addition, each next version Fortran inevitably supports the previous ones. Therefore, a situation has arisen where there are no significant factors for scientists and engineers to abandon this alliance.

In fact, Fortran's main competitor today is MATLAB, which is more universal, more functional and convenient. However, MATLAB has strict limitations on the software used, is quite expensive and in most cases is simply unnecessary.

Has a relatively bright future

Of course, we cannot predict what will happen in 10-20 years, and how the IT world will change during this time. However, if you look at possible new competitors for Fortran (such as Go), their main drawback- universalization. That is, the creators of Fortran very quickly outlined target audience in the form of scientists, their opinions and wishes have priority. Therefore, it is difficult to imagine that tomorrow they will abandon their “special order” for the sake of some fashion trend. It is on this basis that we can say that another generation of Fortran is leaving boldly.

And then they'll just release a new version.