=====================[ 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, - whether it's an individual or a team project, - generative AI mode: whether your code will be hand-written or generated. Team projects are welcome but their goals would need to be more ambitious. AI-aided projects are welcome but would need to justify their use of AI with a sufficiently larger scope and complexity. For example, AI would be appropriate for adding non-trivial features to large mature production code bases. Please note the specific AI model and add any observations of its successes and failures. For hand-written code projects, using AI agents for small worked examples and questions about the language, the standard libraries, and the system is OK, but the code must be your own. I will respond to your email either with an ACK (an acknowledgment), 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 before December 1, because my final grades are due to the Registrar at noon of December 2. ---------------------[ 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 or Google Doc links (as I am not a frequent user of Google services, I get way too many pictures of street lights, bikes, etc.) ---------------------[ Classic 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. These projects MUST be hand-written. 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. These project MUST be primarily hand-written, with AI-generated parts clearly marked. ---------------------[ PL internals projects ]--------------------- I am very interested in projects that expose the internals of languages and/or advanced language features, and explore their implementations. For example, exploring the bytecode of the Java, Ruby, Python, Scala, or Clojure 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 Rust, 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. ---------------------[ Instrumentation projects ]--------------------- Instrumenting interpreters or compilers, or dissecting compiled binaries is always welcome. For example, a good project would be a decompiler for Emacs' eLisp, which would start with Elisp bytecode and try to recover the program as much as possible. Adding bytecode-level tracing functionality to 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. Visualizations of these processes would be an appropriate use of LLMs. ---------------------[ Algorithmic internals of PL ]--------------------- 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. For a _hand-written_ project, implement the unification algorithm in your favorite language and check that it actually derives the same types (compare with Maxwell Bernstein's implementation of Algorithm W and Algorithm J in Python; or Cornell lectures' implementations in OCaml). ---------------------[ Formal methods projects ]--------------------- Formal methods are rapidly gaining ground in PL. You are encouraged to pick projects that use Rocq, Lean, ACL2, Adga, Idris2, Dafny, Isabelle/HOL, or any other historical theorem provers (see https://homepages.inf.ed.ac.uk/wadler/topics/history.html, https://sdiehl.github.io/zero-to-qed/03_theorem_provers.html https://pqnelson.github.io/2020/03/27/automated-theorem-provers.html, etc.) Each of these theorem provers comes with its own programming language. Using these languages and proofs to create programs that provably _eliminate common classes of bugs_ in the domain of your choice would make a great project! ---------------------[ PL and theorem proving history ]--------------------- 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 HAND-WRITE programs in it to solve algorithmic puzzles. Start with the classic 8 Queens and Sudoku-like puzzles, and work your way to a unique puzzle of your own. ---------------------[ The Sinews of Systems ]--------------------- Studying production language package and library systems would also make a fine project, as these systems make an important part of any modern ecosystem. Common Lisp now has Quicklisp with a variety of packages, Ruby has Gems, Haskell has Cabal, and so on. They all fall back to the Executable and Linkable Format (ELF) on Unix, Mach-O on MacOS, PE on Windows. ---------------------[ From a project to an thesis ]--------------------- 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! ---------------------[ A language show-and-tell ]--------------------- 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. These projects MUST be hand-written. Finally, 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.