chapter 2
Post on 14-Jan-2016
43 Views
Preview:
DESCRIPTION
TRANSCRIPT
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
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.
Compiling systems
Relocatable code
Assembly languages
Fortran 0, I, II
AI – FLPL; IPL-I, LISP
Business – Flowmatic & COBOL
ALGOL
1950s
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
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
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.
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
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
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
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.
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
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
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
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...
The Business Domain
Fortran progresses
1958 Fortran II compiler
– Bug fixes– Independent compilation of subprograms
Made lengthier programs possible
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]
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
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
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
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
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
BASICLet’s make it easy…
1963 John Kemeny and Thomas Kurtz
– Designed BASIC Beginner’s All-purpose Symbolic Instruction Code
– Goals1. Must be easy for non-science students to learn and use2. Must be pleasant and friendly3. Must provide fast turnaround for homework4. Must allow free and private access5. 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.
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
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
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
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
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
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
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
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
MetaLanguageFunctional Language Interest Continues
1980s Robin Milner
– ML (MetaLanguage) Functional but supports imperative Syntax similar to imperative
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
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
Miranda
1984 David Turner
– Miranda Based on ML, SASL, and KRC Functional, no variables, no assignment statement Haskell is based on Miranda
– But has the unique feature of lazy evaluation - No expression is evaluated until its value is required
C++
Bjarne Stroustrup at Bell Labs– Made the first step from C to C++ with C with Classes language int 1983– Goals
provide a language with classes and inheritance No performance penalty – reason array index range checking was not considered It could be used for every application ofr which C was used – so left unsafe features of C
– Progression 1980
– Addition of function parameter tyep checking and conversion– Classes like those of SIMULA 67 and Smalltalk– Derived classes, public/private access, constructors/destructors, friends.
1981– Inline functions, default parameters, overloading
– 1984 Named C++ - virtual methods, dynamic binding of method calls to method definitions, reference types
– 1985 First available implementation named Cfront which translates C++ programs into C programs Continued to evolve
– multiple inheritance, abstract classes– Templates which provide parameterized types and exception handling– 2002 - .NET
Fortran 90
1990 Fortran 90
– Dynamic arrays– Records– Pointers– Multiple selection statement– Modules– Recursion– Obsolescent-features list– Dropped fixed format of code requirement– Fortran vs. FORTRAN– Convention – keywords & identifiers in uppercase
ADA 95
Features– Adding new components to those inherited from a base
class.– Dynamic binding of subprogram classes to subprogram
definitions (polymorphism)– Protected objects
Success hindered by C++
Scripting Languages
Sh (shell) – a small collection of commands interpreted as calls to system subprograms to perform utility functions with added varaibels, control flow statements, functions andetc
– Ksh – David Korn ’95 Awk – Al Aho, Brian Kernighan, Peter Weinberger
(’88) began as a report generation language Tcl – John Ousterhout ’94 Perl – Larry Wall – designed as a UNIX tool for
processing text files. Common Gateway Interface language as well.
Scripting Languages
Perl – Larry Wall – Combination of sh and awk– Statically typed variables - $ scalar; @ arrays; % hash
names– Arrays can be dynamic and sparse– Some dangers
If a string is used in a numeric context and teh string cannot be converted to a number, zero is used without warning
Array indexing cannot be checked since there is no set subscript range. References to non-existent elements return undef, which is interpreted as 0 in numeric context.
Fortran 2003
2003 Fortran 2003
– Parameterized derived types– OOP support– Procedure pointers– C interoperability
top related