BYU CS Logo
Computing That Serves

CS 330

Course Offerings

Section # Semester Instructor Website Description
1 Fall 2017 David Wingate https://learningsuite.byu.edu/view/AwQay9QWrjbE.html
2 Fall 2017 David Wingate https://learningsuite.byu.edu/view/AwQay9QWrjbE.html
Section # Semester Instructor Website Description
1 Winter 2018 Bryan Morse
2 Winter 2018 Bryan Morse
1 Fall 2017 David Wingate https://learningsuite.byu.edu/view/AwQay9QWrjbE.html
2 Fall 2017 David Wingate https://learningsuite.byu.edu/view/AwQay9QWrjbE.html
1 Winter 2017 David Wingate https://learningsuite.byu.edu/view/rSugMPl3oxzm.html
1 Fall 2016 David Wingate https://learningsuite.byu.edu/view/nkeI-prqCp4l.html Taught with Bryan Morse
1 Winter 2016 David Wingate https://learningsuite.byu.edu/view/YxYS5Vcfy2I3.html
1 Fall 2015 Bryan Morse https://learningsuite.byu.edu/view/EGhZBi70dhgw.html#instructorInformation

Short Summary: 

Concepts of Programming Language

Credits: 

3

Prerequisites: 

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.

 

Objectives


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.

Topics

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

Basic components                              (1 lecture))
    primitives
    means of combination
    abstraction         

Inductive structure of a language             (3 lectures)
    BNF
    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
    closures
    local environments and scoping
    functions as first-class entities, higher-order functions

Variables                                     (2 lectures)
    Name binding
    Properties
    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
    Inheritance
        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
    unparsing
    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).