Download History of Early High-Level Programming: FORTRAN, LISP, ALGOL, BASIC & More and more Exercises Programming Languages in PDF only on Docsity!
FORTAN
The First High Level Language - FORTRAN I – John Backus 1957
FORTRAN stands FORmula TRANslating system. It was the first implemented version of FORTRAN as FORTRAN 0 (1954) was never implemented. It was the first compiled high-level language designed for the new IBM 704, which had index registers and floating point hardware. At that time computers were small and unreliable, applications were scientific, and no programming methodology or tools were available. Machine efficiency was most important and no need was felt for dynamic storage. So the language needed good array handling and counting loops. No string handling or decimal arithmetic was supported. Names could have up to six characters. It had support for formatted I/O and user-defined subprograms. There was no data typing statements and no separate compilation. The compiler was released in April 1957, after 18 man/years of effort. Unfortunately, programs larger than 400 lines rarely compiled correctly, mainly due to poor reliability of the 704 but code was very fast. Within one year, 50% of the code written for 704 was being developed in FORTRAN.
All statements of FORTRAN I were based on 704‟s instruction set. It included 3 way branch and computed if in the form of If (EXPRESSION) L1, L2, L3. It also had posttest counting loop as shown below: DO L1 I = N, M
Fortran II (1958) and IV (1960)
Fortran II came after one year in 1958. It added independent compilation and had some bug fixes.
Fortran IV was released in 1960 and became the most popular language of its time. It had support for explicit type declarations and logical IF statement. Subprograms could also be passed as parameters. ANSI standard of FORTRAN IV was release in 1966 and remained mostly unchanged for the next 10 years.
FORTRAN 77 and 90
FORTRAN 77, released in 1977, was the next major release of FORTRAN after FORTRAN IV. It added support for structured Programming, character string handling, logical loop control statement, and IF-THEN-ELSE statement.
FORTRAN 90, released in 1990, added modules, dynamic arrays, pointers, recursion – stack frames, case statement, and parameter type checking. However, because of the backward compatibility constraints, it could never gained the same popularity as its predecessors.
Functional Programming – LISP – McCarthy 1959
LISP stands for LISt Processing language. It was designed by John McCarthy in 1959 as part of AI research at MIT to deal with problems of linguistic, psychology, and mathematics. They needed a language to process data in dynamically growing lists (rather
than arrays) and handle symbolic computation (rather than numeric). LISP has only two data types: atoms and lists and syntax is based on lambda calculus. It pioneered functional programming where there is no need for assignment and control flow is achieved via recursion and conditional expressions. It is still the dominant language for AI. COMMON LISP and Scheme are contemporary dialects of LISP and ML, Miranda, and Haskell are related languages.
ALGOL
ALGOL 58 – 1958 – Search for a “Universal Language”
ALGOL stands for ALGOrithmic Language. It was designed in 1958. At that time FORTRAN had (barely) arrived for IBM 70x and was owned by IBM. Many other languages were being developed, all for specific machines. There was no portable language as all were machine-dependent. Also, there was no universal language for communicating algorithms.
ALGOL was thus designed to be a language that was close to mathematical notation, good for describing algorithms, and was machine independent. That is, it was an algorithmic language for use on all kinds of computers.
Salient features of the language are: Concept of type was formalized Names could have any length Arrays could have any number of subscripts Lower bound of an array could be defined Parameters were separated by mode (in & out) Subscripts were placed in brackets Compound statements were introduced (begin ... end) Semicolon as a statement separator was used Assignment operator was := if had an else-if clause
It was actually not meant to be implemented, but variations of it were (MAD, JOVIAL) implemented. Although IBM was initially enthusiastic but vested interest in FORTRAN resulted in taking back all support by mid-1959.
Algol 60 - 1960
ALGOL 60 was a modified version of ALGOL 58. It added new features to the language. These included block structure (local scope), two parameter passing methods – value and name, subprogram recursion, and stack-dynamic arrays – run time size definition and space allocation. It did not have built-in I/O facility.
It was quite successful as it was the standard way to publish algorithms for over 20 years. All subsequent imperative languages are based on it. It was the first machine-independent language and the first language whose syntax was formally defined in BNF. It also impacted the hardware design.
By 1963 scientific users began to need more elaborate i/o, like COBOL had and business users began to need fl. pt. and arrays (MIS). It looked like many shops would begin to need two kinds of computers, languages, and support staff. This proposition was obviously too costly and the obvious solution was to build a new computer to do both kinds of applications and design a new language to do both kinds of applications. Hence PL/1 came into being.
PL/I was the first language to introduce unit-level concurrency, exception handling, pointer data type, and array cross sections.
The language was not a huge success because many new features were poorly designed and it was too large and too complex.
Early Dynamic Languages - Characterized by dynamic typing and dynamic storage allocation
APL (A Programming Language) 1962
It was designed as a hardware description language (at IBM by Ken Iverson). It was highly expressive (many operators, for both scalars and arrays of various dimensions) but programs are very difficult to read - commonly known as “write-only” language.
SNOBOL (1964)
It was designed as a string manipulation language (at Bell Labs by Farber, Griswold, and Polensky). It had powerful operators for string pattern matching but suffered from poot readability and maintainability.
Simula 67 – 1967 – The first Object-oriented langauge
It was designed in Norway by Nygaard and Dahl, primarily for system simulation. It was based on ALGOL 60 and SIMULA I. Its primary contributions include the concept of a class which was the basis for data abstraction. Classes are structures that include both local data and functionality.
Pascal – 1971 – Simplicity by Design
Pascal was designed by Niklaus Wirth, who quit the ALGOL 68 committee because he didn't like the direction of that work. It was designed for teaching structured programming. It was small and simple with nothing really new. Because of its simplicity and size it was, for almost two decades, the most widely used language for teaching programming in colleges.
C – 1972 – High-level system programming language
C was designed for systems programming at Bell Labs by Dennis Richie. It evolved primarily from B, but was also influenced by ALGOL 68. It had powerful set of operators, but poor type checking. It initially spread through UNIX but became very popular in the academic circles because of its easy portability. Many modern programming languages including C++, Java, and C# are direct descendents of C.
Prolog – 1972 – Logic Programming
It was developed at the University of Aix-Marseille, by Comerauer and Roussel, with some help from Kowalski at the University of Edinburgh. It is based on formal logic. It is a non-procedural declarative programming language with built-in backtracking mechanism. It has support for associative memory and pattern directed procedure invocation. After LISP, it is the second most widely used language in AI community, especially in Europe.
Ada – 1983 – History‟s largest design effort
It involved a huge design effort, involving hundreds of people, much money, and about eight years. It introduced Packages - support for data abstraction, elaborate exception handling, generic program units, and concurrency through the tasking model.
It was the outcome of a competitive design effort. It included all that was then known about software engineering and language design. Because of its size and complexity, first compilers were very difficult and the first really usable compiler came nearly five years after the language design was completed
Smalltalk - 1972-1980 – The Purest Object-Oriented Langauge
It was developed at Xerox PARC, initially by Alan Kay and then later by Adele Goldberg. It is the first full implementation of an object-oriented language (data abstraction, inheritance, and dynamic type binding) and the purest object-oriented language yet! It pioneered the graphical user interface everyone now uses.
C++ - 1985
It was developed at Bell Labs by Stroustrup. It evolved from C and SIMULA 67. Facilities for object-oriented programming, taken partially from SIMULA 67, were added to C. It also has exception handling. It is a large and complex language, in part because it supports both procedural and OO programming. Rapidly grew in popularity, along with OOP and ANSI standard was approved in November, 1997.
Java - 1995
Java was developed at Sun in the early 1990s and is based on C++. It is significantly simplified as compared to C++ and supports only OOP. It eliminated multiple inheritance, pointers, structs, enum types, operator overloading, and goto statement and added support for applets and a form of concurrency.
C# - 2002
application to parsing and compiler theory as well as theory of operational and mathematical semantics were defined. There was a lot of emphasis on program correctness and verification.
- 1970‟s – Effective software technology
Decreasing hardware cost and increasing software cost resulted in more complex software requiring support for software engineering in the programming languages. It also required development of tools and methodologies for controlling the complexities, cost and reliability of large programs Therefore, languages designed in this period had software engineering support in the form of structured design in the form of structured programming, modular design, and verification. It saw a transition from pure research to practical management of the environment. Verifiable languages such as Pascal and Modula were developed as a result of this effort.
- 1980‟s – Support for SE continued
- 1990‟s and 2000‟s
- Support for OOP and Internet
- 2010‟s – Aspect-Oriented Programming
Language Design Perspectives
Programming Language design is not a simple task. A designer has to consider the need for many different stake holders and balance their requirements. For example, software developers ask for more features and theoreticians ask for features with clean semantics. On the other hand developers of mission-critical software want features that are easier to verify formally. Compiler writers want features that are orthogonal, so that their implementation is modular. These goals are often in conflict and hence it is difficult to satisfy all of them.
From a language definition perspective, once again different users have different needs. Programmers need tutorials, reference manuals, and programming guides (idioms). Implementers demand precise operational semantics and verifiers require rigorous axiomatic or natural semantics. Language designers and language advocates want all of the above. This means that a language needs to be defined at different levels of detail and precision but none of them can be sloppy!
