CS240h Final project

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, Thursday, December 15 12:15pm-3:15pm. Lunch will be provided. 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.

Any of the papers or techniques we discuss in class can be used as a inspiration for a project. Here are a few more specific ideas. This list will gradually expand as the course staff thinks of more suggestions. You are by no means limited to the list.

• Implement a system that safely incorporates untrusted code through the SafeHaskell extension. There are several possibilities:
  • You could implement "Haskell@Home"--a generalized version of services such as Folding@home and SETI@Home.
  • 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.
  • Implement some sort of end-user programmable web-site (like Wikipedia, but for code rather than for information).
  • Implement an online Haskell REPL environment such as Try Haskll. Using Safe Haskell and some of the recent support in GHC 7.3 for data declarations in GHCi you should be able to provide a far more powerful feature set then existing websites.
• Implement a parser library with a parsec-inspired interface, but that generates DFA-based parsers.
• Add garbage collection for dynamically-loaded code to GHC.
• 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.
• Develop a new generic programming or automatic-instance-generating system for Haskell, possibly using template Haskell or haskell-src-exts. This has been done before, but it is not hard to identify shortcomings of previous approaches that your implementation could remedy.
• 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.)
• Develop a high-level database interface for Haskell. HaskellDB is one example of an interesting way to leverage Haskell's type system to make type-safe SQL queries, but it's a bit hairy. Can you do something simpler for a no-SQL database? Or build a higher-layer RAILS-like object-relational mapping for Haskell?
• Implement RAMCloud bindings for Haskell and build an application in Haskell that takes advantage of RAMCloud's unique performance characteristics.
• Integrate Haskell into a web browser. There are several options for this:
  • Implement a GHC back-end for Google's Native Client environment.
  • Develop PPAPI (pepper plugin-api) bindings for Haskell.
  • Use ghcjs to compile Haskell directly to Javascript. Develop a library that shows off Haskell's flexibility for programming styles--for instance by supporting functional reactive programming along the lines of that provided by Flapjax.
• Put Haskell into an operating system kernel, and use it to allow untrusted extensions (like SPIN) or untrusted device drivers.
• 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.
• Add vector / SIMD support to GHC. This is a very heavily requested feature of GHC and is something that is really needed by the community given a lot of emphasis on parallel programming in Haskell. Here are some links to info about this:
  • GHC Wiki: Vector Computing
  • GHC Wiki: SIMD Computing
  • GHC Ticket 3557: Add vector opps
  The basics of this task shouldn't be that hard, especially if you only worry about supporting GHC's LLVM backend. Providing a nice API to the user though and then porting packages like repa would make this a nice project.
• 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.
• The TYPED research project is building a domain specific language (DSL), in Haskell, for computing on encrypted data. The DSL is a generic, but small, language that can target Secure Multiparty Computation (SMC), Fully Homomorphic Encryption, and other "secure platforms" (which you can help build). The group is looking to re-implement the DSL to use CloudHaskell and target additional back-ends (including, but not limited to, SMC with arithmetic sharing and the Paillier cryptosystem). If you are interested in a project that combines Haskell, cryptography, and networking contact Deian Stefan ([first name]@cs.stanford.edu) for more information and arrangements.
• A good place to find project ideas are one of these three places:
  • Haskell Summer Of Code
  • Reddit Haskell Proposals
  • GHC Task / Bug Tracker: Lots of things here so scan appropriately