The 4999 and 7999 projects that I supervise generally involve a mix of
reading research papers, design and implementation work, and a final writeup of
about 5,000 words. Students should have solid programming experience; taking a
prior 4000-level project course is a good idea. A good background for many of these
projects is a course with the number x1y0, where x ≥ 4. Examples include
CS 4120 (Compilers), CS 4110 (Programming Languages), and CS 6110 (Advanced Programming
The following are some projects that may be available. Students seeking a
project should think about what they would like to work on before talking to
We are programming robots using the Jif programming language, for greater
software security when robots are being attacked in various ways. There are
a lot of subprojects associated with this; one near-term goal is to get
Jif compiling onto the RISC V processor via our Polyglot/LLVM front end.
We can then run Jif code on an FPGA simulating RISC V.
The Genus programming language (http://www.cs.cornell.edu/projects/genus) is
Java-like language with a powerful new capability for generic programming,
related to Haskell's type classes. Some projects:
- explore how to use the new language features most effectively by
developing libraries for Genus, such as the library of collection classes.
- work on the compiler to improve code quality and support for
- The new Familia language extends Genus with support for family inheritance.
We also are developing a compiler for that language.
- Reduct is a new
game for teaching programming languages via operational semantics. We are expanding the game to
become a real programming environment. Students are needed with interests in
user interface, programming languages, education, and game design.
[Reduct version 1 |
Reduct version 2 ]
is a secure wide-area distributed object store and a big system-building
project. Fabric objects look like Java objects but are secure and are
transparently distributed and persistent.
- Automatically moving computation and data storage to distributed locations
to make programs secure and efficient
- Extending the language to support parallel distributed applications (MapReduce
- Implementing larger Fabric applications (e.g., CMS) to explore how well
we can capture security requirements.
- Studying how to make Fabric's software transactions as efficient as possible.
- Adding mechanisms for adaptively switching between optimistic
concurrency control and pessimistic locking.
- Improving the power of policy inference.
- Exploring richer security policy languages.
- Developing an Eclipse plugin for Fabric.
- Developing an Android version of Fabric.
is a new, secure voting system. Civitas is the first
voting system implementation that allows voters to vote securely from the
remote client of their choice.
A secure voter client that supports coercion resistance and cut-and-choose style
protection against malicious clients.
Additional tabulation mechanisms to protect against application-level DoS attacks.
Using threshold cryptography to improve availability of the system.
CIVS is the actively running voting system
that we developed and support. We have 17+ years of data from polls people
have run, including more than 13,000 polls and more than 300,000 votes.
This is a rich source of data about how preferential voting works in the
wild. It would be interesting to analyze this data to see how different
voting systems compare -- how often does IRV choose a non-Condorcet winner?
How often do different Condorcet methods disagree? And can we produce a
truly anonymized, publicly releasable version of the dataset that still
yields the same conclusions?
Polyglot: an extensible compiler framework for building extensions
to the Java programming language. Dozens of compilers have been built on top
of Polyglot by research groups all over the world, so work on Polyglot will
immediately be appreciated.
- Implement lambdas, default methods, and other Java 8 features. Currently Polyglot
implements Java 7.
- Add more features to JLang,
our LLVM back end for Polyglot. JLang supports ahead-of-time
compilation from Java to any architecture supported
by LLVM. Missing features include threads and (full)
Implement a back end targeting the recently released
Counterexample generation for more parser generators. Polyglot's parser
generator is easier to use than other parser generators because it
reports compact counterexamples when grammars can't be parsed. A nice
self-contained project with potentially high impact would be to extend the
Bison parser generator to implement this algorithm.
- Improve support for Javadoc, so that extended languages can generate documentation easily.
This can be built using Polyglot itself.
- Improve the support for easy development of Eclipse IDEs for extended languages.
- Extend the tutorial so developers can more easily learn advanced
features of Polyglot like program analysis, quasiquoting, and in-place translation.
- Course Management System.
The course management system used by the Computer Science Department
and now also hosted at CIT and used by other departments
was developed by students.
New team members are welcome.
[ CMS web site
| CMS system ]
- adding new scheduling and calendaring features,
- making it scale to the size of MOOCs
- developing the external API for integration with other services
- porting it (back) to Fabric.
- Also/A-mud: This
highly extensible MUD system has some interesting security mechanisms
built into its underlying programming language. However, its security
needs careful evaluation and perhaps extension. It seems to be a good testbed for
designing blockchain programming language security mechanisms. It would also
be interesting to explore whether the system can be made concurrent and
geodistributed, to support massive numbers of simultaneous players.
- Hierarchical partitioned searching: The classic single-player game
of Sokoban requires hundreds of moves of searching; fortunately, it has some
properties that makes it amenable to a new kind of hierarchical searching
algorithm. Other games like Go are encouragingly similar. Experience
in search algorithms and ML programming is important.
- netview: an intuitive distributed graphical network monitoring tool
- codewriter: a web markup language for high-quality
pretty-printing of program code on web pages, so program code
fills the available horizontal width while remaining readable.
- jshell: a shell interface with integrated Java and Windows
support, smoothly combining a language-based (console prompt) interface with
a icon-based graphical interface.
- JMatch: pattern matching and logic programming for Java.
Some papers on JMatch: [ Iterable Abstract Pattern Matching for Java (PADL'03), Interruptible Iterators (POPL'06) ]
- unifying pattern matching with predicate dispatch
- unifying pattern matching with lenses
- adding more powerful predicate solving using external solvers (SAT, numerical, ...)
- developing an Eclipse plugin using the Polyglot IDE
- Building an LLVM back end (based on JLang) that can exploit LLVM
coroutines to achieve excellent performance
The ultimate graphical diff-merge tool, supporting N-way merging, RCS/CVS support, and
editing. Related to other tools like
a viewer and editor for version-controlled files
under RCS and CVS. Rcsview helps the user to figure out a source file
evolved and to identify who's responsible for any given code segment.
this is both a powerful editor for drawings and animations,
and a constraint-based programming language.
Juno displays a view of the picture as it would appear if printed, and simultaneously displays a program in the Juno-2 programming language
that draws the picture. It also allows users to create their own
drawing tools. The project is to improve the UI to better support
the creation of user-defined tools.
This would involve programming in
one of the best languages ever designed.
Swift: A system for building secure web applications in
the Jif language. Client-side
secure and efficient to do so.
- partitioning for
- making client-server data synchronization