Tuesday, Thursday, 12:1:15
Room 216, Computer Science
Office Hours: Tuesday, Thursday: 3-4pm
In the relatively short history of computing, there have been hundreds of programming languages invented, and undoubtedly hundreds more will appear during our lifetime. How do we judge the quality, novelty, and expressive power of these myriad languages? What are the criteria that dictate when a new language design or feature is warranted? How do we relate different languages and their features to one another? How do we distinguish between language features that are really different, from those that only appear to be?
These are some of the questions that we will explore in this class. Among the many questions we will not answer are those dealing with programming techniques or methodology, or software engineering. This course will not teach you how to be a better programmer; it does aim however to teach you to be a better programming language designer. By exposing you to insights and formalisms on language design, you will be able to better rationalize and objectively analyze language features and paradigms.
Some of the topics we will cover include:
To help us in our investigation, we will will strive to identify foundational components of a language and use these components to build toolkits that will allow us to express new, more complex, language features. Our components will be drawn from a simple core language called the lambda-calculus, and our toolkits will be defined as extensions of the calculus.
By the end of the class, students should be comfortable with objectively assessing and comparing superficially disparate language features, understanding how these features impact implementations, and be able to distinguish concepts that truly are foundational from those that just appear to be. Most importantly, the overarching goal of this course is to equip students to ask better questions about language design, even if the answers themselves are not readily apparent.
It is assumed that students taking this class would have had exposure to an undergraduate software engineering and/or compilers class, and be comfortable with basic mathematical concepts, and software implementation techniques. Although students need not be fluent in Scheme (the language in which programming assignments are to be completed), they should be confident in their ability to grasp its key features, and gain fluency quickly by self-study.
Students are encouraged to work together to clarify issues presented in class. Small programming assignments will be given during the course. Students are free to work together on these assignments.
Grading for the class is as follows:
Midterm 1 25%
Midterm 2 25%
The main text for this class will be Programming Languages:
Application and Interpretation by Shriram Krishnamurthi. The .pdf
for the text is
In addition, students might find the following texts also useful:
The Scheme programming language is the language in which programming
examples in the text are written, and the language used for
assignments. Dr. Scheme is an
integrated development environment and
implementation for Scheme. Students with
access to a desktop or laptop machine should download a copy. Dr.
will also be available on the department machines. There are links to
resources from the Dr. Scheme website that you can use to learn more
about Scheme. You may also find the online version of the text How to Design
Programs useful; it provides hints on how to use Dr. Scheme. In
addition, the Scheme report
gives a precise
description of the language. An accessible tutorial on Scheme can be