Chapter 2: Evolution of Major Programming Languages

1
Chapter 2 Evolution of Major Programming
Languages

• Short review of important programming languages

2
Brief summary of following languages
3
Ada

• Ada is a large and powerful language based on
  pascal. It includes features to support data
  abstraction and concurrency.
• An Ada is a collection of modules (subprograms or
  packages).
• A package is in two parts a specification which
  gives its interface with the rest of the program,
  a hidden implementation part.
• Data types integer, float, character, Boolean
  and string.
• Type checking Ada is strong typed.

4
C

• C is a system programming language.
• C programs are comparable in efficiency to
  assembly language programs.
• The source text of a C program can be distributed
  among several files, each of which can be
  compiled independently.
• Full type checking is not possible.
• The predefined data types are int, char and float
  together with short and long and double.
• User-defined types are enumeration types, arrays
  and structure.
• No concurrency support directly.

5
C

• C was designed to add object-oriented features
  to C.
• Classes support the decomposition of large
  program into self-contained units.
• Derived classes inherit the properties of a base
  class which they can extend through the
  definition of a new, or redefinition of existing,
  data and function members.
• Dynamic binding is supported.
• Type checking is supported.
• No concurrency support directly.

6
COBOL

• COBOL is the most extensively used programming
  language in data processing and is oriented to
  deal with large files of data.
• A COBOL program is divided into four divisions.
  IDENTIFICATION DIVISION, provides essential
  program documentation the ENVIRONMENTAL DIVISION
  contains machine-dependent program specifications
  relating logical and physical entities the DATA
  DIVISION describes the data and its structure
  and finally, the PROCEDURE DIVISION gives the
  algorithms.
• The basic data types are character strings and
  numbers whose precision is defined by the
  programmer in DATA DIVISION. Array exist, but the
  main structure variable are record.
• Dynamic data structure are not supported.
• Implicit type checking are an integral part of
  COBOL, little type checking is possible.

7
Eiffel

• Eiffel is an object-oriented language that
  combines dynamic binding and static type
  checking.
• Programs are composed of class definitions. The
  equivalent of a main program is the create
  feature of the root class.
• Simple data types such as integer, real,
  character and boolean are built in. All other
  types are defined using classes and are accessed
  via pointer.
• Strongly typed checking.
• No Concurrency support.

8
FORTRAN

• FORTRAN is still widely used for numerical
  applications by scientists and engineers.
• Recursion is not supported.
• INTEGER, REAL, DOUBLE PRECISION, LOGICAL, and
  CHARACTER.
• Supported type checking.
• Array can be passed as parameters.
• No concurrency support.

9
LISP

• LISP is primarily used in artificial intelligence
  applications and although it is not a purely
  functional language it has all the features
  needed for functional programming.
• The object manipulation in the language are
  expression, which can be lists, atoms or
  function.
• Dynamic type checking.
• Recursion is used instead of iteration.
• No concurrency support.

10
Prolog

• PROLOG is a logic programming language.
• A PROLOG program consists of a database of facts
  and a series of rules.
• PROLOG has atoms,numbers and structures are data
  types.
• It is dynamic typed.
• Structure (which are similar to record in pascal)
  
• No concurrency support.

11
Smalltalk

• Object-oriented language. It is not just
  language, but is a complete programming
  environment.
• Supports information hiding. Data local to an
  object.
• The only data type is the object. Object belong
  to a class, which is itself an object.
• When message are sent to an object, the required
  method is selected dynamically at run time.
• A concurrency is supported by collection of
  concurrent object that communicate with one
  another by sending messages.