IBU

International Burch University

CEN 332 Programming Languages

Lecture 2 – Evolution of Major Programming Languages

Assoc. Prof. Dr. Zerina Mašetić

Agenda

 Zuse’s Plankalkül
 The IBM 704 and Fortran
 Functional Programming: LISP
 The First Step Toward Sophistication: ALGOL 60
 Computerizing Business Records: COBOL
 The Beginnings of Timesharing: BASIC
 Everything for Everybody: PL/I
Agenda

 The Beginnings of Data Abstraction: SIMULA 67

 Orthogonal Design: ALGOL 68
 Some Early Descendants of the ALGOLs
 Programming Based on Logic: Prolog
 History’s Largest Design Effort: Ada
 Object-Oriented Programming: Smalltalk
 Combining Imperative and Object-Oriented Features: C++
 An Imperative-Based Object-Oriented Language: Java
 Scripting Languages
Zuse’s Plankalkül

 Designed in 1945, but not published until 1972

 Never implemented
 Advanced data structures: floating point, arrays, records
 Invariants (a function which remains unchanged when a specified transformation is applied.)
Plankalkül Syntax

 The simplest data type in Plankalkül was the single bit.

 Integer and floating-point numeric types were built from the bit type.
 Plankalkül included arrays and records (called structs in the C-based languages)
IBM 704 and Fortran

 Fortran 0: 1954 - not implemented

 Fortran I:1957
 Designed for the new IBM 704, which had index registers and floating point hardware
 This led to the idea of compiled programming languages, because there was no place to hide the cost
of interpretation (no floating-point software)
 Development environment
 Computers were small and unreliable
 Applications were scientific
 No programming methodology or tools
 Machine efficiency was the most important concern
 IBM 704

IBM 704 was programmed in

Fortran language
• had a 36 bit binary word as it’s
data
• Each 36-bit computer
instruction contained 1 or 2
address fields of 15 bits, so that
the full 32K, 36-bit word
memory could be addressed
directly.

The 704 Main Console (Lee Jennings)

IBM 704

64K Magnetic core memory stacks ((Lee Jennings)

Fortran I Overview

 First implemented version of Fortran

 Names could have up to six characters
 Post-test counting loop (DO)
 Formatted I/O
 User-defined subprograms
 Three-way selection statement (arithmetic IF)
 No data typing statements
Fortran I Overview

 First implemented version of Fortran

 No separate compilation
 Compiler released in April 1957
 Programs larger than 400 lines rarely compiled correctly mainly due to poor reliability of 704
Fortran II

 Distributed in 1958
 Independent compilation
 Fixed the bugs
Fortran IV

 Evolved during 1960-62

 Explicit type declarations
 Logical selection statement
 Subprogram names could be parameters
Fortran 77

 Became the new standard in 1978

 Character string handling
 Logical loop control statement
 IF-THEN-ELSE statement
Fortran 90

 Most significant changes from Fortran 77

 Modules
 Dynamic arrays
 Pointers
 Recursion
 CASE statement
 Parameter type checking
Latest versions of Fortran

 Fortran 95 – relatively minor additions, plus some deletions

 Fortran 2003 – suppport for OOP, procedure pointers, interoperability with C
 Fortran 2008 – blocks for local scopes, co-arrays, Do Concurrent
Fortran 95
Functional Programming: LISP

 LISt Processing language

 Designed at MIT by McCarthy

 AI research needed a language to

 Process data in lists (rather than arrays)
 Symbolic computation (rather than numeric)

 Only two data types: atoms and lists

Representation of Two LISP Lists

 Representing the lists (A B C D) and (A (B C) D (E (F G)))

LISP Evaluation

 Pioneered functional programming language

 No need for variables or assignment
 Control via recursion and conditional expressions

 Still the dominant language for AI

 COMMON LISP and Scheme are contemporary dialects of LISP
 ML, Haskell, and F# are also functional programming languages, but use very different
syntax
Lisp
The First Step Toward Sophistication:
ALGOL 60
 Environment of development
 FORTRAN had (barely) arrived for IBM 70x
 Many other languages were being developed, all for specific machines
 No portable language; all were machine dependent
 No universal language for communicating algorithms
The First Step Toward Sophistication:
ALGOL 60
 ALGOL 60 was the result of efforts to design a universal language
 ACM and GAMM met for four days for design (May 27 to June 1, 1958)
 Goals of the language
 Close to mathematical notation
 Good for describing algorithms
 Must be translatable to machine code
ALGOL 58

 Concept of type was formalized

 Names could be any length
 Arrays could have any number of subscripts
 Parameters were separated by mode (in & out)
 Subscripts were placed in brackets
 Compound statements (begin ... end)
 Semicolon as a statement separator
 Assignment operator was :=
 if had an else-if clause
 No I/O - “would make it machine dependent”
ALGOL 60 Overview

 Modified ALGOL 58 at 6-day meeting in Paris

 New features
 Block structure (local scope)
 Two parameter passing methods
 Subprogram recursion
 Stack-dynamic arrays
 still no I/O and no string handling
ALGOL 60 Evaluation

 First machine-independent language

 First language whose syntax was formalized
 Never widely used, especially in U.S.
 Lack of I/O and the character set made programs non-portable
 Too flexible--hard to implement
 Lack of support from IBM
Computerizing Business Records: COBOL

 COBOL: common business-oriented language

 compiled English-like computer programming language designed for business use
 First Design Meeting (Pentagon) - May 1959
 Design goals
 Must look like simple English
 Must be easy to use, even if that means it will be less powerful
 Must broaden the base of computer users
 Must not be biased by current compiler problems
Computerizing Business Records: COBOL

 Design committee members were all from computer manufacturers and DoD branches
 It was created as part of a US Department of Defense effort to create a portable
programming language for data processing.
The Beginning of Timesharing: BASIC

 Beginner’s All-purpose Symbolic Instruction Code

 Design Goals:
 Easy to learn and use for non-science students
 Must be “pleasant and friendly”
 Fast turnaround for homework
 Free and private access
 User time is more important than computer time

 Current popular dialect: Visual BASIC

BASIC
Everything for Everybody: PL/I

 Designed by IBM and SHARE

 Computing situation in 1964 (IBM's point of view)
 Scientific computing
 IBM 1620 and 7090 computers
 FORTRAN
 SHARE user group
 Business computing
 IBM 1401, 7080 computers
 COBOL
 GUIDE user group
PL/I: Background

 By 1963
 Scientific users began to need more elaborate I/O, like COBOL had; business users began to need
floating point and arrays for MIS
 It looked like many shops would begin to need two kinds of computers, languages, and support
staff--too costly
 The obvious solution
 Build a new computer to do both kinds of applications
 Design a new language to do both kinds of applications
PL/I: Design Process

 Designed in five months by the 3 X 3 Committee: three members from IBM, three
members from SHARE
 Initial concept: an extension of Fortran IV
 Initially called NPL (New Programming Language)
 Name changed to PL/I in 1965
PL/I: Evaluation

 PL/I contributions
 First unit-level concurrency
 First exception handling
 Switch-selectable recursion
 First pointer data type
 Concerns
 Many new features were poorly designed
 Too large and too complex
The Beginning of Data Abstraction:
SIMULA 67
 Designed primarily for system simulation in Norway by Nygaard and
Dahl
 Based on ALGOL 60 and SIMULA I
 Coroutines - a kind of subprogram
 Classes, objects, and inheritance
Orthogonal Design: ALGOL 68

 Contributions
 User-defined data structures
 Reference types
 Dynamic arrays (called flex arrays)
 Comments
 Less usage than ALGOL 60
 Had strong influence on subsequent languages, especially Pascal, C, and Ada
Pascal - 1971

 Developed by Wirth (a former member of the ALGOL 68 committee)

 Designed for teaching structured programming
 Small, simple, nothing really new
 Largest impact was on teaching programming
 From mid-1970s until the late 1990s, it was the most widely used language for teaching
programming
Pascal
C - 1972

 Designed for systems programming (at Bell Labs by Dennis Richie)

 Powerful set of operators, but poor type checking
 Though designed as a systems language, it has been used in many application areas
C
Programming Based on Logic: Prolog

 Based on formal logic

 Non-procedural
 Can be summarized as being an intelligent database system that uses an inferencing
process to infer the truth of given queries
 Comparatively inefficient
 Few application areas
Prolog
History’s Largest Design Effort: Ada

 The Ada language was developed for the Department of Defense (DoD)
 Huge design effort, involving hundreds of people, much money, and about eight years
 Named Ada after Augusta Ada Byron, the first programmer
Ada Evaluation

 Contributions
 Packages - support for data abstraction
 Exception handling
 Generic program units
 Concurrency - through the tasking model
 Comments
 Competitive design
 Included all that was then known about software engineering and language design
 First compilers were very difficult; the first really usable compiler came nearly five years after the
language design was completed
Ada
Ada
Ada 95

 Ada 95 (began in 1988)

 Support for OOP through type derivation
 Better control mechanisms for shared data
 New concurrency features
 More flexible libraries
 Ada 2005
 Interfaces and synchronizing interfaces
 Popularity suffered because the DoD no longer requires its use but also because of
popularity of C++
Object-Oriented Programming:
Smalltalk
 Developed at Xerox PARC, initially by Alan Kay, later by Adele Goldberg
 First full implementation of an object-oriented language (data abstraction,
inheritance, and dynamic binding)
 Pioneered the graphical user interface design
 Promoted OOP
Smalltalk
Combining Imperative and Object-Oriented
Programming: C++
 Developed at Bell Labs in 1980
 Evolved from C and SIMULA 67
 Facilities for object-oriented programming, taken partially from SIMULA 67
 A large and complex language, in part because it supports both procedural and OO
programming
 Rapidly grew in popularity along with OOP
Related OOP Languages

 Objective-C (designed by Brad Cox – early 1980s)

 C plus support for OOP based on Smalltalk
 Uses Smalltalk s ’s method calling syntax
 Used by Apple for systems programs
 Delphi
 Pascal plus features to support OOP
 More elegant and safer than C++
 Go (designed at Google - 2009)
 Loosely based on C, but also quite different
 Does not support traditional OOP
An Imperative-Based Object-Oriented
Language: Java
 Developed at Sun in the early 1990s
 C and C++ were not satisfactory for embedded electronic devices
 Based on C++
 Significantly simplified (does not include struct, union, enum, pointer arithmetic, and half of the
assignment of C++)
 Supports only OOP
 Has references, but not pointers
 Includes support for applets and a form of concurrency
Java Evaluation

 Eliminated many unsafe features of C++

 Supports concurrency
 Libraries for applets, GUIs, database access
 Portable: Java Virtual Machine concept
 Widely used for Web programming
 Use increased faster than any previous language
Java
Java
Scripting Languages for the Web

 Perl
 Designed by Larry Wall—first released in 1987
 Variables are statically typed but implicitly declared
 Three distinctive namespaces, denoted by the first character of a
variable’s name
 All scalar variable names begin with dollar signs ($),
 All array names begin with at signs (@), and
 All hash names begin with percent signs (%)
Scripting Languages for the Web
 Perl
Scripting Languages for the Web

 JavaScript
 Began at Netscape, but later became a joint venture of Netscape and Sun Microsystems
 A client-side HTML-embedded scripting language, often used to create dynamic HTML
documents
 Purely interpreted
 Related to Java only through similar syntax
Scripting Languages for the Web

 PHP
 PHP: Hypertext Preprocessor, designed by Rasmus Lerdorf
 A server-side HTML-embedded scripting language often used for form,
processing and database access through the Web
 Purely interpreted syntax
Scripting Languages for the Web

 Python
 An OO interpreted scripting language
 Supports lists tuples and hashes
Scripting Languages for the Web

 Ruby
 Designed in Japan by Yukihiro Matsumoto (a.k.a, “Matz”)
 Began as a replacement for Perl and Python
 A pure object-oriented scripting language
 All data are objects
 Most operators are implemented as methods, which can be redefined by user code
 Purely interpreted
Scripting Languages for the Web

 Lua
 An OO interpreted scripting language
 Supports lists tuples and hashes all with its single data structure
 Easily extendable
TASK:
 Select one of the programming languages listed below:
 Perl
 Algol 60
 Simula 67
 Go
 Delphi
 FLOW-MATIC
 COBOL 60
 Scheme
 C#
 Lua
 Haskell
 Prolog
TASK:

 Explore it and find out following:

 When was it developed, by whom, why there was a need for it, what were the main features of it,
how the syntax looked like.