Programming Languages 1 (Com S 541)

This page gives access to information about the course offering of ``Programming Languages 1'' by Gary T. Leavens for the Department of Computer Science at Iowa State University.

Material from Previous and Current Offerings

I have taught this course (and variations of it) several times. Material on these offerings is available based on:

Overview and History

When I teach this course, I like to change what (and even how) I teach to some extent each semester. I started teaching (in 1990-92) based on readings, notes, and projects from Dave Gifford's 6.821 course at MIT (for which I was a TA). I gradually found that the students at Iowa State needed more programming experience, and so taught various languages as part of the course (usually towards the end of the semester). At various times these have included: OBJ3, Prolog, lambda Prolog, Scheme, Standard ML, Haskell, Smalltalk, C++, and SR. (I have also tried to find the right balance between this course and the undergraduate programming languages course.)

Continuing the development of 541, I taught the course in 1993 based on Watt's Programming Languages: Concepts and Paradigms, with a supplement of Watt's Programming Languages: Syntax and Semantics; the focus was on language design, not semantics. In 1994 and 1995, I reversed the use of these books, and taught a course centered around semantics, especially for object-oriented programming languages; this version of the course also did a considerable amount of operational semantics, using lambda-Prolog to animate these semantics. I carried this trend to perhaps its conclusion by using David Schmidt's new book The Structure of Typed Programming Languages in 1996. Although I'm struck by how this book uses denotational semantic techniques to explain things (as opposed to teaching the semantic techniques as an end in themselves), the balance between theory and practice was a bit too much on the theory side for 541. (However, I have had success with this book for a more advanced graduate course, Com S 641.)

In Spring 1997 we went back to something more like the 1994 and 1995 offerings of the course. Although we used Haskell instead of ML, as in 1994-95 we centered the course around semantics of object-oriented programming languages. We used the generic-function language BeCecil, which is described in ISU CS TR#96-17, as a jumping off point for several projects. The treatment was much less theoretical than in 1996, did more programming, a bit of language design, and some prototyping of BeCecil's type system. Finally, we continued previously successful aspects of the course, such as group work for mini-projects, and exercises to help students learn to read and evaluate relevant research literature.

This is similar to what we did in Fall 1997 and Fall 1998 and Fall 1999. In Fall 1997, by negotiation with students, we studied object-oriented programming using Smalltalk, did a case study on Java, and studied other paradigms using Haskell and Lambda Prolog. We did not concentrate as much on language design, but focused more on semantics again. We also continued group work for mini-projects and reading exercises. In Fall 1998, we had a similar course, but too some off of the logic programming to study JavaBeans and components. In Fall 1999, we again had a similar course, but focused more on semantics and less on langauge design. We continued group work for mini-projects and reading exercises. Group work and some of the material in the course focused on domain-specific languages.

For Fall 2002 we emphasized the new ideas in aspect-oriented programming. We will investigated extensions to Squeak Smalltalk, including multiple dispatch (using tuples) and the semantics of AspectJ. Students designed a a version of aspect-oriented Smalltalk. We also studied functional langauges, using Haskell.

The course was similar in Fall 2003 but instead of working with aspect-oriented Smalltalk, we did a bit more with the semantics of AspectJ and aspect-oriented programming languages. Curt Clifton led a few class discussions on an aspect-oriented calculi. We also looked a bit at the idea of expressive power.

In Fall 2004 we followed again a somewhat similar plan, but did more with logic programming instead of working much with object-oriented programming. For example, we studied lambda Prolog instead of Smalltalk. We used logic programming to explore operational semantics more fully than in recent years, but also spent quite a bit of time on aspect-oriented programming.

Plans for Fall 2005 aimed at trying to "invent the future" of programming languages, designing a successor to Java incorporating state-of-the-art features that are nevertheless well-understood. We started by studying Haskell and the lambda calculus, and then spent a lot of time studying Scala. We also spent some time looking at aspect-oriented programming using AspectJ, and rather less time than would have been ideal actually designing new languages.

Plans for Fall 2006 offering are to study the book Concepts, Techniques, and Models of Computer Programming, by Peter Van Roy and Seif Haridi (MIT Press, 2004). The idea is to get a broad overview of paradigms and especially approaches to concurrency. We will discuss ways of proceeding together in class.

Last update $Date: 2006/08/15 03:57:27 $
Gary T. Leavens
229 Atanasoff Hall
Department of Computer Science, Iowa State University
Ames, Iowa 50011-1040 USA