CSCI 3675, Fall 2000

We will use Solaris for program development. All students will receive accounts. If you have a prior account, it has not been modified. If you were on my class role and you did not have a prior account, then your account is your first initial followed by up to seven letters from your last name. Use all lower case letters. Your password is the last six digits of your social security number.

A brief tutorial on Solaris is available.

Lecture summaries

[8/16] I handed out the syllabus and began looking at programming languages in general. A manuscript will be made available on Monday 8/21 at Kinko's on Tenth street. The material covered today is from Chapter 1 of that manuscript.
[8/21] We began looking at formal description of the syntax of a programming language. The formal description is broken into the lexical rules and the syntactic rules.
The syntactic rules are given by productions written in BNF (Backus-Naur Form). A collection of productions is called a grammar. BNF is described in Chapter 2 of the book.
[8/23] We looked more at BNF. We defined ambiguous grammars and wrote an unambiguous grammar for simple expressions with + and *. We looked at extended BNF and syntax diagrams. Homework assignment 1 was assigned. A link to it is above.
[8/28] We discussed implementation of programming languages, including compilers, linkers, interpreters, the library and the run-time support. This material is in chapter 3 of the text.
[8/30] We discussed data and how data is represented. This is from chapter 4 of the text.
[9/4] Holiday.
[9/6] We discussed names, name binding and scope. This material is in chapter 5 of the text.
[9/11] We began to look at functional programming. See chapter 6 of the text.
[9/13] We continued to look at functional programming. Exercise 2 was assigned, and we went over programming assignment 2.
[9/18] We looked at higher order functional programming and how to define and use higher order functions.
[9/25] We discussed assignment 3, and look more at higher order programming, including lazy evaluation.
[9/27] We finished looking at lazy evaluation and list comprehensions, and began looking at Scheme.
[10/2] We will continued looking at Scheme.
[10/4] Quiz 2. We will address issues on the semantics of programming languages.
[10/9] We looked at lambda-calculus. This material is in a chapter of the text that is not ready. If I get it ready soon I will hand it out.
[10/11] We finished lambda-calculus and began looking at imperative programming.
[10/16] We looked at the semantics of imperative programming.
[10/18] We looked at handling failure, including exception handling and backtracking.
[10/25] We began looking at logic programming. We started with the foundations, including unification.
[10/30] We looked in detail at logic programming and computation of logic programs.
[11/1] We did more examples of logic programming.
[11/6] We finished logic programming and Prolog by looking at cuts and negation.
[11/8] We began looking at types. We covered material in the new notes up to 24.3.
[11/13] We continued looking at types, including polymorphism and type inference.
[11/15] We did do more on types, including more on polymorphism, plus programmer-defined types and type checking with programmer-defined types.