Hannes Mehnert

• Implement a parser library similar to camlp5 (to allow correct parsing of Coq)
  

• Improve Coq perspective of Eclipse
  The Coq perspective is currently shipped with Eclipse. It would be good to separate it into a disjoint plugin. Also some features are missing like Search/SearchAbout and other useful stuff. Once that is done, a content assistant (completion) could be developed.
• Translate specifications (JML, Plural, …) into higher-order separation logic specification
  Parse the JML (or Plural or some other) specification and transform it to our higher-order separation logic specification. With this in place, we could reuse and proof case studies developed with JML or Plural.
• Port to 64 bit
  
• Improve Windows port (especially sending interrupt to coqtop)
  
• https://github.com/hannesm/Kopitiam/blob/master/TODO.org
  

• Interactive Code Browser (CodeBubbles) via Web (JavaScript)
  The compiler provides an amazing amount of data via an API, it would be nice to have an interface via a web browser for this. A nice case study what can be achieved with HTML5 and Javascript. http://www.cs.brown.edu/people/acb/codebubbles_site.htm

  This has been worked on http://turbolent.github.com/hula-presentation/

• Replace frontend with different syntax (LISP / PLOT)
  The syntax of Dylan is Algol-like. PLOT looks similar, apart from the macro system. The amount of punctation needed is lower. http://users.rcn.com/david-moon/PLOT/ Another project would be to write a compiler frontend which is able to parse the old Dylan syntax (LISP-style).
• Implement Link Time Optimization for Open Dylan
  Inter-library dependencies can be resolved at link time solely. Currently every library contains every defined method, initialized constants, etc. The idea of link time optimization is to remove the unreachable code, resulting in a smaller binary and a faster startup time. Since the Open Dylan compiler has all the information which application to build, it could, instead of building a lot of shared objects, build a statically linked library with only those definitions and initializations required.

  A rough sketch for LLVM is available: http://llvm.org/docs/LinkTimeOptimization.html

• Speedup generic function dispatch
  More efficient dispatch (by being deterministic), as mentioned in Eric Kidd's 'Efficient Compression of Generic Function Dispatch Tables', should be possible now that C3 is integrated. http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.68.9146&rep=rep1&type=pdf
• Speedup runtime
  Yoav Zibin PhD thesis has a great collection of efficient algorithms for object-oriented runtime. http://www.flashtogether.com/yoavzibin/publications/my-thesis.pdf
• Implement 'hot code update' for UNIX
  Compiling and uploading expressions into a running binary. There is already support on Windows, but UNIX lacks this support.
• Implement elisp frontend for deuce
  Deuce is an editor similar to emacs, but has for example polymorphic buffer pointers. This editor should be enhanced to be able to use elisp code, and thus running a huge amount of modes from emacs natively.
• Design and implement test suite for compiler
  Testing compiler optimizations and typist is a non-trivial task. The frontend is not so much of interest, but rather are optimization and type inference. The input and output of these phases are in the intermediate language, which doesn't have a reader by now.

There are two open source implementations, both written in Dylan: Gwydion Dylan (originally developed at CMU) which compiles Dylan to C, but has no thread support; and Open Dylan (formerly Functional Developer, developed at Harlequin), which compiles Dylan to either x86 assembly or C code. Open Dylan has an IDE (currently only on Windows) which supports debugging, REPL, etc.