Course News

• This term we will be using Piazza for outside-class discussion. The system is designed to quickly provide you with course help from classmates, the TAs, and myself. Rather than emailing questions to the teaching staff, I encourage you to post your questions on Piazza. If you have any problems or feedback for the Piazza developers, email team@piazza.com.
  Our class Piazza page is located at the URL: https://piazza.com/rice/spring2015/comp411/home
• Finding project partners:
  All projects in Comp 411 will be completed in groups of up to two students. If you would like to find a partner for completing the projects this semester, we encourage you to use the Search for Teammates! feature on Piazza. The following are some issues to keep in mind when searching for a partner.
  • Make sure you have the time to work on the project together.
  • Make sure that at least one partner has Java programming experience.
  • Try to find a permanent partner for the rest of the class; it's a lot easier to work with the same student than to switch.
  • You may choose to work alone. We do not allow groups of more than two students, even if there is an odd number of students in the class.

Summary

COMP 411 is an introduction to the principles of programming languages. It focuses on:

• identifying the conceptual building blocks from which lanugages are assembled and
• specifying the semantics, including common type systems, of programming languages.

A secondary theme is software engineering. All of the programming assignments in this course are conducted in Java using test-driven development and pair-programming, two of the major tenets of Extreme Programming.

COMP 411 consists of three parts:

• The first part focuses on specifying the syntax and the semantics of programming languages. The former is introduced via simple parsing (translations) of program text into abstract syntax. More detailed aspects of parsing (such as lexical analysis and advanced parsing methods) are left to COMP 412, a course on compilers. The semantics of a comprehensive collection of programming language constructs is specified using interpreters and reduction (textual rewriting) systems. The constructs include arithmetical and conditional expressions, lexical binding of variables, blocks, first-class functions, assignment and mutuation, simple control constructs (loop exits, first-class continuations, simple threads), and dynamic dispatch.
• The second part illustrates how interpreters and reduction semantics can be used to analyze important behaviorial properties of programming languages. Two examples are covered: type safety and memory safety. Type safety guarantees that programs respect syntactically defined type abstraction boundaries and never raise certain classes of error signals. Memory safety guarantees that programs release memory if it is provably useless for the remainder of the evaluation. Type safety typically depends on memory safety.
• The third part shows how interpreters can systematically be transformed so that they use fewer and fewer language facilities. The key transformations are the explicit representation of closures as records and the conversion of program control flow to continuation-passing style. Using these transformations, a recursive interpreter can readily be be re-written in a low-level language like C/C++ or even assembly language. These transformations can be applied both to interpreters and to arbitrary programs. if we apply these transformations to an interpreter, the result is a low-level interpreter that is easily implemented in machine code. The process of applying these transformations to arbitrary input programs yields a high-level description of program compilation, a process which is explored in more detail in COMP 412.

The course enables students to analyze the semantics and pragmatics of the old, new, and future programming languages that they are likely to encounter in the workplace (e.g., Fortran, C, C++, Java, Visual Basic, C#, Perl). They will also be able to build efficient interpreters for new languages or for "special-purpose" languages embeded in software applications. Finally, they will be much better equipped as software developers because they will understand how to define and implement whatever linguistic extensions are appropriate for simplifying the construction of a particular software system.

Notes on the common mathematifcal notation used in operational semantics, some of which will be used in class.

Course Information

Please take a look at the course information some of which was discussed during the first few class lectures.

Assignments

Please refer to the assignments column in the below.

Lectures

Powerpoint slides for selected lectures are available in this directory.

Language Resources

1. Java
   1. SDK Download
   2. Generic Java Documentation
   3. API Reference
   4. DrJava Programming Environment
   5. Elements of Object-Oriented Program Design by Prof. Cartwright
2. Scheme (Racket)
   1. How to Design Programs
   2. DrRacket Programming Environment
3. OCaml
   1. OCaml Book
   2. O'Caml Language
   3. MetaOCaml
   4. OCamlLex
   5. Using "Ledit" to make Ocaml recognize arrow keys
4. Haskell
5. Scala

Additional References

1. Krishamurthi, Shriram. Programming Languages: Application and Interpretation. Online at http://www.cs.brown.edu/~sk/Publications/Books/ProgLangs/. This book is a descendant of lecture notes created by Shriram for a version of this course when Shriram was a teaching assistant over a decade ago.
2. Friedman, Wand, and Haynes, Essentials of Programming Languages, 2nd ed. (MIT Press, 2001)
   You can take a look at the following two chapters, which the authors prepared for the second edition, without buying the book:
   1. Parameter Passing ( local file, PDF)
   2. Types and Type Inference ( local file, PDF)
3. Evaluation rules for functional Scheme ( PDF)
4. References on evaluating Jam programs
5. Lecture Notes on Types I
6. Lecture Notes on Types II
7. Introduction to System F (Polymorphic Lambda-Calculus)
8. Scheme code from Class Lectures
9. The Essence of Compiling with Continuations by Flanagan et al.
10. Uniprocessor Garbage Collection Techniques by Paul Wilson
11. Garbage Collection [canonical textbook] by Jones and Lins
12. Space Efficient Conservative Garbage Collection by Hans Boehm ( local file, PDF)
13. Hans Boehm's Conservative GC Webpage
14. The Java Virtual Machine. The most basic expository articles appear at the end of the index. Read it from bottom up.
15. Java Memory Model
16. Revised Thread Synchronization Policies in DrJava (doc) ( pdf). Since DrJava is built using the Java Swing library, it must conform to the synchronization policies for Swing. Unfortunately, the official Swing documentation is sparse and misleading in places, so this document includes a discussion of the Swing synchronization policies.
17. Lesson: Concurrency in Swing. This lesson discusses concurrency as it applies to Swing programming. It assumes that you are already familiar with the content of the Concurrency lesson in the Essential Classes trail.
18. Concurrency in Swing Text
19. The Last Word in Swing Threads
20. Old Course Website

Accomodations for Students with Special Needs

Students with disabilities are encouraged to contact me during the first two weeks of class regarding any special needs. Students with disabilities should also contact Disabled Student Services in the Ley Student Center and the Rice Disability Support Services.