Final project

You will complete a final project for CSCI 360 which brings together some of the ideas we have explored this semester. You may work on the project either individually or in a pair.

Topics

The topic of the project is open-ended; the only requirements are:

• The project must (of course) explore one or more programming languages or programming language features.

• The project must include a significant programming component.

It will likely make the most sense for the programming to be done in Haskell, but this is not required.

Some possibilities include:

• Design and implement a language, in a way similar to what we have done with many of the modules and projects this semester. The language could be a standalone language or an EDSL.

  • For example, you could pick a domain that seems interesting to you and design a domain-specific language for it. You might design a language for computing with
    • Sets
    • Vectors and matrices
    • Dates and times
    • Logic puzzles
    • Logic circuits
    • Newtonian systems
    • Sound or music
    • Knitting or crochet patterns
    • Text adventure games
    • … the possibilities are endless! …
  • You could also take one of the languages we developed this semester and extend it in some nontrivial ways.

• Explore a language feature or implementation technique beyond what we have covered in class, such as, but certainly not limited to:

  • Recursive functions
  • Type reconstruction (i.e. how to infer All The Things, via solving systems of constraints)
  • Polymorphism (i.e. how Haskell’s type system has type variables which can be instantiated with any type)
  • Continuations
  • More sophisticated ways to represent variable names such as locally nameless style or (parametric) higher-order abstract syntax.
  • Linear types / uniqueness types / borrow checking

  The best way to approach such a project would be to start with a question like “How does X work in language Y?” and then talk to me about it, and I can point you in the direction of relevant resources.

• Explore a classic (or recent) PL paper and implement some of the ideas contained in it. This could be a really fun and worthwhile project, but it’s hard to list potential examples in advance. If you are interested in a particular topic, come talk to me and I can help you find an appropriate paper.

• Contribute to an open-source language implementation. For example:

  • GHC itself is implemented in Haskell.
  • Idris is a dependently typed functional language implemented in Haskell.
  • Disco is a functional programming language I am developing for teaching discrete mathematics.

Requirements

You must turn in a 1-2 paragraph proposal explaining your chosen final project topic by Monday, April 17th.

The project is due at 8:30am on Thursday, May 4 (though you may turn it in earlier to receive feedback). During the officially scheduled CSCI 360 final exam slot from 8:30-11:30am, each group will give a presentation/demo of their project. It does not need to be a carefully planned, polished presentation; just explain what you did and/or show us some cool examples.

You should turn in:

• Your code: submit either

  • All the source files, or
  • A URL linking to a repository on github or something similar. (For example, if you contribute to an open-source project you should submit links to your pull requests.)

• A README file, formatted either as plain text, markdown, or LaTeX. In your README you should:

  • Explain the overall idea of your project.
  • Highlight any particularly interesting/challenging features.
  • Explain the other files that are part of your submission. Help me to understand and evaluate your project. For example, you might say “First, take a look at Foozle.hs. This defines the basic Wibble types that are used by the rest of the project. examples/Wibble.plj shows an example of using a Wibble type. Then look at Quux.hs, which…” and so on.
  • Include a section explaining the effort you put into the project, especially if you complete a project where your effort is not obviously reflected in the code: for example, if you spent a lot of time reading about some language feature, or figuring out how to contribute to some open-source project, or writing some code that you later deleted, etc., you should clearly explain that.

• A file named INSTALLING with step-by-step instructions for how to build and test your project. For example, it should list any packages needed from Hackage, any other tools needed, etc. It could also include URLs linking to other instructions—for example, if you contribute to some open-source language implementation you will probably want to link to existing instructions for building that project.

• Optionally, you may want to include a directory named examples containing some example programs, example executions, example outputs… or whatever is appropriate.

Specifications

• To complete the project to Level 1, you must fulfill the requirements listed above:

  • you must turn in a 1-2 paragraph proposal;
  • the project must explore a topic relevant to the course;
  • it must compile and run successfully; and
  • you must give a presentation/demo of your project during the scheduled final exam period.

• To complete the project to Level 2:

  • Ensure that your code uses good Haskell style.

  • Make sure your code is simplified as much as possible, for example, without redundant pattern-matching.

  • Turn on {-# OPTIONS_GHC -Wall #-} and make sure your code generates no warnings.

  • Ensure your project is well-documented, with plenty of comments explaining the code, thorough README and INSTALLING files, good examples (if appropriate), etc.

• To complete the project to Level 3, the project must go beyond the content of the course in some significant way. I am aware that this is rather vague; if you would like to get Level 3 credit for the project, I encourage you to talk to me about it during the planning phase so that we can agree on an appropriate topic, and get feedback from me before the final deadline to make sure you are on track.