Google Summer of Code 2012 Project Ideas

Project Ideas

Core Clojure

Clojurescript

Mobile

Tooling

Enhancing Clooj IDE

Brief explanation: Clooj (https://github.com/arthuredelstein/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.

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: TBD

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