Evolution of Major Programming Languages

Chapter 2: Evolution of the Major Programming Languages

Topics Covered

• Minimal Hardware Programming: Pseudocodes
• The IBM 704 and Fortran
• Functional Programming: LISP
• The First Step Toward Sophistication: ALGOL 60
• Computerizing Business Records: COBOL
• The Beginnings of Timesharing: BASIC
• Everything for Everybody: PL/I
• Two Early Dynamic Languages: APL and SNOBOL
• The Beginnings of Data Abstraction: SIMULA67
• Orthogonal Design: ALGOL 68
• Some Early Descendants of the ALGOLs
• Programming Based on Logic: Prolog
• History's Largest Design Effort: Ada
• Object-Oriented Programming: Smalltalk
• Combining Imperative and Object-Oriented Features: C++
• An Imperative-Based Object-Oriented Language: Java
• Scripting Languages
• The Flagship .NET Language: C#
• Markup/Programming Hybrid Languages

Genealogy of Common Languages

• A historical timeline showing the evolution and relationships between various programming languages, starting from FLOW-MATIC and Fortran I in the late 1950s and extending to languages like C#, Java, and Ruby in the early 2000s.

Minimal Hardware Programming

• Problems with Machine Code:
  • Poor readability
  • Poor modifiability
  • Tedious expression coding
  • Machine deficiencies: no indexing or floating-point support
• Early machines were difficult to program due to the lack of supporting software.
• Programming was done in machine code, which was tedious and error-prone.

Pseudocodes: Short Code

• Developed by John Mauchly in 1949 for BINAC computers.
• Expressions coded using byte-pair values.
• A word had 72 bits, grouped as 12 six-bit bytes.
• Many equations could be coded within a word.
• Example: a = (b + c) / b * c was coded as:
  • X3 = ( X1 + Y1 ) / X1 * Y1 (substituting variables)
  • X3 03 09 X1 07 Y1 02 04 X1 Y1 (substituting operators and parentheses)
  • 0000X30309X107Y10204X1Y1 (a word, 12 bytes/72 bits)

Pseudocodes: Speedcoding

• Developed by Backus in 1954 for IBM 701.
• Used pseudo-ops for arithmetic and math functions, including floating-point operations.
• Supported conditional and unconditional branching.
• Included auto-increment registers for array access.
• Slow execution speed.
• Only 700 words left for the user program.

IBM 704 and Fortran

• Fortran 0: 1954 - not implemented.
• Fortran I: 1957
• Designed for the new IBM 704, which had index registers and floating-point hardware.
• Led to the idea of compiled programming languages, as interpretation was too costly, especially for floating-point operations.
• Development Environment:
  • Computers were small and unreliable.
  • Applications were scientific.
  • No programming methodology or tools existed.
  • Machine efficiency was the most important concern.

Fortran I Overview

• First implemented version of Fortran.
• Names could have up to six characters.
• Post-test counting loop (DO).
• Formatted I/O: Iw, Fw.d, A, etc.
• User-defined subprograms.
• Three-way selection statement (arithmetic IF):
  • If (expression) S1, S2, S3
  • S1 if expression < 0
  • S2 if expression == 0
  • S3 if expression > 0
• No data typing statements.
• Implicit typing: names starting with I, J, K, L, M, or N were integers; otherwise, floating-point.
• No separate compilation.
• Compiler released in April 1957, after 18 worker-years of effort.
• Programs larger than 400 lines rarely compiled correctly due to the poor reliability of the 704.
• Code was very fast.
• Quickly became widely used.

Fortran II

• Distributed in 1958.
• Introduced independent compilation.
• Fixed bugs in Fortran I.

Fortran IV

• Evolved during 1960-62.
• Introduced explicit type declarations.
• Logical selection statement.
• Subprogram names could be parameters.
• ANSI standard in 1966.

Fortran 77

• Became the new standard in 1978 (ANSI, 1978a).
• Character string handling.
• Logical loop control statement.
• IF-THEN-ELSE statement.

Fortran 90

• Most significant changes from Fortran 77.
• Modules.
• Dynamic arrays.
• Pointers.
• Recursion.
• CASE statement.
• Parameter type checking.

Fortran 95 and Later Versions

• Fortran 95 (INCITS/ISO/IEC, 1997): minor additions and some deletions.
• Fortran 2003: support for OOP, procedure pointers, interoperability with C.
• Fortran 2008 (ISO/IEC 1539-1, 2010): blocks for local scopes, co-arrays, Do Concurrent.
• Fortran 2018 (ISO/IEC 1539-1:2018): further interoperability with C, additional parallel features, conformance to the new version of the IEEE floating-point standard.
• Fortran 2023 (ISO/IEC 1539-1:2023): published in November 2023.

Functional Programming: LISP

• LISt Processing language.
• Designed at MIT by John McCarthy.
• AI research needed a language to:
  • Process data in lists (rather than arrays).
  • Perform symbolic computation (rather than numeric).
• Only two data types: atoms and lists.
• Syntax based on lambda calculus.
• Examples:
  • (A (B C) D (E (F G)))
• Factorial Function in LISP:
  • lisp (defun factorial (n) (cond ((= n 0) 1) (t (* n (factorial (- n 1)))) ) )

LISP Lists

• (A (B C) D (E (F G)))
• (A B C D)

LISP Evaluation

• Pioneered functional programming.
• No need for variables or assignment.
• Control via recursion and conditional expressions.
• Still the dominant language for AI.
• COMMON LISP and Scheme are contemporary dialects of LISP.
• ML, Haskell, and F# are also functional programming languages but use very different syntax.
• Garbage collection was invented by John McCarthy around 1959 to simplify manual memory management in Lisp.

Scheme

• A dialect of Lisp with a strong focus on functional programming concepts but also supports procedural and imperative-style programming when needed.
• Developed at MIT in the mid-1970s.
• Small.
• Extensive use of static scoping.
• Functions as first-class entities.
• Simple syntax (and small size) make it ideal for educational applications.
• Example: Functions as first-class entities.

COMMON LISP

• An effort to combine features of several dialects of LISP into a single language.
• Large, complex, used in industry for some large applications.

Scala

• Scalable Language.
• Full functional support.
• Very strong type system (all types inherit from class Any).
• Runs in JVM.
• Introduced in 2004.
• Example:
  • scala def factorial(x: BigInt): BigInt = if (x == 0) 1 else x * factorial(x - 1)

The First Step Toward Sophistication: ALGOL 60

• Development Environment:
  • FORTRAN had (barely) arrived for IBM 70x.
  • Many other languages were being developed, all for specific machines.
  • No portable language; all were machine-dependent.
  • No universal language for communicating algorithms.
  • ALGOL 60 was the result of efforts to design a universal language.

ALGOL 58

• Concept of type was formalized.
• Names could be any length.
• Arrays could have any number of subscripts.
• Subscripts were placed in brackets.
• Compound statements (begin ... end).
• Semicolon as a statement separator.
• Assignment operator was :=.
• If had an else-if clause.
• No I/O → make it machine-independent.

ALGOL 60 Overview

• Modified ALGOL 58 at a 6-day meeting in Paris.
• New features:
  • Block structure (local scope).
  • Two parameter passing methods.
  • Subprogram recursion.
  • Stack-dynamic arrays.
  • Still no I/O and no string handling.

ALGOL 60 Evaluation

• Successes:
  • It was the standard way to publish algorithms for over 20 years.
  • All subsequent imperative languages are based on it.
  • First machine-independent language.
  • First language whose syntax was formally defined (BNF).
• Failure:
  • Never widely used, especially in the U.S.
  • Reasons:
    • Lack of I/O and a standardized character set made programs non-portable.
    • Too flexible → hard to implement.
    • Entrenchment of Fortran.
    • Formal syntax description.
    • Lack of support from IBM.

Computerizing Business Records: COBOL

• Development Environment:
  • UNIVAC was beginning to use FLOW-MATIC.
  • USAF was beginning to use AIMACO.
  • IBM was developing COMTRAN.
• FLOW-MATIC (1957), originally known as B-0 (Business Language version 0), was the first English-like data-processing language.

COBOL Historical Background

• Based on FLOW-MATIC.
• FLOW-MATIC features:
  • Names up to 12 characters, with embedded hyphens.
  • English names for arithmetic operators (no arithmetic expressions).
  • Data and code were completely separate.
  • The first word in every statement was a verb.

COBOL Design Process

• First Design Meeting (Pentagon) - May 1959.
• Design goals:
  • Must look like simple English.
  • Must be easy to use, even if that means it will be less powerful.
  • Must broaden the base of computer users.
  • Must not be biased by current compiler problems.
• Design committee members were all from computer manufacturers and DoD branches.
• Design Problems: arithmetic expressions? subscripts? Fights among manufacturers.

COBOL Evaluation

• Contributions:
  • First macro facility in a high-level language.
  • Hierarchical data structures (records).
  • Nested selection statements.
  • Long names (up to 30 characters), with hyphens.
  • Separate data division.

COBOL: DoD Influence

• First language mandated by DoD.
• Would have failed without DoD.
• Still the most widely used business applications language.

COBOL Example

IDENTIFICATION DIVISION.
PROGRAM-ID. FACTORIAL.
DATA DIVISION.
WORKING-STORAGE SECTION.
77 N PIC 9(4).
77 A PIC S9 (4) VALUE 0.
77 F PIC 9(4) VALUE 1.
PROCEDURE DIVISION.
PARA.
DISPLAY "ENTER A NUMBER."
ACCEPT N.
PERFORM PARA1 UNTIL A == N.
DISPLAY
"THE FACTORIAL IS".
DISPLAY F.
STOP RUN.
PARA1.
ADD 1 TO A.
COMPUTE F = F *
A.

The Beginning of Timesharing: BASIC

• Designed by Kemeny & Kurtz at Dartmouth.
• Design Goals:
  • Easy to learn and use for non-science students.
  • Must be “pleasant and friendly”.
  • Fast turnaround for homework.
  • Free and private access.
  • User time is more important than computer time.
• Current popular dialect: Visual BASIC.
• First widely used language with time-sharing.
• BASIC: Beginner’s All-purpose Symbolic Instruction Code

Everything for Everybody: PL/I

• Designed by IBM and SHARE.
• Computing situation in 1964 (IBM's point of view):
  • Scientific computing:
    • IBM 1620 and 7090 computers
    • FORTRAN
    • SHARE user group
  • Business computing:
    • IBM 1401, 7080 computers
    • COBOL
    • GUIDE user group

PL/I: Background

• By 1963:
  • Scientific users began to need more elaborate I/O like COBOL had; business users began to need floating point and arrays for MIS.
  • It looked like many shops would begin to need two kinds of computers, languages, and support staff → too costly.
• The obvious solution:
  • Build a new computer to do both kinds of applications.
  • Design a new language to do both kinds of applications.

PL/I: Design Process

• Designed in five months by the 3 X 3 Committee.
• Three members from IBM, three members from SHARE.
• Initial concept:
  • An extension of Fortran IV.
  • Initially called NPL (New Programming Language).
  • Name changed to PL/I in 1965.

PL/I: Evaluation

• PL/I contributions:
  • First unit-level concurrency.
  • First exception handling.
  • Switch-selectable recursion.
  • First pointer data type.
  • First array cross-sections.
• Concerns:
  • Many new features were poorly designed.
  • Too large and too complex.
  • array cross sections: selecting a subset of elements from an array based on certain criteria or conditions.

Two Early Dynamic Languages: APL and SNOBOL

• Characterized by dynamic typing and dynamic storage allocation.
• Variables are untyped.
• A variable acquires a type when it is assigned a value.
• Storage is allocated to a variable when it is assigned a value.

APL: A Programming Language

• Designed as a hardware description language at IBM by Ken Iverson around 1960.
• Highly expressive (many operators, for both scalars and arrays of various dimensions).
• Programs are very difficult to read.
• Still in use; minimal changes.

SNOBOL (String-Oriented Symbolic Language)

• Designed as a string manipulation language at Bell Labs by Farber, Griswold, and Polensky in 1964.
• Powerful operators for string pattern matching.
• Slower than alternative languages (and thus no longer used for writing editors).
• Still used for certain text processing tasks.

The Beginning of Data Abstraction: SIMULA 67

• Designed primarily for system simulation in Norway by Nygaard and Dahl.
• Based on ALGOL 60 and SIMULA I.
• Primary Contributions:
  • Coroutines - a kind of subprogram
  • Classes, objects, and inheritance

Orthogonal Design: ALGOL 68

• From the continued development of ALGOL 60, but not a superset of that language.
• Source of several new ideas (even though the language itself never achieved widespread use).
• Design is based on the concept of orthogonality.
• A few basic concepts, plus a few combining mechanisms.

ALGOL 68 Evaluation

• Contributions:
  • User-defined data structures.
  • Reference types.
  • Dynamic arrays (called flex arrays).
• Comments
• Less usage than ALGOL 60.
• Had a strong influence on subsequent languages, especially Pascal, C, and Ada.

Pascal (1971)

• Developed by Wirth (a former member of the ALGOL 68 committee).
• Designed for teaching structured programming.
• Small, simple, nothing really new.
• The largest impact was on teaching programming.
• From the mid-1970s until the late 1990s, it was the most widely used language for teaching programming.

C (1972)

• Designed for systems programming at Bell Labs by Dennis Ritchie.
• Evolved primarily from BCLP and B, but also ALGOL68.
• Powerful set of operators, but poor type checking.
• Initially spread through UNIX.
• Though designed as a systems language, it has been used in many application areas.

Programming Based on Logic: Prolog

• Developed by Comerauer and Roussel (University of Aix-Marseille), with help from Kowalski (University of Edinburgh) in 1972.
• Based on formal logic.
• Non-procedural.
• Can be summarized as being an intelligent database system that uses an inferencing process to infer the truth of given queries.
• Comparatively inefficient.
• Few application areas.

World First Programmer

• Augusta Ada King, Countess of Lovelace (née Byron; 10 December 1815 – 27 November 1852).
• An English mathematician and writer, chiefly known for her work on Charles Babbage’s proposed mechanical general-purpose computer, the Analytical Engine.
• The last of Lovelace’s notes, Note G, was designed to calculate Bernoulli numbers using the Analytical Engine  the first algorithm specifically for a computer.

History’s Largest Design Effort: Ada

• Designed for embedded and real-time systems, primarily for the U.S. Department of Defense.
• Huge design effort, involving hundreds of people, much money, and about eight years.
• Sequence of requirements (1975-1978).
• Named Ada after Augusta Ada Byron.
• Widely recognized as the first programmer.

Ada Evaluation

• Contributions:
  • Packages - support for data abstraction.
  • Exception handling.
  • Generic program units.
  • Concurrency - through the tasking model.
• Comments:
  • Competitive design.
  • Included all that was then known about software engineering and language design.

Ada 95

• Ada 95 (began in 1988).
• Support for OOP through type derivation.
• Better control mechanisms for shared data.
• New concurrency features.
• More flexible libraries.
• Ada 2005
  • Interfaces and synchronizing interfaces
• Popularity suffered because the DoD no longer requires its use but also because of the popularity of C++.

Object-Oriented Programming: Smalltalk

• Developed at Xerox PARC, initially by Alan Kay, later by Adele Goldberg.
• First full implementation of an object-oriented language (data abstraction, inheritance, and dynamic binding).
• Pioneered the graphical user interface design.
• Promoted OOP.

C++

• Combining Imperative and Object-Oriented Programming.
• Developed at Bell Labs by Stroustrup in 1980.
• Evolved from C and SIMULA67.
• Facilities for object-oriented programming, taken partially from SIMULA 67.
• A large and complex language, in part because it supports both procedural and OO programming.
• Rapidly grew in popularity, along with OOP.
• ANSI standard approved in November 1997.

Related OOP Languages

• Objective-C (designed by Brad Cox – early 1980s)
  • C plus support for OOP based on Smalltalk.
  • Uses Smalltalk’s method calling syntax.
  • Used by Apple for systems programs.
• Delphi (Borland)
  • Pascal plus features to support OOP.
  • More elegant and safer than C++.
• Go (designed at Google - 2009)
  • Loosely based on C, but also quite different.

An Imperative-Based Object-Oriented Language: Java

• Developed at Sun in the early 1990s.
• C and C++ were not satisfactory for embedded electronic devices.
• Influenced by C++.
• Significantly simplified: intentionally omitted certain features found in C++, such as explicit pointer arithmetic, explicit memory management through pointers, and certain type coercions.
• Has references, but not pointers.
• Memory Management: automatic memory management through garbage collection.
• Includes support for applets and a form of concurrency.
• Platform independence.

Java Evaluation

• Eliminated many unsafe features of C++.
• Supports concurrency.
• Libraries for applets, GUIs, database access.
• Portable: Java Virtual Machine concept, JIT compilers.
• Widely used for Web programming.
• Use increased faster than any previous language.
• Most recent version, Java SE 24, released in March 2025.

Scripting Languages for the Web

• Perl
  • Designed by Larry Wall—first released in 1987.
  • Variables are statically typed but implicitly declared.
  • Three distinctive namespaces, denoted by the first character of a variable’s name.
  • Powerful, but somewhat dangerous.
  • Gained widespread use for CGI programming on the Web.
  • Also used as a replacement for the UNIX system administration language.

Scripting Languages for the Web (cont.)

• JavaScript
  • Began at Netscape, but later became a joint venture of Netscape and Sun Microsystems.
  • A client-side HTML-embedded scripting language, often used to create dynamic HTML documents.
  • Purely interpreted.
  • Related to Java only through similar syntax.

Scripting Languages for the Web (cont.)

• PHP
  • "PHP: Hypertext Preprocessor” (a recursive acronym) is a widely-used open source-based general-purpose scripting language that is especially suited for web development and can be embedded into HTML.
  • A server-side HTML-embedded scripting language, often used for form processing and database access through the Web.
  • Purely interpreted.

Scripting Languages for the Web (cont.)

• Python
  • An OO interpreted scripting language.
  • Type checked but dynamically typed.
  • Used for CGI (Common Gateway Interface) programming and form processing.
  • Supports lists, tuples, and hashes.

Scripting Languages for the Web (cont.)

• Ruby
  • Designed in Japan by Yukihiro Matsumoto (a.k.a, “Matz”).
  • Began as a replacement for Perl and Python.
  • A pure object-oriented scripting language.
    • All data are objects.
  • Most operators are implemented as methods, which can be redefined by user code.
  • Purely interpreted.

The Flagship .NET Language: C

• Part of the .NET development platform (2000).
• Based on C++, Java, and Delphi.
• Includes pointers, delegates, properties, enumeration types, a limited kind of dynamic typing, and anonymous types.
• Is evolving rapidly.

Markup/Programming Hybrid Languages

• XSLT
  • eXtensible Markup Language (XML):
    • a metamarkup language
  • eXtensible Stylesheet Language Transformation (XSTL)
    • transforms XML documents for display
    • Programming constructs (e.g., looping)
• JSP
  • Java Server Pages:
    • a collection of technologies to support dynamic Web documents
  • JSTL, a JSP library, includes programming constructs in the form of HTML elements

Summary

• Development, development environment, and evaluation of a number of important programming languages.
• Perspective into current issues in language design.