Introduction - Why 380??

  1. Increased capacity to express ideas.
  2. Improved background for choosing languages.
  3. Increased ability to learn languages.
  4. Understanding of significance of implementation.
  5. Ability to design new languages.
  6. Overall advancement of computing.

Language Evaluation Criteria

  1. Criteria
    1. Readability
    2. Writability / Expressiveness
    3. Reliability
    4. Cost

  2. Affected by
    1. Simplicity
    2. Orthogonality
    3. Data types and structures
    4. Syntax
    5. Support for Abstraction
    6. Type checking
    7. Exception handling
    8. Aliasing
    9. Control structures
    10. Expressivity

Criteria: Readability & Writability

  1. Simplicity

    1. Small number of basic components

    2. One syntax :: one meaning

      • Increment x with x++; x=x+1; x+=1; ++x;

      • Y=SUM(I,J); Array or function ???

      • Perl deliberately violates

  2. Orthogonality

    1. Any composition of basic primitives is allowed.

    2. Need small set of primitives and ways to combine them

    3. Violation: Out parameters for functions
    4. Violation: Return types for functions
    5. Violation: Functions as first-class objects

    6. Non-orthogonal often to simplify implementation

    Criteria: Readability & Writability (Cont.)

  3. Control Statements/Constructs

    Which control mechanisms to include?

  4. Data Types

    * Primitive (e.g. boolean, char, unsigned)

    * Structured

    * Provide abstraction.

  5. Syntax

    * Matters more than you think!

    * Identifier length, reserved words, layout, etc.

  6. Abstraction

    * Hide details to manage complexity!

    * Process abstraction

    * Data abstraction

Criteria: Reliability

  1. Performs to specifications under all conditions
  2. Impacted by:

    1. Type checking
      1. compile-time
        • type inference
      2. runtime
      3. none

    2. Exception handling

    3. Aliasing (i.e. Two or more names for same memory cell), for example: 
      p,q: access Integer;

p := new Integer;
q := p;

Criteria: Cost

  1. Programer training
  2. Program writing
  3. Program compilation
  4. Program execution (speed and size)
  5. Liability
  6. Tool availability
  7. Application
  8. Programmer availability
  9. Support for language
  10. Compiler and tool cost
  11. Maintenance time (>50%!)

Writability & readability are critical!

Influences on language design

von Neumann Architecture

  1. von Neumann arch: Memory, I/O, CPU (ALU and CU)

  2. Program execute via the fetch-execute cycle:
    1. control fetches next instruction from memory
    2. control decodes instruction
    3. control causes instruction to be executed:

  3. Kinds of instruction:
    1. arithmetic
    2. comparison
    3. branch
    4. move data from memory to/from ALU
    5. I/O

  4. Reflected in imperative languages:
    1. Sequential execution of instructions
    2. Branches (conditional and unconditional) to modify control flow
    3. Modifiable memory locations (variables)

  5. Related issues/question:

Programming Methodologies

Programming domains


Language Paradigms

Evolution of Imperative Languages


Control Abstraction


Data Abstraction

[LaTeX -> HTML by ltoh]
Dr. Okie's Home Page