A BRIEF HISTORY OF PROGRAMMING LANGUAGES

1. A BRIEF HISTORY OFPROGRAMMING LANGUAGES

2. Figure 2.1 Genealogy of common high-level programming languages

3. TIOBE

4. Pseudocodes (1949) - Short code; 1949; BINAC; Mauchly - Expressions were coded, left to right - Speedcoding; 1954; IBM 701, Backus - Pseudo ops for arithmetic and math functions - Conditional and unconditional branching - Autoincrement registers for array access - Slow! - Only 700 words left for user program

5. FORTRAN(mid-late 1950’s) • Emphasis on scientific programming • FORTRAN 0 1954(not implemented) • FORTRAN I 1957 • FORTRAN II 1958 • FORTRAN IV 1960-62 • FORTRAN 77 1978 • FORTRAN 90 1990 • FORTRAN 95 1995 Dramatically changed forever the way computers are used

6. FORTRANin depth • FORTRAN II – 1958 • Independent compilation • FORTRAN IV – 1960-62 • Improved data typing • ANSI standard in 1966 • FORTRAN 77 – 1978 • Better logical statements • FORTRAN 90 – 1990 • Allows recursion • Syntactic changes • FORTRAN 95 – 1995 • Deletes some deprecated features • Deprecates more features

7. LISP(1959) • Designed at MIT by McCarthy • Still the dominant language for AI • Pioneered functional programming • Syntax is based on lambda calculus • Contemporary dialects: COMMON LISP, Scheme • Object-oriented versions: Flavors, LOOPS, CLOS • Related languages: ML, Miranda, Haskell

8. Scheme • Developed at MIT in mid 1970s • Small • Extensive use of static scoping • Functions as first-class entities • Simple syntax (and small size) make it ideal for educational applications

9. COMMON LISP • An effort to combine features of several dialects of LISP into a single language • Large, complex

10. ALGOL • Goals of the language • Close to mathematical notation • Good for describing algorithms • Must be translatable to machine code • Not meant to be implemented, but variations of it were • MAD, JOVIAL • IBM initially enthusiastic, but all support dropped by mid-1959

11. ALGOL 58(1958) • Formalized the concept of the data type • Compound statements (begin ... end) • Parameters were separated by mode (in & out) • Names could have any length • Arrays could have any number of subscripts • Subscripts were placed in brackets • Semicolon as a statement separator • Assignment operator was := • if had an else-if clause • no i/o - “would make it machine dependent”

12. ALGOL 60(1960) • New Features: • Block structure; multiple scopes • Better parameter passing • Recursion • Stack-dynamic arrays • Successes: • Standard for publishing algorithms for over 20 years • All subsequent imperative languages are based on it • First machine-independent language • First formally defined syntax • Failures: • Programs non-portable • Hard to implement • Intrenchment of FORTRAN • Formal syntax description • Lack of support of IBM

13. COBOL(1960) • Based on FLOW-MATIC, which had: • Names up to 12 characters, with embedded hyphens • English names for arithmetic operators • Data and code kept completely separate • Verbs as the first word in every statement • COBOL Design Problems: • Arithmetic expressions? • Subscripts? • Fights among manufacturers • Contributions: • Macros • Hierarchical data structures • Nested selection statements • Long names with hyphens • Separate data division

14. BASIC(1964) • Intended for teaching how to program • Interactive interpreted environment • Designed by Kemeny & Kurtz at Dartmouth • First widely used language with time sharing • Current popular dialect: Visual BASIC

15. PL/I(1965) • Contributions: • First unit-level concurrency • First exception handling • Switch-selectable recursion • First pointer data type • First array cross sections • Comments: • Many new features were poorly designed • Too large and too complex • Was (and still is) actually used for both scientific and business applications

16. APL(1962) • Array and matrix processing • Dynamic typing and dynamic storage allocation • Designed as a hardware description language • Highly expressive • Programs are very difficult to read

17. SIMULA 67(1967) • Introduced classes • data and operations together • Designed primarily for system simulation • Based on ALGOL 60 and SIMULA I • Primary Contribution: • Classes, objects, and inheritance

18. ALGOL 68(1968) • Primary design goal: orthogonality • Based on ALGOL 60, but not a superset

19. Pascal(1971) • Designed for teaching structured programming • Small, simple, nothing really new • Many subsequent languages based on Pascal • Delphi • Occam

20. C(1972) • Designed for systems programming • Powerful set of operators • Poor type checking • Initially spread through UNIX • Flexible, but unsafe

21. Prolog(1972) • Logic language, non-procedural • Programs are sets of facts and rules • Not proven to be widely applicable

22. Ada(1983 - began in mid-1970s) • Contributions: • Packages; Exception handling; Generic program units; Concurrency • Comments: • Competitive design • Included all that was then known about software engineering and language design • First compilers were very difficult: Five years to develop the first really usable compiler • Ada 95 (began in 1988) • Support for OOP through type derivation • New concurrency features • More flexible libraries

23. Smalltalk(1972-1980) • Object-oriented programming language • Really a graphical environment • Developed at Xerox PARC • First full implementation of an object-oriented language • Pioneered the GUI everyone now uses

24. C++(1985) • Design goal: no performance penalty, relative to C • Features: • Parameterized types (templates) • Exception handling • Operator overloading • Facilities for object-oriented programming added to C • Large and complex • Rapidly grew in popularity, along with OOP • ANSI standard approved in November, 1997!!

25. Java(early 1990’s) • Developed at Sun Microsystems • Smaller, simpler, more reliable C++ • Significantly simplified • All code must be encapsulated in classes • Concurrency support (threads) • Garbage collected • JavaScript (1995) • Began as LiveScript at Netscape • Client-side HTML-resident scripting language • Used for designing client-side dynamic documents • Purely interpreted

26. Scripting Languages • Earliest scripts were files which stored a sequence of OS commands • interpreted by simple OS facility • UNIX had a profound influence • sh • ksh • awk • Not all are Turing Complete

27. Perl (1987) • Related to ALGOL only through C • A scripting language • A script (file) contains instructions to be executed • Other examples: sh, awk, tcl/tk • Developed by Larry Wall • Perl variables are statically typed and implicitly declared • Three distinctive namespaces, denoted by the first character of a variable’s name • Powerful but somewhat dangerous • Widely used as a general purpose language

28. Scripting Languages for the Web • JavaScript • Used in Web programming (client side) to create dynamic HTML documents • PHP (1994) • Server-side HTML-resident scripting language • Purely interpreted • Python • An OO interpreted scripting language

29. C#(2000) • Microsoft • The primary language of the .NET platform • A successor to both Java and C++ • Includes most of the features of Java, with some modifications, as well as some of the features of C++ that were left out of Java • Can be used for both .NET applications for the Web, as well as a general-purpose programming language

30. Markup/Programming Hybrid Languages • XML : eXtensible Markup Language • a metamarkup language • eXtensible Stylesheet Language Transformation (XSTL) transforms XML documents for display • JSP : Java Server Pages • a collection of technologies to support dynamic Web documents

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