CS4337 ch02 Evolution of the Major Programming Languages

Chapter 2: Evolution of the Major Programming Languages

Chapter 2 Topics

  • 2.2 – Minimal Hardware Programming: Pseudocodes

  • 2.3 – The IBM 704 and Fortran

  • 2.4 – Functional Programming: LISP

  • 2.5 – The First Step Toward Sophistication: ALGOL 60

  • 2.6 – Computerizing Business Records: COBOL

  • 2.7 – The Beginnings of Timesharing: BASIC

  • 2.8 – Everything for Everybody: PL/I

  • 2.9 – Two Early Dynamic Languages: APL and SNOBOL

  • 2.10 – The Beginnings of Data Abstraction: SIMULA67

  • 2.11 – Orthogonal Design: ALGOL 68

  • 2.12 – Some Early Descendants of the ALGOLs

  • 2.13 – Programming Based on Logic: Prolog

  • 2.14 – History's Largest Design Effort: Ada

  • 2.15 – Object-Oriented Programming: Smalltalk

  • 2.16 – Combining Imperative and Object-Oriented Features: C++

  • 2.17 – An Imperative-Based Object-Oriented Language: Java

  • 2.18 – Scripting Languages

  • 2.19 – The Flagship .NET Language: C#

  • 2.20 – Markup/Programming Hybrid Languages

Genealogy of Common Languages

  • FLOW-MATIC (1957)

  • Fortran I (1958)

  • Fortran II (1958)

  • ALGOL 58 (1959)

  • LISP (1959)

  • ALGOL 60 (1960)

  • APL (1960)

  • COBOL (1960)

  • Fortran IV (1961)

  • SIMULA I (1962)

  • CPL (1964)

  • BASIC (1964)

  • PL/I (1964)

  • SNOBOL (1965)

  • ALGOL W (1966)

  • SIMULA 67 (1967)

  • ALGOL 68 (1968)

  • BCPL (1967-1969)

  • Pascal (1970)

  • Prolog (1972)

  • Scheme (1975)

  • MODULA-2 (1978)

  • Fortran 77 (1978)

  • C (1972)

  • C++ (1980)

  • And many more until Fortran 2008 and subsequent versions.

Minimal Hardware Programming

Issues with Machine Code

  • Poor Readability: Difficult for humans to understand.

  • Poor Modifiability: Hard to change or update code.

  • Tedious Expression Coding: Complicated and time-consuming.

  • Machine Deficiencies: Limited capabilities like no indexing or floating point.

Pseudocode Development

Short Code

  • Developed by John Mauchly in 1949 for BINAC computers.

  • Codes expressions using byte-pair values.

  • Example given for coding a basic arithmetic operation.

Speedcoding

  • Introduced in 1954 by Backus for IBM 701.

  • Features included pseudo ops for various functions and conditional branching.

  • Though innovative, it had limitations in memory usage.

The IBM 704 and Fortran

Fortran Development

  • Fortran 0 (1954) - not implemented, Fortran I (1957) - designed for the IBM 704 with significant features like index registers and floating-point hardware.

  • Early development environment faced challenges like small unreliable computers, leading to an emphasis on machine efficiency.

  • It led to the concept of compiled programming languages, as interpretation costs could not be hidden.

Fortran I Overview

  • Characteristics included a six-character name limit and post-test counting loops.

  • Featured formatted input/output and arithmetic IF statements, with implicit data types based on variable names.

  • Overcame early compilation issues, gained rapid adoption despite initial limitations.

Evolution of Fortran

  • Fortran II fixed early bugs and enabled independent compilation.

  • Fortran IV (1960-62) introduced explicit type declarations and logical selection statements.

  • Fortran 77 became the standard in 1978, adding features for string handling and control.

  • Significant updates followed with Fortran 90, 95, 2003, and others into 2023, expanding capabilities in modules, pointers, and object-oriented programming.

Functional Programming: LISP

  • Developed at MIT by John McCarthy to support AI research.

  • Focused on list processing rather than arrays and emphasized symbolic computation with only two data types: atoms and lists.

  • Pioneered functional programming with recursion and conditional expressions, lacking variables and assignments.

  • Dialects include COMMON LISP and Scheme, while others like ML and Haskell emerged, focusing on different syntax and styles.

The First Step Toward Sophistication: ALGOL 60

  • Developed as a machine-independent language for communicating algorithms.

  • Introduced a block structure with local scope and recursion but lacked I/O handling.

  • It succeeded in publishing algorithms widely but fell short on practical usage due to lack of I/O and portability issues.

Computerizing Business Records: COBOL

  • Development sparked by the need for an English-like language for business applications, evolving from FLOW-MATIC.

  • Pioneered features like named operators and a focus on data separation.

  • First language mandated by the Department of Defense.

The Beginning of Timesharing: BASIC

  • Designed to be user-friendly for non-science students with goals of fast, pleasant interactions.

  • Created for easy access and rapid programming turnaround.

  • Led to the widespread use of timesharing systems.

PL/I: Everything for Everybody

  • Addresses the needs of scientific and business applications with a unified design.

  • Merged Fortran and COBOL features into a single language for cost efficiency.

Evaluation of Programming Languages

Key Contributions

  • LISP: Pioneered functional programming and garbage collection.

  • COBOL: Advanced data structures and programming flexibility.

  • ALGOL 60: Set the standard for many modern languages despite its limited use.

Conclusion

  • This chapter emphasizes the evolution of programming languages from early machine code to sophisticated modern languages.

  • Each significant language brought unique contributions that influenced future developments in syntax, functionality, and design.