Instructor: Eugene Wallingford
- office: 305 ITTC (the old East Gym)
- phone: 273-5919
- email: email@example.com
- web: http://www.cs.uni.edu/~wallingf/
- my office hours and schedule
- The course web page, http://www.cs.uni.edu/~wallingf/teaching/cs3540/
- The course mailing list, firstname.lastname@example.org
- The programming environment Dr. RacketNote that to send messages to the course mailing list, you must send from the mailing address from which you are subscribed. By default, that is your uni.edu e-mail address. If you prefer to be subscribed from some other address, just let me know.
- The Little Schemer, by Daniel Friedman and Matthias FelleisenThe Little Schemer uses an unusual question-and-answer format to help you to think and program in a new style. It's well worth a few dollars. Some people really like this format. If you are one of them, then take a look at The Seasoned Schemer, also by Friedman and Felleisen.
- The Racket GuideRacket's documentation is outstanding. The Racket Guide gives a broad and deep introduction to the language, aimed at people who already know another programming language. Occasionally, the guide introduces a feature sooner than we do in class, but overall it is a useful introduction to the language, its basic features, and its advanced features. We won't use many of the advanced features, because we have only fifteen weeks and Racket isn't the primary goal of the course.
The study of programming languages and paradigms is fundamental to the discipline of computer science. As a computer scientist, regardless of your specialty, you should have a deep understanding of the principles of programming languages. They govern the design and use of every language that you will encounter. They affect the design of the applications you encounter. They even affect the architecture of the machines on which we run our programs. If you understand these design principles, then you will find it easier to be become an effective user of any language, to adapt to new paradigms as they evolve, and to design and implement new languages when necessary. You may be surprised to learn just how often you find yourself implementing small languages as a part of your applications.
This course aims to help you develop a deep, hands-on understanding of the essentials of programming languages. It does so by confronting you with the most fundamental idea in computer programming: The interpreter for any computer language is just another program. We will first lay the foundation for the analytic study of programming languages and then use those ideas to develop a sequence of increasingly detailed interpreters for a simple language.
In order to use this approach for the course, it is helpful that you learn a programming language that make it relatively easy to build language interpreters. We will learn Racket, a programming language that allows us to easily treat programs as data and vice versa. One of the extra benefits of learning Racket is that you will learn to program in a functional style, which will expand your programming repertoire. It will be the third "paradigm" in which you can program, in addition to procedural (Python, Ada, C) and object-oriented (Java, Python). Functional programming differs from the other two styles in a very important way: in functional programming, we compute only for values, rather than for side effects.
By the end of the semester, you should feel comfortable:
Note that this course is not about any particular programming language, nor even about a smorgasbord of different languages. We will not study the syntax of new programming languages so that you can use them to write programs. Instead, we will seek develop the knowledge and skills necessary for you to be able to study other languages on your own. The course does introduce you to Racket, a small and malleable programming language, as a tool for expressing the features of languages and writing language interpreters. It will be the microscope we use to study the broader principles of programming languages and paradigms.
You will earn your grade based on your performance on homework assignments, quizzes, and the final examination. I assign final grades using the following distribution:
Grades will be assigned using an absolute scale:
This means that there is no curve. However, I reserve the right to lower the individual grade boundaries at the end of the term if I think that produces grades that better reflect what students have achieved.
The following schedule gives a rough sketch of the topics we will cover and the distinguished dates this semester. The quiz dates are tentative. If I decide to change a quiz date, I will notify you at least one week prior to the quiz date.
|1||01/10 - 01/12||Introduction to course and Racket||.|
|2||01/17 - 01/20||Functional programming and Racket||.|
|3||01/24 - 01/26||Functional programming and Racket||.|
|4||01/31 - 02/02||Induction and recursion||Exam 1 (Tue)|
|5||02/07 - 02/09||Recursive programming techniques||.|
|6||02/14 - 02/16||Recursive programming techniques||.|
|7||02/21 - 02/23||Recursive programming techniques||Exam 2 (Thu)|
|8||02/28 - 03/02||Syntactic abstraction||.|
|9||03/07 - 03/09||Syntactic abstraction||.|
|.||03/14 - 03/16||spring break||.|
|10||03/21 - 03/23||Syntactic abstraction||.|
|11||03/28 - 03/30||Syntactic abstraction||Exam 3 (Thu)|
|12||04/04 - 04/06||Data abstraction||.|
|13||04/11 - 04/13||Data abstraction||.|
|14||04/18 - 04/20||Interpreters||.|
|15||04/25 - 04/27||Interpreters; course wrap-up||.|
The final exam is Thursday, May 4, from 3:00 PM - 4:45 PM.