Statement of Course Outcomes


Course Number: CS 510


Course Name: Principles of Programming Languages


Course Coordinator: Adriana Compagnoni


Graduate or Undergraduate Equivalent: CS 496


Catalog Description: Principles of functional, imperative, and object-oriented programming languages; elements of language theory; the typed-l calculus, functional languages, and stack implementation of recursion; imperative languages, block structure, and more on stack allocation model; user-defined types, heap storage model; and object-oriented languages, data abstraction, genericity, polymorphism, and inheritance. Case studies may include Algol, Pascal, Ada, LISP, Scheme, Smalltalk, Java, and C++. Prerequisites: MA 502 and CS 590.

Course Outcomes: The graduate of this course will be prepared to:


Each course outcome is followed in parentheses by the Program Outcome to which it relates.



  1. [inheritance] Explain the difference between implementation and interface, and between inheritance and subtyping, using object-oriented languages such as Java and C++ as examples (core:software).

  2. [trees] Structure a labeled tree data structure, such as an abstraction syntax tree, using (Scheme or ML) datatypes, C unions, dynamic typing in an object-oriented language, and abstract base classes and derived concrete subclasses (core:software)

  3. [abstract-syntax] Implement a recursive program such as an interpreter using interfaces, classes, inheritance, subtyping, and dynamic typing where necessary (core:software).

  4. [polymorphism] Explain the difference between subtype and parametric polymorphism, using Java as an example (core:software).

  5. [visitor] Use the visitor pattern and the subject-observer pattern in structuring object-oriented programs (core:software).

  6. [recursive-programming] Implement recursive programs in the Scheme language to manipulate data structures such as lists and trees (core:software,core:math-stat).

  7. [recursion-and-induction] Explain the relationship between inductively defined data types, recursive programs that process inputs of those data types, and inductive arguments about the correctness of those programs using induction over data types (core:math-stat).

  8. [scoping] Explain the difference between static and dynamic scoping rules in programming languages, and the use of environments and closures to realize these scoping rules, where appropriate (core:runtime).

  9. [interpreter] Implement an interpreter for a language that has static and dynamic scoping, and potentially extensions such as call-by-name and lazy data constructors (core:runtime).

  10. [parameter-passing] Explain parameter-passing mechanisms such call-by-value, call-by-result, call-by-value-result, call-by-reference, call-by-name and call-by-need (lazy evaluation); and be able to reason about the behavior of programs that use those conventions (core:runtime).

  11. [exceptions] Explain what exceptions and exception handlers are, and what the rationale is for their scoping rules (core:runtime).

  12. [type-systems] Define type systems as inductive rule definitions, and reason about well-typedness of programs using those type systems (core:math-stat).

  13. [type-inference] Explain the difference between type checking and type inference, and be able to derive inferred types for simple (ML) programs (core:runtime).

  14. [unification] Explain what the unification problem is and how the Robinson unification algorithm works, including the significance of the occurs check; and show the result of running the algorithm on example unification problems (core:runtime).

  15. [logic-programming] Write simple Prolog programs, and simulate their execution using SLD-resolution (core:runtime).