- The project proposal is due
on February 23rd. This should be a 1 page paper describing what
you plan to do. Please send it to me by email. The main purpose of this is
to allow me to give you feedback on the feasibility of the project (in
case you propose to solve the halting problem by the end of the semester
- You must finish the paper by the date TDB, to avoid
getting mixed with other class projects you might have.
- I will announce a schedule of 15-20 minute presentations during the last few lecture slots
All students are expected to select and complete a course project. This can
be in the form of a paper exploring more deeply a topic covered in the course
or a related topic which we have not covered in the course. Before starting to
work on a project discuss it with the instructor. Be ready to argue what do
you expect to learn from the project (why is it interesting to you) and to
propose a work schedule. Make sure to budget time for writing a short paper
(max 6 pages) describing the project and for preparing a short (15-20 minute)
presentation during the last week of classes. Projects can be individual or in
groups of two.
The main goal of the project in CS263 is to allow you to customize the
content of the course to your own interests. The goal is not to force you all
to produce novel results in one semester.
- You should expect to learn from the project a comparable amount of
material as from two or three lectures.
- 80 hours should suffice (within a factor of two)
- More ambitious projects are welcome:
- such projects must be staged so that you have something to show at the end of the semester
- I (or your advisor) can provide some guidance on such projects
- If you have a great idea and need help feel free to recruit it
- However, given the scope of most projects, especially the survey
projects, I think that they are easier done alone
Kinds of projects
I envision 3 main kinds of projects
- survey of the work in some area of language design (see below for some
of a small language or relevant algorithm
in language design (preferred) or implementation. (see below for some
The survey project
- Pick an area in which you are interested
- Read thoroughly 3-6 papers
(or a monograph?). Read at least superficially 3-6 other papers. I will
provide some start leads but you should do most of the work in tracking
the relevant papers.
- Write a report on what you
Keep the scope narrow enough
so you can say something interesting
- What are the basic
- What are the basic
approaches to solving them
- What are the main
achievements to date
- What are open problems
The research project
There are several sorts of research projects
- Design: invent a language, or
a language fragment, for some particular purpose or with some particular
- Modeling: try to formalize
some interesting aspect of some existing language
- Implementation: explore novel
techniques for implementing a given language fragment
In any case you should be prepared to write a report on your work or
whatever length is appropriate.
These projects are the hardest because they also involve some survey work
and sometimes implementation. Unless you already have an idea already you can
start with a survey project and then turn it into a research one.
The project paper should have an Introduction describing the tackled
problem, its motivation and a very brief summary of the accomplishment. Then
you should write a description of your notations if they are different from
what we used in class. Then you continue with the body of the material. The
paper should end with a Conclusion putting the perspective the accomplishment
of the project and mentioning the open problems and with a Bibliography of
cited papers. Research papers should also have a Related Work section in which
they compare the work with previous research results.
The paper should be typeset and made available in electronic form.
The presentation should be very short (15-20 minutes) and should describe in
few details what the problem was, what the difficulties were and what was
accomplished or learned. You will find it much easier to prepare the talk using
slides (8 to 10 slides excluding the title, depending on your speed). While
preparing the talk keep in mind who your audience is: your colleagues who are
eager to find out (1) about new exciting facets of programming languages and
(2) how much fun you had. Plan to motivate the project (why is it important)
and to describe what you learned from it. Keep in mind that your colleagues
have not read all the papers that you have read to do the project.
Suggestions for Survey Projects
Again, I encourage you to define your own project. In case you do not have
any ideas, here are some suggestions. Send me mail to indicate your interest in
a topic that does not currently have a description.
- Language Constructs for Concurrency. See Chapter 14 in Winskel's for leads. You must go
significantly beyond the simple pi calculus which we'll (try to) cover in
class. There are a variety of proposals for new concurrent languages. Look at
concurrency models like
MapReduce and Dryad/LINQ,
Futures as well as new
languages like Erlang, Clojure, Cilk, Scala and newer ones like X10,
- Axiomatic semantics for parallel languages. Owiki Gries semantics. See the
book by Apt and Olderog "Verification of Sequential and Concurrent Programs"
- Receiver class analysis with abstract interpretation. Design (and implement) and analysis to infer the run-time
subclass of a value statically declared to have an abstract class. This can
be used in compilers for object-oriented languages to optimize the run-time
- Region-Based Memory Management. Is it possible to have a type-safe language where the
programmer has some control over the memory deallocation? Regions are one
such possibility. Start with the seminar paper by Talpin and then take a look
at the Cyclone language.
- Typed Assembly Language
- Refinement Types. A method to refine types with the purpose of allowing the
type checker to perform more extensive tests. For example we might want to
refine the type of lists into two subtypes, the list of even length and
those of odd length. With such information a compiler can unroll loops
- Exceptions. Study various ways to add exceptions to the language.
- Monads. Monads are a discipline for simulating the effects of
imperative programming in logic or purely functional programming languages.
- Continuation-passing style semantics.
Continuation passing style is a form of operational
semantics using continuations. You can start with Duba et al paper
"Typing First-Class Continuations in ML" from POPL
'91 and Filinski's "Linear Continuations" in POPL
- Semantics of finalizers.
Java has the notion of a finalizer, a function that is
invoked when an object is garbage collected. This has some interesting
consequences, mostly having to do with the ordering of finalizers. See the
section from the Java Reference Manual: 12.6
Finalization of Class Instances 231
- Languages with multiple inheritance. Java has multiple inheritance of specifications and C++
has also multiple inheritance of implementation. Explore the implications. A
starting point might be Cardelli's paper "A Semantics of Multiple
Inheritance" in Lecture Notes in Computer Science, vol 173, 1984, pp
- Language support for Databases and Web Applications. PL and databases have
never entirely gotten along -- attempts to combine the two smoothly have run
aground. Follow the links in
this survey to see what the problems are, what approaches
have been proposed and what remains to be done.
Links attempts to resolve
- Web Security. There are several exciting projects on language-based
techniques for securing web applications.
- Dependent Types for Programming and Verification. Capture rich invariants
about the program inside the type system. See
Hybrid Type Checking,
- Networked Systems built using Modern Languages.
Is C still the best choice for building networked systems ?
See here for a functional approach, and
here for a declarative approach.
- Statistical Debugging. Is a new technique for finding bugs by using Machine Learning to find
predicates correlated with failures. See
- Program Synthesis. Survey the literature on synthesizing programs from high level
specifications. Look here or
here for a starting
- Separation Logic. Is a recently discovered technique for reasoning about
heap-manipulating programs at a low-level,
using axiomatic semantics. Look
here for a starting point.
- Shape Analysis. techniques attempt to statically analyse and predict the possible
structures that will be created at run-time on the heap.
Look here or
for a starting point.
- Termination Analysis techniques attempt to statically prove that a given program will terminate.
Google "Andrey Rybalchenko" for a starting point.
- Safe Low-level Languages. There have been several languages proposed recently, that attempt to bring
the benefits of high-level programming (e.g. type-safety) down to languages
designed to be low-level (e.g. for OS Kernels, Drivers). Two examples are
Cyclone and Vault. You can also look at the
Singularity project at MSR that is attempting to build an OS
Kernel in C#.
- Random Interpretation.
Is a recently invented technique for finding program properties that hold (with
arbitrarily high probability) by cleverly interpreting the program's
behavior over a small set of randomly chosen inputs. Look here
for more details.
- Reasoning about Compilers. The code you write is crunched by a compiler into the code that is
executed. Are the two the same thing ? Study the different techniques
proposed to answer this question: translation validation
, automatically checking optimizations, and
compilers with a proof assistant.
- Typestates. Types are useful for precisely capturing properties about data that
do not change during the execution of the program (e.g. an integer variable
always holds an integer). Typestates generalize this to allow reasoning
about specific configurations that an object may be in owing to the
operations that have been applied to it (e.g. method calls).
Start with the papers of FD04 ,
and BA05 that
describe typestates and JIST, HJM05 and
that describe how to infer them.
- PL for Embedded Software. Embedded systems are especially hard to program as they must meet
several constraints that regular programs need to. Study some of these
issues and how they have been addressed in various languages e.g.
NesC and Giotto , to name just
Suggestions for research projects