The final lab assignment for the class is to undertake a mini research project of your choice involving Haskell in a group of 1-3 people. At the end of the term, in addition to the code, you will turn in a short (4-8 page) paper describing your project. You will also present and demo your results in a mini-conference held during the class's final exam period. Make sure you can attend this final exam, as your group's presentation will be an important part of your final grade.
If your project overlaps with your research, this is not a problem. We actually encourage this. However, if your final project overlaps with a project for another class (including an independent study you are taking for credit), you must obtain permission from the instructor of the other class in an email CCed to the CS240h staff mailing list.
We require that you submit a written proposal for your project early on in the quarter. This is not a graded assignment, we just want to make sure you are on track and have a chance to give feedback early if we think there are issues with what you intend to do.
Submitting: Please email the staff mailing list with your project description
- Team members (1-3 people)
- Few sentences describing your project and what you will deliver by the end of the course
- If this project overlaps with work you are doing in another class or in your own research
- Paper describing what your project (4-8 pages)
- Code you implemented
- 5 minute presentation of your project at a miniconference (instead of final exam)
You are not limited to this list, this is just a starting point.
Implement a parser library with a parsec-inspired interface, but that generates DFA-based parsers.
- Map Reduce & Paxos
Implement any of the popular Google programming abstractions (Chubby, Map-reduce, BigTable) or related ideas (such as Ciel or Paxos-based data storage) in Haskell.
Implement an in-memory database (or disk backed). Could explore how to use Haskell's concurrency support (such as STM) for achieving high-performance transactions.
- Haskell Operating System
Put Haskell into an operating system kernel, and use it to allow untrusted extensions (like SPIN) or untrusted device drivers.
- Re-execution Monad
Develop a Monad with an IO-like interface, but that logs all IO actions (such as changes to memory or the file system) in such a way that they can be undone. Hence, the execution of a program built on this interface can be reversed for debugging or failure recovery purposes.
- Static Analysis
Build a useful static analysis tool and framework for Haskell. Even just a tool for code exploration (call-graph visualization for example) could be very useful.
- Haskell Language Extension
Develop an extension to the Haskell language that increases expressiveness.
For instance, the simple ability to require the inequality of two type parameters in class instance declarations would allow all kinds programming techniques that today require the frowned-upon OverlappingInstances extension.
- GHC Haskell Compiler
Do some work on improving the LLVM backend of GHC. There are a list of ideas for work that needs to be done on the LLVM backend here.
- Domain Specific Languages
Create a domain-specific language. For example, you might write a DSL for generating efficient Verilog state machines from high-level descriptions.
- Safe Haskell Projects
Implement a system that safely incorporates untrusted code through
extension. There are several possibilities:
- Online GHCi
Implement an online Haskell REPL environment using Safe Haskell. A prototype of this that can be used as a starting point is ghc.io, written by the course TA, David Terei. The existing code for this can be found on github.
Fun extension beyond the simple task of executing code, is to allow user written plugins to be deployed against the site so that it can be extened with extra services.
- Haskell Execution Bot
You could implement a 'bot that executes untrusted code along the lines of Lambdabot. Lambdabot was written before Haskell was typesafe, and as a result is fairly hairy code and very limited in functionality. Using type safety you ought to be able to achieve something much cleaner and simpler, and that provides far more functionality.
- Haskell Code Wiki
- Implement some sort of end-user programmable web-site (like Wikipedia, but for code rather than for information).
- Other Ideas
- You might find other good ideas in one of these places: