Learning Computing History

A Brief History of Programming Language

In the early days, computers were programmed using instructions that the hardware understood directly. From machine language, to human-readable assembly language, to high lever language which abstract away form the details of the hard ware, hence become portable to different type of hardware, the programming language at its third generation, start boom rapidly.

Early high-level languages: The most famous early imperative high-level languages are FORTRAN, COBOL AND ALGOL 60.  The Main focus is machine state or the set of values stored in memory location, and command-driven.

FORTRAN (Formula Translator)

• Stands for “FORmula TRANslating system”, developed by John Backus.

• Fortran I (1957), designed for IBM 704 computer, all control structures corresponded to 704 machine instructions

• First manual 1956, first successful compiler 1958 (Took 18 person-years to write compiler!)

• Fortran II (1958), independent compilation and fix the bugs.

• Fortran IV (1960-1962), explicit type declarations, logical selection statement, and subprogram names could be parameter, use ANSI standard in 1966.

• Fortran 77 (1977), able to hand character string, logical loop control statement and IF-THEN-ELSE statement.

• Fortran 90 (1990), uses modules, dynamic arrays, pointer, recursion CASE statement and parameter type checking.

Fortran was the first effectively implemented high-level language, it pioneered many techniques of scanning, parsing, register allocation, code generation, and optimization, it introduced variables, loops, procedures, statement labels and much more.  It forever changed the way computers are used.

COBOL – 1960

• Lead by Department of Defense personal, Grace Hopper

• Designed for business application, features for structuring data and managing files.

• Based on FLOW-MATIC:

  • Names up to 12 characters, with embedded hyphens

  • English names for arithmetic operators

  • Data and code were in completely separated sections

  • Verbs were first word in every statement

• First Design Meeting - May 1959, design goals: English like, easy to use, able to broaden computer users, not be biased by current compiler problems.

• Contributions:

  • First macro facility in a high-level language, very strict program organization

  • Hierarchical data structures (records), data structures, record type introduced for the first time.

  • Nested selection statements, though poor control structures

  • Long names (up to 30 characters), with hyphens

  • Data Division

COBOL is still the most widely used business application language, used to be very popular in business and government, though much less at universities. It is the first business-oriented computation language required by DoD.

ALGOL (Algorithmic Language)

• Realized the importance of standardization, and FORTRAN was one company’s product (IBM), ALGOL was developed by a joint European-American committee

•  ALGOL Goals

  • Should be as close as possible to standard math notation

  • Readable without too much additional explanation or even comments

  • Can be used for describing computing processes (algorithms) in publications

  • Mechanically translatable into machine code

• ALGOL Versions: ALGOL 58 was first version, never implemented! ALGOL 60 was next, incorporated criticisms of ALGOL 58; report for the “60” was an important event in history of computing; revised report, 1963, was a classic.

• Many concepts were introduced:

  • Language definition

  • Structured

  • Arrays can have variable bounds at compile time

  • Contained several structured control statements

  • Recursion introduced for the first time!

ALGOL  was an international effort to design a universal language and never popular, but virtually all languages after 1958 used ideas pioneered by the Algol designs for it introduced and formalized many common language features of today.

A different view of the world: Other early languages pioneered non-imperative paradigms. Lisp emerged in the 1960s as a pure functional language although it absorbed some imperative features as time went on. APL is also functional in nature.  Its strength is very high-level operations that use matrices.

LISP (List Processing) - 1959

• Developed at MIT by John McCarthy

• Designed for Artificial Intelligence Research, it is symbolic, flexible, and dynamic.

•  Performs computations with symbolic expressions more than with numbers

• Represents symbolic expressions and other info in the form of list structures in memory

• Uses small set of constructor and selector operations to create and extract info from lists

• Recursive control is more natural than iterative control!!

• Data and program are equivalent forms. Thus programs can be easily modified like data!

• Probably the first language to implement garbage collection!

• Close to a pure functional language    and interactive

Lisp quickly became, and remains the most popular language for AI applications and it is the second-oldest general-purpose programming language still in use.  Some ideas, like the conditional expression and recursion, were adopted by Algol and later by many other imperative languages, the function-oriented approach influenced modern functional languages and garbage collection is increasingly common in many different language families.

APL (A Programming Language) 1962

• Designed by  Ken Iverson at IBM  for concise description of math algorithms

• Originally contained a large number of operators, Trimmed down once implemented, but still very rich

• APL has a large alphabet, and these unusual characteristics:

  • The primitive objects are arrays (lists, tables, or matrices)

  • It’s an operator-driven language, branches not used much

  • No operator precedence, just left to right

  • Designed as a hardware description language

  • Highly expressive (many operators, for both scalars and arrays of various dimensions)

  • Programs are very difficult to read

Advances in high-level languages: The 1960 - 1970s brought many new languages, building on experiences with the early ones. Basic is the first in history language of personal computing. Pascal is an ALGOL-like imperative language that gained a vast following primarily due to its utility for teaching programming. Another notable language of this time is Simula which is the first mainstream language to have object-oriented features (with an imperative core).

BASIC (1964)

• Designed by Kemeny & Kurtz at Dartmouth

• designed for beginners, unstructured but popular on microcomputers in 70's

• The first programming language for many programmers: designed to be easy to learn.

• Very simple, limited, though still general-purpose.

• Current popular dialects: QuickBasic and Visual BASIC

• Present-day versions of Basic are full-fledged languages—not "basic", and not easy to learn any more.

Pascal (1971)

• Developed by Niklaus Wirth in the late 60’s and early 70’s; built on his earlier work on Algol W.

• Small, simple, nothing really new. A conceptually simplified and cleaned-up successor of Algol 60.

• Inclusion of features that encourage well-written and well-structured program

  • A great language for teaching structured programming. became the primary teaching language in the world by mid-80’s

  • Data types are a prominent feature of Pascal

    • Integer

    • Real

    • Boolean

    • Char

    • Enumeration types

    • Structured user-defined types include

      • Arrays

      • Records

      • Sets

      • File

    • An excellent first language to learn.

  • Not rich in features for systems programming (bit-twiddling), however, its later extensions (for example, Delphi) are full-fledged systems programming packages, as powerful as any Java kit.

Though Pascal designed as a teaching language but used extensively, emphasized structured programming.

Simula (Simulation Languages)

• Developed in the 60’s at the Norwegian Computing Centre in Norway by Nygaard and Dahl

• Designed primarily for simulating discrete systems, including concurrent processes

• Simula ’67 was the best known version

• Based on Algol ’60 with one very important addition, the CLASS concept

• Primary Contribution -- Introduced the central concepts of object orientation: classes and encapsulation.

• Predecessor of Smalltalk and C++.

• Now unused.

Non-imperative paradigms: Smalltalk is the most famous object-oriented language.  It took some of the concepts of Simula to the nth degree in that every piece of data in a Smalltalk program is an object; Prolog pioneered the idea of logic programming where we can program with relations.  Prolog is also one of the most popular declarative languages, so-called because they let you specify what you want to happen rather than how it should happen.

Smalltalk (1972-1980)

• Developed at Xerox PARC, initially by Alan Kay, later by Adele Goldberg

• Inspired by Simula, Sketchpad, Logo, cellular biology

• Object-Oriented:

  • More object-oriented that most of its more popular descendants, everything is an object: variables, constants, activation records, classes, etc.

  • First full implementation of an object-oriented language (data abstraction, inheritance, and dynamic type binding); Objects (encapsulating state and behavior) communicate via messages

  • It is the purest object-oriented language ever designed (till now), cleaner than Java, much cleaner than C++.

• Comes complete with a graphical interface and an integrated programming environment.

•  In skilled hands, a powerful tool.

Together with Simula, they inspired a generation of object-oriented languages. Smalltalk still has a small but active user community.

Prolog - programmation en logique (1972)

• Developed at the University of Aix-Marseille, by Alain Colmerauer and Philippe Roussel, with some help from Robert Kowalski at the University of Edinburgh

  • 1971 Robert Kowalski published an efficient resolution-based technique, SL-resolution

  • 1972, Alain colmerauer and Philippe Roussel developed Prolog for the automated deduction part of an AI project in natural language understanding.

  • 1973 version: Eliminated special backtracking controls (introducing the cut operation instead) and Eliminated occurs-check

  • David Warren, 1977: efficient compiled Prolog, the Warren Abstract Machine

•  Based on formal logic

• Non-procedural

• Resolution sort of like depth first search

• Summarized as an intelligent database system that uses an referencing process to infer the truth of given queries

Modern languages: C is arguably the most widely used imperative language today. Various languages have branched away from C by adding object-oriented features.  The most obvious are C++, Java and C#.  Delphi is an object-oriented descendant of Pascal. Modern functional languages like ML and has built on the concepts pioneered in Lisp. In many ways they are also declarative.

C (1972)

• Designed for systems programming at Bell Labs by Dennis Ritchie

• Evolved primarily from BCPL, B, and also ALGOL 68

• A great tool for systems programming and a software development language on personal computers.

• Powerful set of operators, but poor type checking

• Initially spread through UNIX

• Once fashionable, still in use, but usually superseded by C++.

• Dangerous if not used properly: not recommended to novice programmers.

• Relatively low-level.

C++ (1985)

• Developed at Bell Labs by Bjarne Stroustrup

• Evolved from C and SIMULA 67

• Facilities for object-oriented programming, mostly from SIMULA 67, were added to C

• Also has exception handling (from Ada)

• A large and complex language, Complicated syntax, difficult semantics, in part because it supports both procedural and OO programming

• Very fashionable, very much in demand , rapidly grew in popularity, along with OOP

• ANSI standard approved in November, 1997 (C++ ISO/IEC 14882:1998)

C ++ is an object-oriented extension of the imperative language C. This is a hybrid design, with object orientation added to a completely different base language.

Java (1995)

• Developed by James Gosling from  Sun Microsystems

• 1991: Oak: a language for ubiquitous computers in networked consumer technology

• Based on C++, but significantly smaller and simpler

  • Supports only OOP

  • Has references, but not pointers

  • Includes support for applets and a form of concurrency

  • More secure and strongly typed

  • More platform independent

• 1995: renamed Java, retargeted for the Web

  • Incorporated into web browsers

  • Platform-independent active content for web pages

• Java also has:

  • Garbage collection (ex Lisp)

  • Concurrency (ex Mesa)

  • Packages (ex Modula)

• Designed for network & distributed programming, multi-tier applications (databases)

Java is a neat, cleaned up, sized-down reworking of C++ with full object orientation features. 

Scripting languages: These languages are designed for rapid application development and deployment, but are not really suitable for large programs due to inefficiency and lack of safety features such as strong typing.

• Widely used scripting languages are Perl, Python and Tcl.

• Special-purpose languages such as awk was developed for these purposes

• Perl is one of the most popular languages for writing CGI scripts.

• Other languages for that purpose include Python Tcl, and JavaScript

• Can also write CGI scripts in more conventional languages but it’s less convenient to do so

Family tree of high-level languages *

* Copy from CSC 221 Computer Programming I/history & background lecture slide by Dr. David Reed at Creighton University

Conclusion: Languages can only be judged within a particular domain or for a specific application, such as: Business applicationsà COBOL; Artificial intelligenceà  LISP/Scheme or Prolog; Systems programming à C; Software engineering à C++ or Java or Smalltalk; Web development à Java or JavaScript or VBScript or Perl.

Is the evolution of programming languages nearly done, or have we as far again to go? Maybe all the important discoveries have been made, and language evolution will now slow and converge, or maybe we will have the pleasure of seeing new ideas, now unknown and un-guessed, become perfectly obvious to everyone.