- Information for Students
- Adding a Proposal
- Google Summer of Code 2012 Project Ideas
- Project Ideas
Information for Students
These ideas were contributed by our developers and users. They are sometimes vague or incomplete. If you wish to submit a proposal based on these ideas, you may wish to contact the developers and find out more about the particular suggestion you're looking at.
Being accepted as a Google Summer of Code student is quite competitive. Accepted students typically have thoroughly researched the technologies of their proposed project and have been in frequent contact with potential mentors. Simply copying and pasting an idea here will not work. On the other hand, creating a completely new idea without first consulting potential mentors is unlikely to work out.
If there is no specific contact given you can ask questions on the general Clojure Google Group - http://groups.google.com/group/clojure
Adding a Proposal
Please follow this template. If you don't have Confluence access please submit your idea, following this template to the clojure mailing list with the subject prefix
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.
Please organise your project idea into a category below. Feel free to create new categories if needed.
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.
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.
- 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.
- 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)