1 / 64

Chapter 2

Chapter 2. Evolution of the Major Programming Languages. Amid the strife of war. 1936-1945 Konrad Zuse (Tsoo-zuh) Built a series of complex computers from electromechanical relays Developed a language called Plankalkul for expressing computations Unpublished until 1972.

sai
Download Presentation

Chapter 2

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Chapter 2 Evolution of the Major Programming Languages

  2. Amid the strife of war... • 1936-1945 • Konrad Zuse (Tsoo-zuh) • Built a series of complex computers from electromechanical relays • Developed a language called Plankalkul for expressing computations • Unpublished until 1972

  3. ShortCodeA Step Toward Readability/Writability • 1949 • John Mauchly • Developed a language named ShortCode for the BINAC • It consisted of coded versions of mathematical expressions • Example statement: 00 X0 03 20 06 Y0 • Meaning X0 = SQRT(ABS(Y0)) • X0 and Y0 were variable names; 03 the assignment opearator, 20 sqrt, and 06 absolute value • Machine implementation was pure interpretation, which was termed automatic programming. • More readable and writable than keying in the machine code equivalent, but at a cost of running 50 times slower.

  4. 1950s Compiling systems Relocatable code Assembly languages Fortran 0, I, II AI – FLPL; IPL-I, LISP Business – Flowmatic & COBOL ALGOL

  5. Keep in Mind the Initial Context • At the beginning of the 50s • Primary use of computers were for numerical calculations • Computer memories were small • Hardware did not directly support floating point operations or indexing • Hardware was unreliable • Hardware was more costly than programmers

  6. A First Compiling System • 1950-1953 • Grace Hopper and her team at UNIVAC • Developed a “compiling system” named A-0, A-1, and A-2 • Programs were written in a type of code called pseudocode which was expanded into machine code subprograms

  7. Progress in Generality • 1950 • David J. Wheeler • Developed a method of using blocks of relocatable addresses. • 1951 • Maurice Wilkes • Extended this idea to design an assembly program that could combine chosen subroutines and allocate storage.

  8. Speedcode SystemSupport for Floating Point Operations • Early 1950s • John Backus • Developed a Speedcode system for the IBM 701 which extended machine code to include floating-point operations. • Instruction set included the four arithmetic operations for floating points, sqrt, sine, arc tangent, exponent and logarithm; conditional and unconditional branching; I/O conversions. • Novel facility of auto incrementing address registers. • Pure interpretation (slow -“add” took 4.2 milliseconds) • Faster coding - Matrix multiplication could be coded in 12 instructions

  9. First Real Compiler? • 1952 • Alick E. Glennie • Developed Autocode compiler for the Manchester Mark I computer • Lowlevel and machine oriented OR • 1953 • Laning and Zierler • Developed an algebraic translation system • Used function calls and included arrays and branching instructions • Implemented on the MIT Whirlwind computer • Generated a subroutine call to each formula, expression • Easy to read • Used within MIT

  10. FortranA Significant Step Up – First Important High Level Language • 1954 • IBM 704 • Provided hardware for indexing and floating point instructions • John Backus and group at IBM • Published a description of Fortran 0 • Major goal: Provide efficiency of hand-coded programs • Note: The first version of the compiler had little syntax error checking based on claims of eliminating coding errors and thus debugging • Implementation began in 1955 • Released in 1957 as Fortran I. • Types and storage for all variables fixed before run time – efficiency vs. flexibility • Included I/O formatting • Variables of up to six characters • User-defined subprograms • If and Do statements • Implicit data types – I-N for integers • 18 worker-years of effort • Huge success

  11. Artificial IntelligenceAn Influence on Programming Languages • Mid 50s • Interest in AI emerged • Natural language processing • Modeling human information storage and retrieval and other brain processes • Mechanizing certain intelligent processes such as theorem proving • These interests held a common need for processing symbolic data in lists that could be easily manipulated • linked lists vs. arrays.

  12. AI and Fortran • Mid 50s • IBM • FLPL (Fortran List Processing Language) • Extension to the Fortran compiler • Used to construct a theorem prover for plane geometry

  13. First AI Programming Language IPL - Information Processing Language • 1956 • Allen Newell, J.C. Shaw, Herbert Simon • Published a description of one of the first AI languages • IPL-I • Information Processing Language

  14. The Business Domain • 1957 • FLOW-MATIC • Business oriented language for the UNIVAC • “mathematical programs should be written in mathematical notation, data processing programs should be written in English statements” – Grace Hopper 1953

  15. The Business Domain • 1959 • COBOL 60 • Common Business Oriented Language • Design Goals • Use English as much as possible • Easy to use, even at the expense of being less powerful.. • Not be overly restricted by the problems of its implementation • Characteristics • DEFINE verb for macros • Records • 30 character names with hyphens • Data division and procedure division • Mandated by the DOD • Example on pages 65-67 • Standardized versions in • 1968; 1974 (subprograms with parameters), 1985, 2002...

  16. Fortran progresses • 1958 • Fortran II compiler • Bug fixes • Independent compilation of subprograms • Made lengthier programs possible

  17. ALGOLAlgorithmic Language • 1958 • GAMM (Society for Applied Mathematics and Mechanics) and ACM (Assoc. for Computing Machinery) • ALGOL 58 – A Universal Standard Language • Developed jointly by a committee of European and American computer scientists in a meeting in 1958 at ETH Zurich. • IAL (International Algorithmic Language vs. ALGOrithmic Language • The following people attended the meeting in Paris (from January 1 to 16): • Friedrich L. Bauer, Peter Naur, Heinz Rutishauser, Klaus Samelson, Bernard Vauquois, Adriaan van Wijngaarden, and Michael Woodger (from Europe), John W. Backus, Julien Green, Charles Katz, John McCarthy, Alan J. Perlis, and Joseph Henry Wegstein (from the USA). • Alan Perlis gave a vivid description of the meeting: "The meetings were exhausting, interminable, and exhilarating. One became aggravated when one's good ideas were discarded along with the bad ones of others. Nevertheless, diligence persisted during the entire period. The chemistry of the 13 was excellent." • Design Goals • The syntax should be as close as possible to standard mathematical notation, and programs written in ti should be readable with little further explanation • It should be possible to use the language for the description of algorithms in publications. • Programs in the new language must be mechanically translatable into machine language. • Characteristics • Machine independent • Flexible & powerful • Simple and elegant • Generalized many of Fortran’s features • Identifiers of any length; any number of array dimensions, lower bound of arrays set by programmer; nested selection statements. • Formalized the data type concept • Compound statements • := assignment operator • Both John Backus and Peter Naur served on the committee which created ALGOL 60 as did Wally Feurzeig, who later created Logo. • ALGOL 60 inspired many languages that followed it. • Tony Hoare remarked: "Here is a language so far ahead of its time that it was not only an improvement on its predecessors but also on nearly all its successors."[7]

  18. LISP • 1959 • John McCarthy and Marvin Minsky • Produced a system for list processing • LISP • A functional language • Dominated for a decade • Originally interpreted • Example diagrams and program on pages 54-55. • Decendents are: • Scheme • COMMON LISP • Related Language - ML

  19. IPL-VALGOL-60APLSNOBOLFortran IVBASICPL/ISIMULAALGOL-68 1960s

  20. Progress in AI • 1960 • Newell and Tonge • IPL-V • Demonstrated that list processing was feasible and useful. • Actually an assembly language implemented in an interpreter with list processing instructions for the Johnniac machine

  21. ALGOL 60 • 1960 • ALGOL 60 • Formally described using Backus-Naur Form • Example on pages 61-62 • New additions • Block structure concept • Pass by value and pass by name • Recursive procedures • Stack-dynamic arrays • Note that formatted I/O was omitted due to goal of machine independence • Parent • Fortran • Descendents • PL/I, SIMULA 67, C, Pascal, Ada, C++ and Java

  22. APL and SNOBOL • 1960 • APL • Kenneth Iverson at IBM • Designed for describing computer architecture • Odd character set required for operators • Expressivity vs. readability • Implemented in mid 60s • SNOBOL • D. J. Farber, R. E. Griswold, and I.P. Polonsky at Bell Labs • Designed for text processing. • Collection of powerful operations for string pattern matching • Common features • Not based on a previous language nor a basis for any languages • Dynamic typing and hence storage allocation

  23. Fortran IV • 1962 • Fortran IV • One of the most widely used PLs • Explicit type declarations for variables • Logical If construct • Capability of passing subprograms as parameters • 1966 • Fortran 66 – its Standardized version

  24. BASICLet’s make it easy… • 1963 • John Kemeny and Thomas Kurtz • Designed BASIC • Beginner’s All-purpose Symbolic Instruction Code • Goals • Must be easy for non-science students to learn and use • Must be pleasant and friendly • Must provide fast turnaround for homework • Must allow free and private access • Must consider user time more important than computer time!’ • Characteristics • Small, nonteractive • Used through terminals • Single data type – fp – numbers • Resurgence with Visual BASIC in 90s. • Example on page 69.

  25. PL/I A Single Universal Language • 1964 • IBM • Developed PL/I • Goal • Capable of both floating point and decimal arithmetic to support both scientific and business apps, as well as, support for list processing and systems programming! • Replace Fortran, LISP, COBOL and assembly languages. • Contributions • ALGOL 60’s recursion and block structure • Fortran IV’s separate compilation with communication via global data • COBOL 50’s data structures, I/O and report generating facilities • A collection of new constructs • Concurrently executing subprograms • Exception handling for 23 different types of exceptions • Allowed the disabling of recursion for more efficient linkage • Pointers as data types • References to cross sections of Arrays • Failings • “I absolutely fail to see how we can keep our growing programs firmly within our intellectual grip when by its sheer baroqueness the programming language – our basic tool, mind you! – already escapes our intellectual control.” – Edsger Dijkstra 1972 • Example on pages 74-75

  26. Simula 67 • 1967 • Kristen Nygaard and Ole-Johan Dahl • First developed SIMULA I in the early 60s • Designed for system simulation, implemented in mid-60s • Generalized into Simula 67 • Features • Extension of ALGOL 60 taking block structure and control statements • Support for coroutines via the class construct thus beginning the concept of data abstraction • Encapsulation of data and processes that manipulate the data • Class definition as a template • Constructors

  27. ALGOL 68Dramatically Different • 1968 • ALGOL 68 • Design Criteria – Orthogonality • Never achieved widespread use, but contributed several important ideas. • User defined data types • Flex arrays – Implicit heap-dynamic arrays • Orthogonality – a few primitive concepts and unrestricted use of a few combining mechanisms • Descendents – ALGOL-W • Value-result method of passing parameters as an alternative to pass-by-name • Case statement for multiple selection

  28. 1970s Pascal C Prolog Scheme Fortran 77 Ada

  29. Pascal • 1971 • Niklaus Wirth • Developed Pascal based on ALGOL 60 • Primarily used as a teaching language • Simple but expressive • Lacked essential features for many apps which led to non-standard dialects such as Turbo Pascal • Example on pages 80-81

  30. C • 1972 • Dennis Ritchie • Developed the C language • Heritage was • CPL - Cambridge early 60s • BCPL – Martin Richards 1967 • B – Ken Thompson 1970 First HLL under Unix • C • and ALGOL 68 • Example on pages 82-83

  31. Logic Languages • 1975 • Phillippe Roussel • Described Prolog • Example code on page 86

  32. Scheme A Functional Programming Language • 1975 • MIT • Scheme • Small size • Exclusive use of static scoping • Functions are first-class entities – can be values of expressions and elements of lists; assigned to variables; passed as parameters and returned as values of function applications. • Simple syntax and semantics

  33. Fortran 77 Continues to Dominate • 1978 • Fortran 77 • Character string handling • Logical loop control statements • If else • “Fortran is the “lingua franca” of the computing world..” Alan Perlis

  34. 1980s Smalltalk ADA ML Common LISP Miranda C++

  35. Smalltalk • 1980 • Alan Kay who predicted computer “desktop” windowing environment • Developed the first language that fully supported OOP as a part of the Xerox Palo Alto Research Center (PARC) group • Charged with task of designing a lanuage to support Kay’s vision. • Objects and message passing • Example on pages 93-94

  36. MetaLanguageFunctional Language Interest Continues • 1980s • Robin Milner • ML (MetaLanguage) • Functional but supports imperative • Syntax similar to imperative

  37. ADA • 1983 • DOD • Most extensive and expensive language design effort • Climate • More than 450 different languages were in use and none were standardized • Reuse and tools not feasible • High-Order Language Working Group was formed • Id the requirements for a new DoD HLL • Evaluate existing languages to determine candidate languages • Recommend adoption or implementation of a minimal set of languages • April 1975 – produced Strawman requirements docs • August 1975 – Woodenman • Jan 1976 – Tinman • Jan 1977 – Ironman • June 1978 – Steelman • July 1979 – Cii Honeywell/Bull language design was selected. • Spring of 1979 – name was adopted • 1983 – “final” official ANSI version • Features • Packages • Exception handling • Generics • Concurrency support

  38. LISP • 1984 • COMMON LISP • Designed to combine features of a number of differenct dialects of LISP that were developed during the 70s and 80s. • Large and complex • Allows both dynamic and static scoping • Basis is pure lisp

More Related