CS 231: Introduction to Programming
An introductory course in computers and programming.
I usually teach a fairly broad set of topics, including the following:
Students attend lectures and labs, three times a week each, and spend
a significant portion of their lab time programming in Symantec Cafe.
- some history (of computing) and philosophy (nature of language
and information, role of symbols, etc.);
- issues in data representation (number systems, algebra
of logarithms and exponents, digital representation of various
kinds of information);
- computer organization and low-level programming (including
simple architecture and assembly language programming, the
latter using a simulator for a simplified machine, the PC-231);
- and finally, the traditional core topic for this course,
higher-level programming using the Java langauge.
CS 241: Data Structures and Algorithms
The second course in the introductory sequence for Computer Science
majors at Willamette. As a second course in programming, it deepens
and enriches a student's understanding of the basic processes involved in
computing. But it also begins to focus on deeper and more abiding issues
such as evaluating design strategies and implementation effectiveness.
CS 348: Programming Languages
An intermediate-level course covering the main concepts of programming
languages, including history, components (syntax, semantics, pragmatics), formal
treatments, design issues and exposure to a handful of languages in lab.
Since Willamette has not been regularly teaching a compilers course recently,
I incorporated some material from this topic in the most recent offering.
CS 446: Automata Theory
An upper-level course on the theory of computation. Despite the course
title (which is traditional at Willamette), we actually consider
computation from the perspectives of both abstract machines (automata)
and language formalisms (the Chomsky hierarchy).
CS 451: Functional Programming
An upper-level course on functional programming taught in Haskell.
In addition to the usual techniques of functional programming
(algebraic data structures, higher-order functions, polymorphism and
lazy evaluation), this version of the course stresses the use of
generic folds and other generic functions in program design (currently
these techniques are not supported by specific language features).
An earlier version of this course (Fall 1997) was taught bi-lingually
in Scheme and Haskell, but I felt that the overhead associated with
learning two languages detracted from the goals of the course as a whole.