CSCI 431 -- Introduction

• Understand key issues in language design and implementation.
• Be aware of the range of available languages and their uses.
• Learn how to learn a new language.

What is a Programming Language

A language used to express instructions to a computer.

• Definition of legal Programs (Syntax)
• Meaning of a Program (Semantics)
• Style of Programming (Pragmatics)

• Example,

  Consider the following statement:

  set x[i] to x[i] + 1

  This is clearly intended to denote the increment of an array element. How would we translate this statement to a variety of different languages, and what would it mean?

  
  

  • In C (circa 1970), we would write this as

    x[i] = x[i] + 1;

  • This performs a hardware lookup for the address of x and adds i to it. The addition is a hardware operation, so it is dependent upon the hardware in question. This resulting address is then referenced (if it's legal - which it might not be), 1 is added to the bit-string stored there (again, as a hardware addition, which can overflow), and the result is stored back to that location. However, no attempt has been made to determine that x is even a vector and that x[i] is a number.

    
    

  • In Scheme (1975), this would be transcribed as

    (vector-set! x i (+ (vector-ref x i) 1))

  • This does all the things the corresponding C operation does, but in addition it also (a) checks that the object named x is indeed an array, (b) makes sure i is within the bounds of the array, (c) ensures the dereferenced location contains a number, and (d) performs abstract arithmetic (so there will be no ``overflow'').

    
    

  • Finally, in Java (circa 1991), one might write

    x[i] = x[i] + 1;

  • which looks identical to the C code. However, the actions performed are those performed by the Scheme code, with one major difference: the arithmetic is not as abstract. It is defined to be done as if the machine were a 32-bit machine, which means we can always determine the result of an operation, no matter which machine we execute the program on, but we cannot have our numbers grow arbitrarily large.

Taxonomy of Programming Languages

• Syntax and Semantics
• Elemantry Data Types
• Structured Data Types
• Sequence Control within Statements
• Sequence Control between Statements
• Sequence Control within Subprograms
• Data Control with Subprograms
• Shared Data in Subprograms

How Many Languages?

• What languages do you know?

  FORTRAN, COBOL, (Visual) BASIC, ALGOL-60, ALGOL-68, PL/I, C, C++, RPG, Pascal, Modula, Oberon, Lisp, Scheme, ML, Haskell, Ada, Prolog, Goedel, Snobol, ICON, ...

  
  

• Different applications motivate different languages:
  • numerical computation (FORTRAN)
  • computer system control (assemblies, C)
  • business applications (COBOL,PL/I)
  • database applications (SQL)
  • AI applications (LISP, Scheme)
  • PC applications (Turbo xxx or Microsoft Visual xxx)
  • client/server applications (C++, Java)
  • internet applications (Java)
  • parallel computation (FORTRAN90)
  • teaching (BASIC, PASCAL, Modula)
  • language research (ML, Prolog, Haskell)
  • text processing (tex, troff)
  • task controls (awk, perl, tcl)
  • ...

Programming Language Classifications

• Application domains:

  (seen on previous discussion)

  
  

• Abstraction Levels:
  • High level
  • Intermediate level
  • Low level

  
  

• Historical Perspective:
  • 1st generation (machine languages)
  • 2nd generation (assembly languages)
  • 3rd generation (procedural languages)
  • 4th generation (application languages)
  • ...

  
  

• Programming Paradigms (Styles):
  • Imperative
  • Object-Oriented
  • Functional
  • Logical
  • Parallel
  • others: dataflow, coordination, algebraic, graph­based, etc.
    Note: distinction is sometimes fuzzy!

``High-Level'' Programming Languages

Consider a simple algorithm for testing primality.

In Java:

public static boolean isprime (int n) {
  int d;
  for (d = 2; d < n; d++)
    if (n % d == 0)
      return false;
  return true;

In Standard ML (using a recursive function):

  fun isprime (n:int) : bool =
    let fun no_divisor (d:int) : bool =
          (d >= n) orelse
          ((n mod d <> 0) andalso
           (no_divisor (d+1)))
    in no_divisor 2
    end

In Intel X86 Assembler:

( here's a little tutorial on the I386 if you want it)

.globl isprime
isprime:
        pushl %ebp         ; set up procedure entry
        movl %esp,%ebp
        pushl %esi
        pushl %ebx
        movl 8(%ebp),%ebx  ; fetch arg n from stack
        movl $2,%esi       ; set divisor d := 2
        cmpl %ebx,%esi     ; compare n,d
        jge true           ; jump if d >= n
loop:   movl %ebx,%eax     ; set n into ....
        cltd               ; ... dividend register
        idivl %esi         ; divide by d
        testl %edx,%edx    ; remainder 0?
        jne next           ; jump if remainder non-0
        xorl %eax,%eax     ; set ret value := false(0)
        jmp done
next:   incl %esi          ; increment d
        cmpl %ebx,%esi     ; compare n,d
        jl loop            ; jump if d < n
true:   movl $1,%eax       ; set ret value := true(1)
done:   leal -8(%ebp),%esp ; clean up and exit
        popl %ebx
        popl %esi
        leave
        ret

General Characteristics of HLLs:

• Complex Expressions (Arithmetic, Logical, ...)
• Structured Control Operators (Loops, Conditionals, Cases)
• Composite Types (Arrays, Records, etc.)
• Type Declarations and Type Checking
• Multiple storage classes (global/local/heap)
• Procedures/Functions, with private scope, maybe first-class
• Maybe abstract data types, modules, objects, etc.
• Maybe high-level control mechanisms (Exceptions, Back-tracking, etc.)

Machine Code Characteristics:

• Explicit registers for values and intermediate results.
• Low-level machine instructions to implement operations.
• Control flow based on labels and conditional branches.
• Explicit memory management (e.g., stack management for procedures).

Programming Paradigms

• Imperative (Examples: FORTRAN, Pascal, C)
  • Conventional
  • Statement-oriented
  • ``Stateful''

  Example: compute m raised to the n power (n > 0)

  result := 1; 
  while n > 0 do 
     result := result * m; 
     n := n ­ 1 
  end while; 
  

  Assessment:

  • computation is expressed by repeated modification of an implicit store (i.e., components command a store modification),
  • intermediate results are held in store
  • iteration (loop)­based control
  
  
• Functional (Examples: Lisp, Scheme, ML)
  • Expression-oriented
  • No side effects
  • Organized into functions

  Example: compute m raised to the n power (n > 0)

  fun power (m,n) = 
     if (n = 0) 
        then 1 
        else m * power(m,n­1); 
  

  Assessment:

  • computation is expressed by function application and composition
  • no implicit store
  • intermediate results (function outputs) are passed directly into other functions
  • recursion­based control
  
  
• Logic (Examples: Prolog)
  • Predicate-oriented
  • Organized into relations

  Example: compute m raised to the n power (n > 0)

  /* define predicate power(m,n,result) */ 
  power(M,0,1). 
  power(M,N,Result) ->
     minus(N,1,N_Sub1), 
     power(M,N_Sub1,Temp_Result), 
     times(M,Temp_Result,Result). 
  

  Assessment:

  • computation is expressed by proof search, or alternatively, by recursively defining relations
  • no implicit store
  • all intermediate results (i.e., function outputs) are stored in variables
  • recursion­based control
  
  
• Object-Oriented (Examples: C++, Smalltalk, Java)
  • Encapsulation (of data and operations)
  • Still imperative style

  
  

• Concurrent/Parallel (Examples: CSP, FORTRAN 90)
  • Multiple threads of control
  • Synchronization
  • Communication

What Makes a Good Language?

• Ease of programming
  • increases productivity

  
  

• Efficient target code
  • often the bottom line

  
  

• High expressive power
  • enables programmer to concentrate on problem solving rather than on low-level issues

  
  

• Security (Never core dumps)
  • helps to develop more robust programs

  
  

• Fast translation
  • important for many application developments

  
  

• Portable programs
  • becoming more important with the Internet

Ease of Programming:

• Well-defined syntax (easy to read, less error-prone)
• Consistent constructs
• Proper program abstractions (subprograms, data structures, etc.)

  
  Example:

  Pascal variable declarations:

    var i : integer;
    var j : integer := 1;
    var a : array[1..5] of integer;
    var b : array[1..5] of integer := (1,2,3,4,5);
  
  
  
  
  syntax: 'var' <var_name> ':' <type> [':=' <value>] ';'
  
  
  
  
  and we can have
  
  
  
  
    type intarray = array[1..5] of integer;
    var c : intarray;
  
  
  
  
  C scalar variable declaration:
    int i;
    int j = 1;
  syntax: <type> <var> ['=' <value>] ';'
  
  
  
  
  C array variable declaration:
    int a[10];
    int b[5] = {1,2,3,4,5};
  syntax: <elm-typ> <var>
  <dim> ['=' { <array_values> } ] ';'
  
  
  
  
  and we can't use typedef to name an array type.
  
  Consistent Constructs:
  
  
  Orthogonality - The property of being able to combine
  various features in a language in all possible combinations.
  
  Combination Orthogonality: If one member of a sort S1can be combined with one member of a sort S2, the any member of a
  sort S1 can be combined with any member of a sort S2.
  
  
  Example:  ``Any kind of declaration can be used for any kind of
  type.'' 
  
  
  Number Orthogonality: In any circumstance in which one
  member of a sort S is allowed meaningfully, zero or more members of
  S are allowed meaningfully.
  
  
  Example: ``If one statement is allowed in a place, zero or more
  statements should also be allowed there.''
  
  
  
  Remarks:
  
  Orthogonality was first used explicitly in the design of Algol 68.
  C violates combination orthogonality in a number of places,
  e.g. one cannot initializing declarations of unions.
  
  

High Expressive Power:

• Advanced forms of expressions
  E.g. FORTRAN 90 array expressions: A = B + C

  
  

• Advanced program constructs
  E.g. User-level handling of exceptions (ML, Java)

  
  

• Abstract data types
  E.g. C++, Java, ML

  
  

• Polymorphism
  E.g. C++, Java, ML

  
  

• Pattern matching
  E.g. ML: merge two sorted list

    fun merge(nil,M) = M
    |   merge(N,nil) = N
    |   merge(N,M) = ...
  

  
  

• Higher order functions
  
  E.g. Lisp, Scheme, ML, ...

Language Security Concept:

A language is secure if it guarantees that programming errors cannot ``give rise to machine or implementation dependent effects, which are inexplicable in terms of the language itself.'' [C.A.R. Hoare '73]

What this means is that the behavior of any program, even one with bugs, can be understood within the framework of the language itself.

Example: C has numerous insecure features:

• referencing out-of-bound array elements
• ``dangling'' pointers
• ...

Design Issues:

• Compile-time detection and correction of as many errors as possible
• User-level handling of exceptions

Fast Translation Techniques:

• Independent Compilation -- avoiding recompiling parts of program which have not been changed since the last time.
• Incremental Compilation -- saving information about last compilation.

How to Make Programs Portable:

• Standardizing the language specification.
• Making the language specification precise.