Module 1 - Topic 1.3: Development of Programming Languages

Factors influencing the development of programming languages

Development influenced by hardware advances, compiler technology, and user needs for reliability, readability, writeability, reusability, and efficiency.

Machine language

Description: First generation programming language; native to computers; consists of pure binary instructions; difficult for humans to remember.

Assembly language

Machine language with mnemonics for bit patterns; allows variables, labels, addressing modes, and macros; requires an assembler to translate to machine code.

Assembler

Program that translates assembly code into machine code, replaces mnemonics with binary, substitutes registers/memory addresses, calculates branch destinations.

First high-level programming language

Konrad Zuse’s Plankalkül (1946), developed on the Z4 machine at ETH Zürich; included a chess-playing program.

Short Code

First high-level language used on an electronic computer (1949); no compiler, programs hand-compiled into machine code.

Grace Hopper

A0 compiler (1951), the first widely known compiler.

Autocode

Primitive compiler by Alick E. Glennie (1952) for Manchester Mark I; translated symbolic statements into machine language.

Fortran

Developed 1954–1957 by John Backus’ IBM team; FORmula TRANslating; supported variables, procedure calls, control structures; versions include Fortran II (1958), ASA Fortran 66, ANSI Fortran 77, ISO Fortran 90, ISO Fortran 95.

BNF (Backus-Naur Form)

Formal notation for defining programming language syntax; co-developed by John Backus.

Spaghetti programming

Pre-structured programming style with tangled control flow; difficult to maintain.

Structured programming

Organizes code into modules with single entry/exit; uses only sequence, selection, and iteration; promoted by Edsger Dijkstra.

Algol 58 & Algol 60

Algol 60 (1960) first block-structured language; revisions in 1963, 1968; Edsger Dijkstra designed first compiler; abolished goto.

Pascal

Developed 1968–1970 by Niklaus Wirth; successor languages include Modula (1977), Modula-2 (1980), Oberon (1988); Oberon added inheritance and type-bound procedures.

C language

Developed 1969–1973 by Dennis Ritchie at DEC for Unix; preceded by BCPL (1967) and B (1969); weak type checking for flexibility.

Simula

Developed 1962–1967 by Ole-Johan Dahl and Kristen Nygaard; introduced object-oriented concepts like classes, objects, inheritance, late binding.

Smalltalk

Developed at Xerox PARC (Alan Kay); versions include Smalltalk-72, -74, -76, -80; influenced by Lisp and Simula.

C++

Developed 1980 by Bjarne Stroustrup as “C with classes”; renamed in 1983; strong type checking, OOP features from Simula.

Java

Developed at Sun Microsystems by James Gosling et al.; announced 1995; predecessors C++ and Smalltalk; compiles to bytecode interpreted by JVM; dominant for Internet apps.

C#

Announced 2000 by Microsoft; derived from C++ and Java; fully object-oriented; emphasizes component-oriented programming.

Lisp

Functional language developed 1958 by John McCarthy; based on lambda calculus; dialects include Scheme, InterLisp, FranzLisp, MacLisp, ZetaLisp.

Scheme

Lisp dialect developed 1975 by Steele & Sussman at MIT; standardized 1989; relies on recursion instead of loops; functions as first-class objects.

Common Lisp

Developed starting 1981 to unify Lisp dialects; standardized 1992; merger with Scheme failed.

FP language

Functional language by John Backus; rule-based, not lambda calculus.

ML

Strongly typed functional language from UK; type inference; based on lambda calculus.

Miranda

Pure functional language by David Turner (1985–86); referentially transparent; combines SASL and KRC features with strong typing.

Logic programming

Programming paradigm based on formal logic; examples include ALF, Gödel, RELFUN.

Prolog

Invented 1971 by Alain Colmerauer and Philippe Roussel; based on Horn logic; originally for natural language processing; common in AI; modern versions include GNU Prolog, SWI-Prolog, SICSTUS Prolog.