Home Page Syllabus Marcin Paprzycki


      CSC 408 PROGRAMMING LANGUAGES

      Material covered:

      Why a course about Programming Languages should be a part of the CS curriculum?

        understanding of languages
        better utilization of languages
        better selection of a "language for a job"
        to learn additional languages easier
        to understand significance of implementation
        to design a language(?)

      What factors influence language design?

        available computer hardware
        programming domains
          scientific computing
          business applications
          artificial intelligence
          system software
          application software
          special purpose
          Internet/multimedia
        theoretical studies
        standardization

      Programming language evaluation criteria:

        1. Clarity simplicity and unity
          clarity of syntax
            length of names of variables
            status of special words
            relation between syntax and meaning
          readability (how many comments necessary to understand?)
          formalization of concepts (precision of definition)
          availability of structured programming, OO programming structures
          created once, or a "victim" of evolution?
        2. Match between the language and the application that it is to be used for
        3. How good is the definition of implementation
          how were the imprecisions inthe language definition "fixed"?
          are there any special features that a vendor added to the language?
          what will the optimizing compiler do to your code?
        4. Portability
        5. Cost
          learning curve
          compilation and loading (rather old criterion, but...)
          creation, verification and testing (editors, debuggers, visual tools)
          execution (how good is the compiler/interpreter)
          maintenance
        6. Availability of "canned" library procedures/modules, software reuse support.

      HOMEWORK 1

      Use the above programming language evaluation criteria to evaluate your favorite programming language. Be fair, but critical. Should the list of criteria be extended?
      Due by: Wednesday, January 24th

      Material covered (continued):

      Programming Early Computers:

        limited memory
        slow machines
        extremely tight coding

        floating point opertions emulated
        lack of indexing operations
        invention of early interpreters and proto-compilers


      Design of Pseudo-Code
        necessary operations
        instruction format
        orthogonal design
        program structure

      Implementation
        the read-execute cycle
        decoding instructions

      Evolution of pseudo-code
        labels
        variables
        symbolic pseudo-code

      Evaluation and summary of the earliest developments in programming languages

      HOMEWORK 2
      Textbook, page 37, problem 8
      Due by: Wednesday, February 7th

      Material covered (continued):

      Fortran

      origins of Fortran
      modularity of design -- subprograms
      compilation and its phases
      control structures

        match between control structures and IBM 704 machine language
        GOTO and its forms
        IF statements
        DO loops and their optimization
      subroutines as abstractions
        address based parameter passing
        activation records
      data structures
        numeric data types and operations
        pseudo-strings
        arrays
        array optimizations
      name structures
        bindings
        declarations
        scope
        information sharing
          parameters
          COMMON blocks
          EQUIVALENCE
      syntactic structures
        format
        reserved words
        algebraic notation and precedence

      Evaluation and summary of the importance and reasons for vitality of Fortran

      HOMEWOK 3
      Textbook, page 93, problem 11 or 12 or 13 (select on of them)
      Due by: Wednesday, February 28th


      Material covered (continued):

      Algol

      origins of Algol
      structural organization
        hierarchical structure
        control structures
      name structures
        blocks and their features
        scoping
      data structures
        primitives
        zero-one-infinity principle and its implications
        dynamic arrays
        strong typing
      control structures
        hierarchy and generalization
        information sharing
          passing by value
          passing by reference
          passing by name
        overgeneralizations
        switch

      HOMEWOK 4
      Textbook, page 140, problem 4
      Due by: Wednesday, March 21st

      Material covered (continued):

      syntactic issues
        free format
        three levels of representation

      Evaluation and summary of the importance and reason of disappearance of Algol

      Pascal
      Historical perspective
      Simplicity as the guiding principle
      Structural organization --> similar to Algol
      New date structures:

        Enumerations
        Subranges
        Sets
        Records and variant records
        Pointers
      Name structures:
        Constants
        User defined data types and their instantiations
      Control structures:
        Simplified for-loop
        While and repeat loops
        Case statement
        Parameter passing
      Evaluation and closure

      Implementation of Block-Structured Languages
      Activation record and context
      Local context
      Nonlocal context
      Address of a variable
      Access to a variable
      Procedure call and return

      Ada
      Historical perspective
      Syntax similar to other languages
      Fully bracketed syntax
      Data types:

        Generalized numerics
        Name equivalence
        Subtypes
        Derived types
        Constraints
      Name structures:
        Specifications and definitions
        Subprogram specifications
        Global variables become harmful
          side effects
          indiscriminate access
          vulnerabilitybr> overlapping definitions
        Ada solution
        Packages
      Control structures:
        Iterator
        Exceptions
        Parameter specification
        Concurrency
        Task synchronization
      Ada evaluation and conclusion

      LISP
      Historical perspective
      Language for AI --> main goal --> flexibility
      Functional language --> everything is a function
      Everything is a list
      Program can be its own data --> self modification
      Primitives:

        numeric atoms
        non-numeric atoms
        lists
      Basic operations
        Car
        Cdr

      Reading assignment - pages vii-323