CSU660 Programming Languages	(4 SH)

 

 
Introduces a systematic approach to understanding the behavior of
programming languages. Covers interpreters; static and dynamic scope;
environments; binding and assignment; functions and recursion;
parameter-passing and method dispatch; objects, classes, inheritance,
and polymorphism; type rules and type checking; concurrency.

 

 
CSU370, CSU390.

 

 
Friedman, Wand, and Haynes, Essentials of Programming Languages, 2nd
ed, MIT Press, 2001.

Sethi, Programming Languages: Concepts and Constructs, Second Edition,
Addison Wesley, 1996

Mitchell, J., Concepts in Programming Languages,  Cambridge University
Press, 2001.

 

 
Syntax and semantics
    compile time vs. run time
    lexical and grammatical structure
    declaratiions, expressions, statements
    grammars and interpreters as specification mechanisms

Scope and Environments
    scope, binding, and extent
    static vs dynamic scope
    scope rules in languages without block structure

Assignment and the Store
    binding vs. assignment

Functions and Recursion
    closures
    parameter-passing:  call-by-value, call-by-reference, call-by-name

Object-Orientation
    objects, classes, inheritance
    dynamic dispatch
    subtype polymorphism

Types
    types as invariants
    structural vs. nominal type systems
    type checking

Concurrency
    interleaving vs. concurrency
    shared-memory vs. message-passing
    mutual exclusion and synchronization

Rudiments of Language Runtimes
    stack vs heap
    garbage collection

All of these topics should be illustrated with examples in a variety
of languages, including a discussion of why particular design choices
were adopted for particular languages.

 

 
Upon completion of this course, a student should

    be able to read a manual for a new programming language and
    understand its basic concepts.

    understand the main tradeoffs associated with major language design
    decisions.

    be able to write an interpreter for a toy language in a high-level
    language like Scheme.


    be able to design a small domain-specific language (e.g. a language
    for a Unix dotfile).

    understand the basic structure of typical language runtimes.

    it is not expected that the student be able to program in a variety
    of languages; rather, the student should be equipped to learn how
    to program in a new language.

 

 
The course outcomes will be measured and verified by:
    Programming homeworks (five to ten recommended)
        It is recommended that several of the assignments be
        	graded by reading the code, not just by executing it.
        It is recommended that the homeworks NOT require large
        	quantities of code (eg more than 100-200 lines per week); the
        	emphasis should be on understanding, not volume.
     Written homeworks (optional at discretion of instructor)
         Inline documentation should always be required as part of
         the coding standards.
     Quizzes (optional at discretion of instructor)
     Major exams during the term (optional at discretion of instructor)
     Final exam (optional at discretion of instructor)
     Electronic portfolio (optional at discretion of instructor)

 

 
This course should prepare students to learn any new languages they
may have to use on their coop assignments.