A Brief History of Programming Languages

Smalltalk

First fully object-oriented language - everything is an object. First language with GUI as fundamental part of language. Never widely adopted - tied to particular GUI and therefore particular hardware. Had huge influence on OO languages none the less.

Go

C++, only loosely related to other C languages. Designed 2007-2009, largely in response to slow compilation times for C++. Goal was fast compilation. Does not support inheritance or generics. Includes goto statement, pointers, associative arrays, support for concurrency.

FORTRAN 95

Added Forall iteration to ease parallelization

FORTRAN 2003

Added Object oriented programming, procedure pointers, interoperability with C.

FORTRAN 77

Added char strings, logical loop control, optional Else to go with If

FORTRAN 90

Added dynamic arrays, records, pointers, multiple selection, modules, recursion.

FORTRAN 2008

Added local scopes, co-arrays, DO CONCURRENT

Dynabook

Alan Kay's research led to dynabook - desktop metaphor, with desktop containing pages. Kay went to Xerox PARC, which developed language to support this, eventually leading to Smalltalk 72..

ALGOL 68

First to incorporate user-defined data types. First to introduce implicit heap-dynamic arrays, did not need subscript bounds, and expanded as needed. Heavy emphasis on orthogonality. Designed in Van Wijngaarden grammar.

1950

David Wheeler (Cambridge) develops method of using blocks of relocatable adresses to solve problem of relocatable addresses.

SNOBOL

Designed by Bell Labs in 1960s. Deesigned for text Processing. Designed for string pattern matching (early use was text-editors). Still in use today for some apps.

Objective-C

Designed early 1980s, originally consisted of C, plus the classes and message passing of Smalltalk. Steve Jobs left Apple and founded NeXT, licensed Objective-C to write system Software. All iPhone development is in Objective-C.

SIMULA 1

Designed in 1964 on UNIVAC 1107, extended to SIMULA 67. Extension of ALGOL 67, mostly focusing on subprograms. Big step towards OOP. Developed first idea of classes.

APL

Developed in 1960 by Kenneth Iverson at IBM. Originally designed for describing comp arch. Special operators for matrix manips. Most commands are 1-char, many specialized symbols. Very expressive. Orthogonal, operators can be put in almost any order. Very low readability, unmaintainable, used mainly for throwaway programs.

Early Programming

Earliest computers were electromechanical & 'programmed' by plugboard. No assembler. All addresses are absolute. No floating-point hardware support. No subroutines, code libraries, etc.

FORTRAN IV

Explicit type declaration. Ability to pass subprograms as parameters.

ALGOL 58

Formalized data types. Compound statements. Identifiers could be any length. Nested selection allowed. Intended as design document, but many implemented it. JOVIAL the only language directly descended from ALGOL 58 to gain wide acceptance.

1951-53

Grace Hopper's team at UNIVAC developed A-0, A-1, A-2, which expanded psuedocode into machine-language code similar to macro expansion.

Delphi

Hybrid of Pascal and C. Provides GUI to the developer and simple way to construct GUI applications.

PL/I

IBM in the 1960's (1963). Final version adopted in 1964. A replacement for FORTRAN, COBOL, and LISP. A language for business and science applications. Support for systems level programming and list processing. Widely used as an instructional language. Mostly just good for all of its firsts. ALGOL 60: recursion, block structure FORTRAN IV: Separate compilation, communication through global data COBOL 60: data structures, good I/O, report generation facilities. Firsts: Concurrently executing subprograms- poorly implemented. Exception handling: 23 types of runtime errors -poorly implemented as well Recursive subprograms allowed, but recursion could be disabled, making nonrecursive subprograms link more efficiently. Pointers as data type - hard to use Cross-sections of arrays could be referenced (slicing).

Functional Programming: LISP - History

Interest in AI came from several sources. Need to process symbolic data in linked lists rather than crunch numbers in arrays. Design for information processing language-l as part of logic theorist published, never implemented. IPL-II implemented 1958 (apprx); IPL-V published 1960. John McCarthy in 1958 needed control flow, recursion, conditional expressions, need to deallocate list portions no longer needed.

1954 - Speedcoding

John Backus develops Speedcoding for the IBM 701. Allowed 701 to function as a 3-address FP calculator. Conditional and unconditional branching. Automatically incremented address registers. Left 700 words for the main program; each instruction took 4.2 ms to execute.

1949: Short Code

John Mauchly for BINAC later ported to UNIVAC I. Code values were byte-pair codes. Much slower than machine code.

1936-45

Konrad Zuse developed Plankalkul for a theoretical machine never built. First high-level language. 2's Complement, Floating point, Arrays, Records, Developed in Bavaria during war. Code for sorting arrays, test connectivity of graph, square root.

Functional Programming: LISP

LISP has only atoms and lists. Atoms - identifiers, or numeric literals. Lists - ordered collection of atoms. Stored internally as single-linked lists. Each node has 2 pointers. First functional language. Dominated AI programming for over 25 years. Reputation for slowness (largely overcome). Descendants: Scheme Common LISP Related: ML Miranda Haskell Caml Ocaml F# Racket

Prolog

Logic programming languages use formal reasoning, usually based on resolution proof techniques. They are nonprocedural do not specify how a solution is to be found. First interpreter developed in 1972, published in 1975.. Really useful for certain types of problems.

Ada

Most extensive (and expensive language) design effort. By 1974, over half of all DoDs comp apps. were embedded systems. These included more than 450 programming languages, none of them standardized. DoDs standardization on COBOL for business applications had been successful. The Army, Navy, and Air Force independently propose developing a single, high-level language for embedded systems. 4 Finalists chosen, all BASED on Pascal 1979, name of Ada proposed and adopted MIL-STD 1815, the standard Ada Language Reference Manual, adopted July 1980. ANSI Standard produced 1983. Design then frozen for minimum of 5 years. Features: Packages allow encapsulating data objects, specs for data types and procedures. Elaborate exception handling Introduction of generic code (template class). Concurrent execution of subprograms.

1958 - FORTRAN II

Mostly bug fixes. Added separate compilation for subroutines.

ALGOL-W

Niklaus Wirth and C.A.R. Hoare. Pass by value/result. Introduction of case statement. Became basis for PASCAL, which was mainly a teaching language.

Early BASIC

Originally non-interactive (no data from user). 14 statements, 1 variable type (FP). First widely-used language used through terminals connected to a remote computer. Design mostly from FORTRAN. Little standardization. Poorly structured. Weak readability and reliability. Early versions not meant for serious programs of any significant size.

C++

Procedural and OO. Bjarne Stroustrup at Bell Labs started working on extension to C in 1980. 1981: Inline functions, default parameters, overloaded assignment operator added. First implementation appeared in 1985, translated C++ into C. Current version standardized in 1998.

ALGOL

Resulted from years-long effort to produce a universal scientific programming language. Before this language, each hardware required rewriting the language for the specific hardware. Petition in 1957 to study/recommend machine-independent scientific programming language. First design May-June 1958 in Zurich - resulted in ALGOL 58 (formerly known as IAL).

FORTRAN

Slow interpretation was accepted because there was no FP support in hardware; with all FP done in software, it was slow and interpretation was minor. FP in hardware made interpretation not important. FORTRAN (FORmula TRANSlation) was predicted to be as efficient as hand-coded programs, and to eliminate coding errors and thus debugging (not realistic)

1950's Computers

Small memories, slow and relatively unreliable, primarily used for scientific computation, no existing efficient ways to program them, computer time very expensive compared to programmer time. Primary goal was speed of computer, not programmer coding time.

Java

Sun Microsystems recognizes need for language for embedded consumer devices. Reliability was primary design goal. If a flaw is discovered only after million units have been sold and shipped, a recall would be expensive. C was compact, but didn't provide OO code; C++ was too large and complex. Neither safe. None of the products it was planned for ever went to market. Instead, used for applets for web. Based on C++, but simpler, smaller, more reliable. Java does not have pointers, but reference types provide some of the same functionality. All Java programs are defined in classes, so all Java programs are OO. Concurrency through synchronized modifier. Java uses implicit deallocation and garbage collection. Type coercion is only allowed going from smaller to larger type.

ALGOL 60

The first language to be described using Backus-Naur form. Pass by value and pass by name. Recursion. Stack-dynamic arrays (subscript ranges passed in to subroutines as parameters, so array size is defined when subroutine starts on each invocation). Pretty much every imperative language is descended form ALGOL 60. First machine-independent language. Failed to take off in US and never the most popular in Europe.

Systems Programming: C

UNIX developed at Bell Labs in 1960s. Originally written in assembly; some parts in BCPL and a successor B. Both languages untyped; data are machine words, leading to various complications and insecurities. Early versions didn't type-check (pre-1999); better flex, but not secure. Basic compiler was quite good, produced fast compact object code, included in UNIX.

COBOL

Widely adopted, but barely effected the design of subsequent languages. First design conference in 1959, sponsored by DoD. Standardized in 1968. Define Verb. Hierarchal records. Name could be 30 chars and have connector hyphens. Division of code and data. Weakest is procedure. Poor compiler performance.

BASIC

Widely successful, but gets no respect. Early version limited and inelegant. Very popular on microcomps of 1980s. Originally written at Dartmouth College by 2 mathematics professors. Introduced time-sharing terminals. Design/coding started fall 1963. 1964, 4:00 AM, May 1, first program using timeshared BASIC was typed in and run.

1956 - FORTRAN I

i/o formatting, 6-char variable names, user-defined subroutines, commands for IF, DO. All based on 704 instructions. No data typing. First widely adopted language