Source: obliquity.

com/computer/fortrans/history

FORTRAN was the world's first high-level programming language. It was developed
at IBM by a small team led by John Backus. The earliest version of FORTRAN was
released in 1957 as a programming tool for the IBM 704. Fifty years later, FORTRAN
remains the programming language of choice for large-scale numerical calculations in
science and engineering.

Before FORTRAN

Programs for the earliest computers consisted of sequences of numerical codes. Each
code represented a basic operation such as 'fetch a number from memory location X
and put it in register A' or 'add the number in register A to the number in register B'. This
style of programming was time-consuming and error-prone. Mistakes were difficult to
find.

By the time John Backus joined IBM as a scientific programmer in 1950, it had become
possible to write programs using mnemonics such as ADD in place of the numerical
codes. A special program (which refer to an assembler today) converted the mnemonics
into the corresponding numerical codes. This made programming a little easier, but
even a simple program required dozens of operations, and it was still difficult to track
down mistakes.

Backus reasoned that it should be possible to create a programming language which

allowed a series of calculations to be expressed in something resembling mathematical
notation. A translation program (a compiler, in today's terminology) would then convert it
into the numerical codes which the computer understood. Backus proposed this idea to
his manager in 1953. He was given a budget and encouraged to hire a small team to
test the feasibility of the notion.

Three years later, the team published a manual which described the IBM Mathematical
Formula Translating System, or FORTRAN for short. Soon after, IBM made the first
FORTRAN compiler available to users of the IBM 704.
Backus and his team had created the world'd first high-level programming language.
Scientists and engineers would no longer have to write their programs as numerical
codes or long-winded mnemonics.

Significantly, Backus's team had implemented the first optimizing compiler, which not
only translated FORTRAN programs into theIBM 704's numerical codes, but produced
codes which ran very nearly as fast as anything that could be crafted by hand.
This was very important in ensuring the success of FORTRAN. Early computers were
very slow by today's standards, and they represented an expensive commodity to their
owners. Inefficient programs wasted time and money. Backus and his team understood
this, and they knew that they had to confound their critics who said that a program
compiled from a high-level language could never be as efficient as one that was hand-
crafted directly using numerical codes or mnemonics.

The Early Years

In 1958, IBM released a revised version of the language, named FORTRAN II. It
provided support for procedural programming by introducing statements which allowed
programmers to create subroutines and functions, thereby encouraging the re-use of
code.
FORTRAN's growing popularity led many computer manufacturers to implement
versions of it for their own machines. Each manufacturer added its own customisations,
making it impossible to guarantee that a program written for one type of machine would
compile and run on a different type. IBM responded by removing all machine-dependent
features from its version of the language. The result, released in 1961, was called
FORTRAN IV.

FORTRAN 66

By the early 1960s, there was growing pressure to create a standardised version of
FORTRAN which was not tied to any single type of computer. In 1962, the American
Standards Association (the precursor of ANSI, the American National Standards
Institute) convened a committee to pursue this goal. The result, published in 1966, was
a document which defined the language which became known as FORTRAN 66.
FORTRAN 66 marked a significant milestone in computer science. It was the first
programming language to be defined by a formal standard.

FORTRAN 77

Within only a few years, the shortcomings of FORTRAN 66 began to become apparent,
especially by comparison with other programming languages such as C, Pascal and
Algol. Computer manufacturers again added customisations to the language to try to
address some of these faults.
This forced the ANSI FORTRAN standards committee, known as X3J3, to start work on
a new version of the language in 1969. The resulting standard would take eight years to
reach maturity, but the language it defined, known as FORTRAN 77, represented a
major enhancement. Among the features which it added were a true block IF statement,
a CHARACTER data type, direct-access I/O and thePARAMETER statement to define
constants.
FORTRAN 77 became the became the most widely-used version of the language, and it
is likely that much of the legacy FORTRAN code around the world is written in this
dialect of the language.

FORTRAN 90

FORTRAN 77 faced competition from languages such as C, which allowed

programmers to allocate memory dynamically and to define heterogeneous data
structures. FORTRAN 77 could do neither of these things. The next version of
FORTRAN to emerge from the ANSIX3J3 committee was designed to address these
deficiencies. It was tentatively named FORTRAN 8X but by the late 1980s, the
committee did not appear to be close to releasing the new standard, and there was a
popular joke among computer scientists that 'X' would need to be a hexadecimal digit.
The new version of FORTRAN was finally published as a standard by the International
Standards Organisation in 1991, and it became known informally as FORTRAN 90.

Source: Thoughtco.com/historyoffortran

FORTRAN (or formula translation) was the first high-level programming language
(software) invented by John Backus for IBM in 1954, released commercially in 1957.
Fortran is still used today for programming scientific and mathematical applications.
Fortran began as a digital code interpreter for the IBM 701 and was originally named
Speedcoding. John Backus wanted a programming language that was closer in
appearance to human language, which is the definition of a high-level language, other
high language programs include Ada, Algol, BASIC, COBOL, C, C++, LISP, Pascal, and
Prolog.

Generations of Codes

1. The first generation of codes used to program the functions of a computer was
called machine language or machine code. Machine code is the language a
computer really understands on a machine level, being a sequence of 0s and 1s
that the computer's controls interpret as instructions electrically.
2. The second generation of code was called assembly language. Assembly
language turns the sequences of 0s and 1s into human words like "add".
Assembly language is always translated back into machine code by programs
called assemblers.
1. The third generation of code was called high-level language or HLL, which has
human sounding words and syntax (like words in a sentence). In order for the
 computer to understand any HLL, a compiler translates the high-level language
into either assembly language or machine code. All programming languages
need to be eventually translated into machine code for a computer to use the
instructions they contain.

John Backus and IBM

"I really didn't know what the hell I wanted to do with my life... I said no, I couldn't. I
looked sloppy and disheveled. But she insisted and so I did. I took a test and did
OK." John Backus on his experience interviewing for IBM.

John Backus headed the IBM team of researchers at the Watson Scientific Laboratory
that invented Fortran. On the IBM team were the notable names of scientists like
Sheldon F. Best, Harlan Herrick (who ran the first successful Fortran program), Peter
Sheridan, Roy Nutt, Robert Nelson, Irving Ziller, Richard Goldberg, Lois Haibt, and
David Sayre.

The IBM team didn't invent HLL or the idea of compiling programming language into
machine code, but Fortran was the first successful HLL and the Fortran I compiler holds
the record for translating code for over 20 years. The first computer to run the first
compiler was the IBM 704, which John Backus helped design.

Fortran Today

Fortran is now over forty years old and remains the top language in scientific and
industrial programming—of course, it has constantly been updated.
The invention of Fortran began a $24 million dollar computer software industry and
began the development of other high-level programming languages.
Fortran has been used for programming video games, air traffic control systems, payroll
calculations, numerous scientific and military applications, and parallel computer
research.
John Backus won the 1993 National Academy of Engineering's Charles Stark Draper
Prize, the highest national prize awarded in engineering, for the invention of Fortran

The creation of FORTRAN, which debuted in 1957, marked a significant stage in the
development of computer-programming languages. Previous programming was written
in machine (first-generation) language or assembly (second-generation) language,
which required the programmer to write instructions in binary or hexadecimal arithmetic.
Frustration with the arduous nature of such programming led Backus to search for a
simpler, more accessible way to communicate with computers. During the three-year
development stage, Backus led an eclectic team of 10 International Business Machines
(IBM) employees to create a language that combined a form of English shorthand with
algebraic equations.
FORTRAN enabled the rapid writing of computer programs that ran nearly as efficiently
as programs that had been laboriously hand coded in machine language. As computers
were rare and extremely expensive, inefficient programs were a greater financial
problem than the lengthy and painstaking development of machine-language programs.
With the creation of an efficient higher-level (or natural) language, also known as a
third-generation language, computer programming moved beyond a small coterie to
include engineers and scientists, who were instrumental in expanding the use of
computers.

By allowing the creation of natural-language programs that ran as efficiently as hand-

coded ones, FORTRAN became the programming language of choice in the late 1950s.
It was updated a number of times in the 1950s and 1960s in order to remain competitive
with more contemporary programming languages. FORTRAN 77 was released in 1978,
followed by FORTRAN 90 in 1991 and further updates in 1996 and 2004. However,
fourth- and fifth-generation languages largely supplanted FORTRAN outside academic
circles beginning in the 1970s.

Source: Wikipedia

PASCAL PROGRAMMING LANGUAGE

Pascal is an imperative and procedural programming language, which Niklaus
Wirth designed in 1968–69 and published in 1970, as a small, efficient language
intended to encourage good programming practices using structured
programming and data structuring. It is named in honor of the French mathematician,
philosopher and physicist Blaise Pascal.

Pascal was developed on the pattern of the ALGOL 60 language. Wirth had already
developed several improvements to this language as part of the ALGOL X proposals,
but these were not accepted and Pascal was developed separately and released in
1970. A derivative known as Object Pascal designed for object-oriented
programming was developed in 1985; this was used by Apple Computer and Borland in
the late 1980s and later developed into Delphi on the Microsoft Windows platform.
Extensions to the Pascal concepts led to the languages Modula-2 and Oberon.
Source: whoishostingthis.com
ALGOL PROGRAMMING LANGUAGE
Brief History of ALGOL
ALGOL was originally invented in the late 1950s, by a joint committee of American
and European computer scientists, meeting in Zurich. Their work was released as
the language now known as ALGOL 58.
A second release by the group, known as ALGOL 60, became the standard version
of the language is common use.
This version, described in the now-famous ALGOL 60 Report, had a profound
impact on the field of programming language design. ALGOL 68, the last “official”
version of the language was not well received by the ALGOL community.
ALGOL never really caught on in business programming, aside from some
mathematical analysis applications used by the financial industry. It was, however,
extensively used in academic computer science and math, and was the standard
language for algorithmic description well into the 1980s and 90s.

ALGOL’s Influence on Other Languages

ALGOL’s syntax and structure directly influenced a number of other languages,
which have come to be known as “Algol-like” languages.
These languages include Simula, C, Pascal, and Ada. Some of these connections
are fairly direct: Pascal, for example, was developed by Niklaus Wirth, who had
previously built an ALGOL derivative called ALGOL W.
The most famous member of this group is C, which spawned its own family of
derivatives and descendants: C++, C#, Objective-C, and D — to name just a few.
The syntax of PHP is also based on C, which means that the most used server-side
language on the internet traces its lineage back to ALGOL.
Even more profoundly, ALGOL influenced the way programming languages are
conceived of and described.
Computer scientist John Backus proposed a grammar description for ALGOL (PDF),
which was used in the ALGOL 60 Report, edited by Peter Naur. This description
language became known as Backus-Naur Form (BNF). BNF, and EBNF
(“extended”), is now the standard way of describing the grammar of a formal
language.

ALGOL Resources
ALGOL is an old, mostly obsolete language, and so it can be very hard to
find resources and reliable information on it. Lucky for you, you don’t have to. We
have scoured the internet to bring you the most important resources for learning
about ALGOL
Source: Britannica
ALGOL, computer programming language designed by an international committee of
the Association of Computing Machinery (ACM), led by Alan J. Perlis of Carnegie
Mellon University, during 1958–60 for publishing algorithms, as well as for doing
computations. Like LISP, ALGOL had recursive subprograms—procedures that
could invoke themselves to solve a problem by reducing it to a smaller problem of the
same kind. ALGOL introduced block structure, in which a program is composed of
blocks that might contain both data and instructions and have the same structure as an
entire program. Block structure became a powerful tool for building large programs out
of small components.

computer programming language: ALGOL

ALGOL (algorithmic language) was designed by a a joint committee of American and
European computer scientists. ALGOL contributed a notation for describing the
structure of a programming language, Backus–Naur Form, which in some variation
became the standard tool for stating the syntax (grammar) of programming languages.
ALGOL was widely used in Europe, and for many years it remained the language in
which computer algorithms were published. Many important languages, such as Pascal,
are its descendants.

Relationship between fortran and other programming language

Fortran (or FORTRAN until the beginning of 90's) this is a language developed in the
50's, the word came from "Formula Translator".

Fortran is used to develop scientific and numerical analysis applications. There are
several versions developed after the initial set, some are most interesting like
FORTRAN II, FORTRAN IV, FORTRAN 77, Fortran 90, Fortran 95 y Fortran 2003. The
last version include the object oriented programming..

COBOL the name come from Common Business -Oriented Language, it was created in
1960 with the objective to cover any computer, because in that time there are several
kind of machines with non compatibles.
This language must be oriented to business or manage information system.

PASCAL Developed by Niklaus Wirth at the end of 60's, The objective of this language
is make easy the learning process of programming, but actually this is used in several
environments.
The language is oriented to structured programs.
C this is a language created in 1972 by Ken Thompson y Dennis M. Ritchie in Bell
laboratories, as an evolution of B language B, and B came from BCPL.
C is a language oriented to create operative Systems (Unix is made with C) and also is
used to create another kind of applications.
C has several functions to access several devices into the computer (low level
functions).

Differences (the purpose of the language):

FORTRAN = Used for scientific purposes, easy to program the scientific formulas and to
do numerical analisys.
PASCAL = Used to teach computer programming and the structured logic.
COBOL = Designed to manage large amount of data and reports, for business
purposes.
C = Developed to create operative Systems.

Similarities:
All of them are high level languages used to process data.
All of them have english commands
Actually all are evolved to new versions and by the rule all of them are using object
oriented prog