CS2013-final-report

How are students assessed
There are typically six major programming projects, most of which attempt to combine experience with a particular
programming paradigm or mechanism (e.g., concurrency, templates, first-class functions, or glue-style scripting)
with a language implementation issue (e.g., syntax error handling, semantic analysis, interpretation, or symbol table
management).
The first project of the semester asks students to solve a simple combinatorial problem in 5 or 6 different (often
unfamiliar to them) languages—e.g., Ada, C#, Haskell, Prolog, and Python.
Each project is expected to take perhaps 10 hours of time, spread over a two-week period. To encourage students to
begin thinking about projects as soon as they are assigned, most require a set of simple familiarization questions to
be answered (in writing) within the first three days. For the programming itself, students can elect to work alone or
in pairs (with no difference in grading).
There is typically a midterm and a final exam. Projects count for approximately half of the course grade, exams for
the other half. In some semesters, students have been asked to turn in written answers to the routine review
questions in the text, to encourage them to keep up with the reading.
Course textbooks and materials
As text, the course uses the instructor’s Programming Language Pragmatics (third edition, Morgan Kaufmann,
2009). Reading assignments cover most of chapters 1–4 and 6–10, and about half each of chapters 12–15. Major
assignments are typically given in C++ (for templates); Java (for concurrency); Scheme or Haskell; and Perl,
Python, or Ruby. Students are provided with access to Linux machines, though many opt to do most of the work on
personal Windows or Macintosh machines, and then port it to the Linux environment (where grading occurs).
Why do you teach the course this way
Like many schools, Rochester once had a “survey of programming languages” course and a separate compiler
course. The current course reflects the conviction that language design and language implementation must be
studied together, because neither can be fully understood without the other. We have separate, follow-on courses in
static and dynamic program analysis, and in language-level tools and software development. The goal is to not to
train students to be experts in the use of any particular language, but rather to give them the ability to pick up new
languages quickly, to choose wisely among them in various circumstances, and to appreciate what may be going on
“under the hood.”
Body of Knowledge coverage
KA Knowledge Unit Topics Covered Hours
PL Object-Oriented Programming All 2
PL Functional Programming All 2.5
PL Basic Type Systems All 2.5
PL Program Representation All 2.5
PL Language Translation and Execution All 5
PL Syntax Analysis Regular expressions and scanning; contextfree
grammars; top-down vs. bottom-up
parsing; recursive descent & table-driven
top-down parsing; syntax error recovery
3.5
PL Compiler Semantic Analysis All 4
- 370 -