Projects

Schedule

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

Guidelines

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.

Goal

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.

Scale

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

Collaboration

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 suggestions)
implementation of a small language or relevant algorithm
research in language design (preferred) or implementation. (see below for some suggestions)

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 have learned

What are the basic problems
What are the basic approaches to solving them
What are the main achievements to date
What are open problems

Keep the scope narrow enough so you can say something interesting

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 characteristic
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 paper

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

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 Software Transactional Memory, Data Parallel Haskell, MapReduce and Dryad/LINQ, Futures as well as new languages like Erlang, Clojure, Cilk, Scala and newer ones like X10, Fortress.
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 method dispatch.
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 involving lists. Start here.
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 '92
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 51--67.
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 the problems.
Web Security. There are several exciting projects on language-based techniques for securing web applications. Start here.
Dependent Types for Programming and Verification. Capture rich invariants about the program inside the type system. See Dependent ML, Deputy, Hybrid Type Checking, Liquid Types.
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 this
Program Synthesis. Survey the literature on synthesizing programs from high level specifications. Look here or here for a starting point.
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 here for a starting point.
Termination Analysis techniques attempt to statically prove that a given program will terminate. Google "Andrey Rybalchenko" for a starting point. here and here
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 programming 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 two.