Computing That Serves

CS 330

Course Offerings

Section # Semester Instructor Website Description
1 Winter 2018 Bryan Morse
2 Winter 2018 Bryan Morse
Section # Semester Instructor Website Description
1 Winter 2018 Bryan Morse
2 Winter 2018 Bryan Morse
1 Fall 2017 David Wingate
2 Fall 2017 David Wingate
1 Winter 2017 David Wingate
1 Fall 2016 David Wingate Taught with Bryan Morse
1 Winter 2016 David Wingate
1 Fall 2015 Bryan Morse

Short Summary: 

Concepts of Programming Language




Concepts of Programming Language

Principles and concepts characterizing high-level computer programming languages, process and data abstraction, encapsulation, inheritance, functional programming, logic programming, scanners, and parsers.

CS330 Objectives and Topics

This document is not a syllabus. Instead, for ALL offerings of this course, this document states the expected objectives and topics for the course and the approximate number of 50-minute lectures to be devoted to each topic. Faculty members teaching this course should adhere to these objectives and topics. Students taking this course can expect to achieve the objectives and cover the topics specified, and faculty members teaching follow-on courses can expect students to have been appropriately exposed to the prerequisite material as stated.



This course introduces students to the fundamental concepts of programming languages. In particular, it concentrates on concepts that are not typically found in traditional languages to which they have already been exposed. It discusses and compares features of several popular programming paradigms such as imperative, object oriented, functional, and logic programming.
In addition, students
Learn the vocabulary of programming language design, syntax, and semantics.
Develop an understanding of how programming languages differ.
Learn how to use BNF to describe concrete syntax and how that syntax drives the structure of translation programs.
Learn how programs can be represented using abstract syntax (e.g., parse trees) and how that abstract syntax is manipulated.
Learn to visualize and analyze the dynamic structure of various programming language features given their static representation.
Learn a functional programming language such as LISP, Scheme, etc.


Programming paradigms                         (1 lecture)
    imperative, object-oriented, functional, logic, etc.

Basic components                              (1 lecture))
    means of combination

Inductive structure of a language             (3 lectures)
    parsing (only minimally---should have been covered in 236)
    syntax-directed recursive programming (should have already seen in 235)

Procedures and function                       (3 lectures)
    delayed evaluation
    local environments and scoping
    functions as first-class entities, higher-order functions

Variables                                     (2 lectures)
    Name binding
    Scoping: static vs. dynamic
    Lexical addressing
Logical connectives and conditionals          (1 lecture)
    short-circuited evaluation
    special forms

Aggregate data                                (1 lecture)
    heterogeneous vs. homogeneous
    access by name vs. access by position
Data models                                   (3 lectures)
    expressed vs. denoted values
    direct data models
    indirect data models
    first-class vs. second-class types
    scalar types 

Parameter passing                             (3 lectures)
    by value
    by reference
    by value-result
    by name and need
    aliasing: problems and methods of avoiding

Functional programming languages              (2 lectures)

Object-oriented languages                     (5 lectures)
    Basics: encapsulation and abstraction, classes, objects, methods
    Class vs. instance variables
        of data
        of methods
        static vs. dynamic inheritance

Program translation                           (6 lectures)
    general structure of a translator
    parsing: concrete syntax vs. abstract syntax
    manipulating, evaluating, interpreting, and translating abstract syntax
    built-in functions vs. special forms
    symbol tables and environments
    various ways to add features:
        to parser, built-in function, special form, change data model, 
        change to parameter passing, etc.

Types                                         (2 lectures)
    strong vs. weak typing
    monomorphic vs. polymorphic types
    ad hoc polymorphism: overloading and coercion
    universal polymorphism: inheritance and parametric

This list includes material for 33 of 41 lectures per semester. This leaves 8 lectures for the instructor to cover the syntax or semantics of specific languages as examples, assign or review projects, prepare for or review examinations, add additional material, etc. It is also anticipated that many of the topics listed here will actually be introduced as part of introducing new language(s).