Homework & Grades
Q & A
U. of Iowa Homepage
About Computer Science 54
This page provides general information about the Fall 2000 offering of Computer Science 54, section 2. This is an old offering of the course.
This page is organized as follows:
Lecture attendance was required. Meeting times and locations were as follows:
There were two optional (but recommended) texts for the course. The first is The Little Schemer (Fourth Edition) by Daniel P. Friedman and Matthias Felleisen, MIT Press, 1996, ISBN 0-262-56099-2.
The second optional text was Revised5 Report on the Algorithmic Programming Language Scheme, Richard Kelsey, William Clinger, and Jonathan Rees, editors, 1998. You can get this report on-line from our resources page.
All the texts, plus some additional resources, were on reserve at the Mathematical Sciences library.
You must have an account on the department Unix machines.
From the U. of Iowa Catalog: "This course examines advanced topics in programming languages, for example, syntax specification and informal semantic models; program control structures including recursion, co-routines, backtracking, and concurrency; and data abstraction and structuring methods. The course introduces programming paradigms other than imperative and object-oriented, such as functional and logic programming. Examples and projects may rely on several languages such as Pascal, C, C++, Ada, and Java, with Prolog for the logic programming part and ML or Miranda for the functional programming part. This is a required course for majors in computer science. The course is taught by a faculty member."
To have a career in computer science means having to learn new programming languages. This course seeks to provide a forum where students can develop an understanding of the basic design decisions that are part of every programming language. Things like:
For such design questions we will look at several different answers and examine the ways that these answers can be combined. A good grounding in these concepts will help you to quickly learn new programming languages by recognizing how the language's designers answered these questions.
Our technique for studying these questions will be two-fold. First we will learn the functional programming language Scheme. Functional programming is much different from the imperative programming that most of us are used to from languages like C++, Visual Basic, or Java. Learning functional programming helps one to develop a more thorough understanding of the various ways of organizing programs.
After we have developed some experience with Scheme we will develop a series of interpreters for various small programming languages. These interpreters allow us to experiment with various design decisions, how those decisions interact, and how different language features are implemented.
The general objectives for this course are divided into two parts: a set of essential objectives, and a set of enrichment objectives. The essential objectives will be helpful for your career as a computer scientist; hence we want to help you to master them. You are encouraged to explore the enrichment objectives both for their own sake and because learning more about those will help deepen your understanding of the essential objectives.
In one sentence, the main objective is that you will have a deep, working knowledge of the functional paradigm and the key ideas used in modern programming languages. In more detail the essential objectives for this course are that you will be able to:
You will be permitted to use the textbook and course notes for tasks involving programming, but not during tests. On tests you may be permitted a small amount of reference material.
The functional style is one answer to the question: "What are good ways to program?" It also represents one major way to organize a programming language for parallel processing. Even if you do not become a programmer, the ideas of functional programming (function abstraction, referential transparency, etc.) have important applications in all areas of Computer Science (such as software specification, algorithm design, and of course in manipulation and specification of programming languages). These ideas also have application in many other contexts such as mathematics and engineering.
Data abstraction is a key idea for allowing programs to be easily modifiable. It forms the basis for the object-oriented style of programming.
One specific benefit of achieving these objectives is that your understanding will help you learn new languages quickly, by mapping key ideas and concepts from this class into the new language's syntax and semantics. For example, Java and other object-oriented languages (such as Smalltalk-80) use the "indirect model" of storage, which will be unfamiliar to you if you've programmed only in C++, C, Pascal, or Ada (all of which use the "direct model"). We will study the indirect model in detail, and you will gain practical programming experience with it, using Scheme. Learning this and other key ideas will also help you read (or write!) a new language's reference manual.
More importantly, understanding of fundamental concepts and run time implementation ideas will help you to better understand whatever language you program in; this will help you program more effectively. Being able to program better will also give you increased job satisfaction.
Enrichment objectives could be multiplied without limit, but the following seem most important or most easily taught using the course text. Following each of the enrichment objectives is a brief justification.
The formal prerequisites in the U. of Iowa catalog are successful completion of 22C:30 and completion or enrollment in 22C:40.
My original ideas for this course at Iowa State were developed with the help of Kelvin Nilsen. Final exams for similar courses at other universities were provided by Kim Bruce (Williams College), Sam Kamin (University of Illinois), Dan Friedman and J. Michael Ashley (Indiana), and John Mitchell (Stanford); these helped provide perspective on what is important for such a course. I owe a great deal of thanks to Clyde Ruby, who was my TA and then an instructor for the course in its present form, and who provided much of the infrastructure for the course. I also owe many thanks to Curtis Clifton at Iowa State for collaboration much work on these web pages, and for collaborative discussions about the course.
Last modified Friday, December 29, 2000.
This web page is for the Fall 2000 offering of 22C:54 at the University of Iowa. The details of this course are subject to change as experience dictates. You will be informed of any changes. Thanks to Curt Clifton for help with these web pages. Please direct any comments or questions to Gary Leavens.