=====================[ Proposing a project ]===================== Send me an email with your proposed project description, in the following format: the task, the language(s) you'd like to use; and whether or not you want to work with a partner. Team projects are welcome but their goals would need to be more ambitious. I will respond to your email either with an "Ack", which means that I approve of the task and scope, or with specific suggestions for features to implement, or with an alternative project suggestion. The projects will be due on December 2 (because my final grades are due to the Registrar at noon December 4). ---------------------[ What to submit ]--------------------- A project writeup, in PDF, ACSII plaintext, or Markdown, and your code as a tarball or a link to your Github or Gitlab project repository. Please no MS Word files. ---------------------[ Recommended topics ]--------------------- Re-creating limited implementations of LISP or Scheme are a classic for PL classes. You may focus on lexical scoping & closures, garbage collection, or continuations. Exploring the continuation-passing style and programming of searches with continuations (cf. OnLisp chapters 20+) is welcome. A Haskell project in the character of the concluding chapters (20--28) of the Real World Haskell book, for a comparable task, would be a very good choice. --- I am very interested in projects that expose the internals of languages or advanced language features, and explore their implementations. For example, exploring the bytecode of the Java virtual machine and the implementation of the newer Java Generics (https://en.wikipedia.org/wiki/Generics_in_Java) would make a very good project. You'll we expected to first survey the tools that already exist, describe the language implementation mechanisms, then add a tool of your own. For C++, you may explore advanced features of the language and their implementations. You may recall that C++ template are Turing-complete: http://matt.might.net/articles/c++-template-meta-programming-with-lambda-calculus/ A good demo of this beyond the existing code would make a good project. Compiler plugins are a very important developing technology, which rose to prominence with LLVM. Exploring them and applying them to a code base of your choice would make a good project. You project may also dig into the implementation and runtime systems of newer languages such as Swift, Go, Clojure, or Scala. A good scope would be to look at a characteristic feature that the language features as an advantage over others, and see how it is implemented. --- Instrumenting interpreters or compilers, or dissecting compiled binaries is always welcome. For example, a good project would be a decompiler for Elisp, which would start with Elisp bytecode and try to recover the program as much as possible. Adding bytecode-level tracing functionality to Emacs' Elisp would be an excellent project. Currently, Emacs supports some tracing an profiling, but does not allow you to check how many cons cells you created and which byte codes you have run. Adding this functionality would be great. Ruby has a very rich tracing framework, with which you can change the language almost entirely; see https://aphyr.com/posts/173-monkeypatching-is-for-wimps-use-set-trace-func Writing your own tracer that would reveal how closures and continuations work in Ruby would be a great project. You may also choose to instrument Ruby's C code (it's all open source!) to catch the action of creating closures and, in particular, of copying frames from the stack to the heap. You can also look into how continuations are implemented. --- Looking into the algorithmic internals of modern languages such as the Unification algorithm used by Haskell's and Ocaml's type inference would make a nice project. Implement the unification algorithm in you favorite language and check that it actually derives the same types. Looking into the history of programming languages will make a good project. For example, your Mitchell textbook covers Prolog, the logical programming language where Unification first became a language built-in. Read about Prolog and write programs in it so solve algorithmic puzzles such as "8 Queens", "Sudoku", or similar. --- Studying package and library systems would also make a fine project, as these systems make an important part of any modern ecosystem (and even Lisp now has Quicklisp with a variety of packages; Ruby has Gems, Haskell has Cabal, and so on). Your project may (and I would like it to!) grow into a senior honors thesis, such as http://www.cs.dartmouth.edu/reports/TR2011-686.pdf (the code is at https://github.com/michaeledgar/reversal/). Interestingly, this thesis gave rise to further interesting work in de-obufscation, which instrumented the Ruby VM: https://www.insinuator.net/2016/04/unrubby-reversing-without-reversing/ https://github.com/richo/unrubby/ Projects to further instrument these are welcome! --- Finally, picking a functional language of your choice and showing off its power by writing a small (remember, we want to show off the power of the language, so use the available libraries freely!) but useful program like an app, a network bot, or a server for some useful task will be welcome, too, so long as it showcases the language well. For the last part, feel free to explore how Emacs Lisp programming works, especially in these useful modes as language modes. I have some ideas to Emacs modes I'd like to have, e.g., some features added to the http://jblevins.org/projects/markdown-mode/---so if you fancy Emacs, ask me about these tasks! Implementing an Emacs mode to help editing your favorite kind of text will be a good project.