Error formatting macro: pagetree: java.lang.NullPointerException

Versions Compared


  • This line was added.
  • This line was removed.
  • Formatting was changed.
Comment: Add Alms port project


If you are not a developer but have a good idea for a proposal, get in contact with relevant developers first.

Google Summer of Code 2012 Project Ideas

Please see the Google Summer of Code 2012 for examples of project ideas.

Project Ideas


Please organise your project idea into a category below. Feel free to create new categories if needed.

Core Clojure




Enhancing Clooj IDE

Brief explanation: Clooj ( is already a good IDE for Clojure beginners to start with, if they do not already have a preferred development tool set.  It is the easiest to install.  There are ideas for enhancements in the Issues tab of the project.

Expected results: An enhanced version of Clooj that fixes existing issues, adds new features, etc.

Knowledge prerequisites: The student would need to know or learn Clojure, and something about GUI development using Java Swing, the GUI library currently used by Swing.

Mentor: Arthur Edelstein, the developer of Clooj, would be an ideal mentor, if he has the time and interest in doing so.  No one has yet approached him with this possibility that I am aware of.

Type Systems

Preparing core.typed for real world usage

Brief explanation: core.typed (aka. Typed Clojure) has a reasonably solid foundation, taking inspiration mainly from Typed Racket. There are several key missing parts that prevent it from being used seriously.

Expected results: 

  • More complete multimethod support
    • eg. multiple dispatch
  • Support for function keyword arguments
  • More core functions/methods assigned types
  • Should understand common control flow idioms across body expressions
    • eg. function preconditions, assertions bound to throwaway locals like _
  • Improve Java method inference for method calls that the Clojure compiler does not already infer
  • Namespace management tools
    • eg. typed-require, typed-use, typed-load
  • Contract generation from types
    • Useful for preserving static type invariants when using typed code from untyped code.
  • More comprehensive handling of complex operations
    • eg. assoc, dissoc, update-in, assoc-in, get-in
  • Be able to successfully type check the current ClojureScript compiler
  • "Wrapper" types
    • eg. SQLSafeString
  • Better design metadata types
    • especially for `with-meta`
  • Add support for Clojure Records
    • implement correct behaviour for when all base keys are dissociated (a record loses it's type)
  • Design solutions to correctly handle macros with complicated expansions.
    • especially `for`, `dotimes`, `doseq` etc.
  • Design a type generalising scheme to help better guess the type of loop variables
    • eg. (loop [a 1] ...) ; a should probably be Long, not the type (Value 0)
    • harder: (loop [a nil] ...) ; should be (U nil (Seqable Any)) ?
  • Design a sound solution for boxed/unboxed positions
    • Often doesn't make sense to give a function a primitive return.
    • eg. `int` should probably be something like `(MaybePrimitive int)`
    • Target Clojure 1.5 boxing semantics
  • Understand common higher-order functions in non-higher-order contexts
    • eg. juxt, every?, comp, partial, etc.

Knowledge prerequisites: 

  • Reasonably complete knowledge of core.typed or Typed Racket internals

Mentor: TBD (Candidates: David Nolen or Ambrose Bonnaire-Sergeant)

Improve local type inference in core.typed (via Alms)

Brief explanation: Local type inference in core.typed (aka. Typed Clojure) is based on Pierce and Turner's Local Type Inference. LTI's strength is in its simplicity, but the authors note that squeezing just a little more inference adds significant complexity to the implementation. A particularly annoying prerequisite is that LTI requires that all function arguments be annotated with a static type.

Alms is a new language most notably featuring affine types. It includes a novel implementation of local type inference that can infer more accurate types for some function arguments. The algorithm is described in Chapter 6 of Jesse A. Tov's PhD dissertation.

The algorithm used for local type inference in Alms could be applied to core.typed 

Expected results: ? (Prototype, document, evidence of incompatibility)

Knowledge prerequisites: Difficulty: High.

Mentor: TBD (Candidates: Ambrose Bonnaire-Sergeant)