Final project

You will complete a final project for CSCI 360 which brings together some of the ideas we have explored this semester.

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
  - Music
  - … 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, 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; or more sophisticated representations of name binding such as locally nameless style or (parametric) higher-order abstract syntax. 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

The project is due at 9am on Wednesday, December 5. During the officially scheduled CSCI 360 final exam slot from 9-11:30am, each student will give a presentation/demo of their project. It does not need to be a carefully planned, polished presentation, and the presentation will not be part of your grade for the project. 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.

Evaluation

The projects will be evaluated according to the following criteria.

Documentation (25%). The project should be well-documented, with plenty of comments explaining the code, thorough README and INSTALLING files, good examples (if appropriate), etc.
Code style (15%). Is the code nicely formatted and easy to read? (For example, take a look at this style guide for Haskell.)
Intellectual merit (30%). Does the project explore interesting ideas that go beyond what was covered in class? Is it relevant to the topic of the course? etc.
Effort (30%). Does the project represent an appropriate amount of effort, depending on the type of project and as explained in the README?