Versions Compared

Key

  • This line was added.
  • This line was removed.
  • Formatting was changed.
Comment: Candidates are irrelevant

...

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

Previous year's Project Ideas

Please see the Google Summer of Code 2012 and the 2013 Project Ideas 2013 for examples of project ideas.

Project Ideas

Info

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

Core Clojure

Lean JVM Runtime

Brief explanation:  The current Clojure/JVM runtime is fully-featured, and can become even more fully-featured with projects like core.typed.  However, sometimes it is important to have a leaner runtime that is less resource-intensive.  This is ideal for instances where Clojure serves primarily as a library or in lean runtime environments like Google App Engine or Android where a quick startup is desirable.  The goal of this project would be to create an alternative lean Clojure runtime and associated compiler.  The compiler may be based either of the standard compiler or the ClojureScript compiler.  Clojure vars would compile to static fields or methods.  It will be necessary to find out which subset of the language makes sense (for example, vars would probably not really exist anymore).

Expected results: A lean Clojure runtime and compiler (well, some good progress to this end)

Knowledge prerequisites: A thorough understanding of Clojure and some familiarity with byte code generation for the JVM.

Difficulty: Hard

Mentor: Daniel Solano Gómez

 

Numerical Clojure

Many of us are working to make Clojure into a great platform for Data Science, Big Data and numerical computing. See the Numerical Clojure Group for ideas and discussions. There are many opportunities to take on exciting projects in this space - a few ideas are listed below:

Linear Algebra for Clojure

Brief explanation: core.matrix provides a powerful and flexible API for array programming and numerical computing in Clojure. To take this to the next level, it is important to implement a suite of linear algebra algorithms - including various matrix decompositions (SVD, QR, Cholesky etc.....), linear system solvers etc. These need to be added both to the core.matrix API, and to one or more core.matrix implementations. A good option would be to add these algorithms to vectorz-clj, which is a well-maintained core.matrix implementation that runs 100% on the JVM. It would be possible to port or adapt existing Java algorithms (e.g. from EJML). Our goal would be to match / exceed the performance of other Java-based libraries - see the Java Matrix Benchmark

Expected results: A clean, well-defined API for linear algebra in core.matrix. Fast working implementations of the API added to vectorz-clj, with performance comparable to the best libraries in the Java Matrix Benchmark

Knowledge prerequisites: Mathematics / linear algebra, Java, Clojure

Skill Level: Hard

Mentor: Mike Anderson

GPU.matrix 

Brief explanation: core.matrix provides a powerful and flexible API for array programming and numerical computing in Clojure. It should be possible to create an implementation for core.matrix that performs computations on the GPU. Ideally, matrices would be retained in GPU memory as much as possible, to avoid unnecessary copying to/from main memory.

Expected results: A full core.matrix implementation with GPU-based array storage and GPU-accelerated operations. Benchmarks to demonstrate clear performance gains over non-GPU approaches for key operations (e.g. matrix multiplication)

Knowledge prerequisites: Mathematics / linear algebra, Clojure, GPU programming

Skill Level: Hard

Mentor: Mike Anderson (core.matrix aspects) - Timothy Baldridge (GPU aspects)

Incanter + core.matrix integration

Brief explanation: core.matrix provides a powerful and flexible API for array programming and numerical computing in Clojure. Incanter is a platform for statistical computing and graphics. Bringing the two together would create a powerful combination. 

Expected results: Incanter modified to take full advantage of core.matrix. 

Knowledge prerequisites: Statistics, Mathematics, Clojure

Skill Level: Hard

Mentor: TBC

HDF5 interface for Clojure + core.matrix integration

Brief explanation: HDF5 is a flexible and widely used file format for storing large datasets, in particular in the form of arrays and tables. There is a rudimentary Clojure interface, but it isn't nearly as full-featured and flexible as interfaces for other languages. Ideally, a Clojure interface would integrate with core.matrix to present datasets as arrays-on-disk, following the example of the h5py interface library for Python which succeeds very well at this.

Expected results: A much improved HDF5 interface for Clojure.

Knowledge prerequisites: Clojure, Java and some JNI (to understand the Java-HDF5 interfaces)

Skill Level: Medium

Mentor: Konrad Hinsen

ClojureScript

Quil on ClojureScript

Brief explanation: Quil is a drawing and animation library for clojure. It is basically wrapper over Processing. Currently Quil works only on vanilla clojure (JVM based). It would be cool to have it also on ClojureScript. Processing already have javascript version: Processing.js, so it can be used for our goals.

Expected results: quil clojurescript library capable of running regular quil sketches, documentation how to use it in clojurescript project.

Knowledge prerequisites: familiarity with clojurescript, javascript

Skill Level: Medium

Mentor: Nikita Beloglazov (nikelandjelo@gmail.com)

Typed ClojureScript Annotations

Brief explanation: Typed ClojureScript is an optional type checker for ClojureScript. Many annotations are missing for the core ClojureScript libraries, which means using the type checker is more painful than it should be. This project involves annotating these core libraries like cljs.core so most of the core annotations are included in the type checker. This is a great project to get familiar with ClojureScript, Clojure, and/or Typed Clojure.

Expectations of student: The student is not expected to make changes to the type checker, but rather identify areas that need improvement to meaningfully annotate the libraries and report them to the Typed ClojureScript maintainers. No particular prior experience with Clojure, ClojureScript, Typed Clojure or type systems is required, but the student is expected to learn quickly from their mentor who will bring them up to speed with any relevant area.

Difficulty: Variable, accommodates to any skill level

Expected results: increased familiarity with ClojureScript/Clojure, annotations for core ClojureScript libraries, identified required improvements to type checker

Mentor: Ambrose Bonnaire-Sergeant (abonnairesergeant@gmail.com)

Data Visualization Components with Om / React.js 

Brief Explanation: React.js provides a natural model for transforming declarative data into interactive interfaces. Om is a powerful Clojurescript interface to React. This project will develop reusable Om components for data visualization, which could be used in conjunction with libraries like Incanter, or for stand-alone applications. React supports SVG out-of-the box, so that will be the initial visualization target.

Expected result: A set of standard visualization components covering the common types, built using Clojurescript and Om. If time allows, the student will have the option of either A) extending the React model to Canvas to achieve higher-scale visualization, or B) develop a visualization subarea in greater detail, for example map projections.  

Difficulty: Variable, accommodates to any skill level. Some components will already be in place for the student to follow as an example. 

Mentor: Kovas Boguta (kovas.boguta@gmail.com)

Tooling

Dynalint: Improved Core Clojure errors and warnings

Brief explanation: Error reporting has been identified as a common complaint of Clojure in the latest Clojure Survey. In many cases, addressing these concerns directly in the core Clojure implementation would degrade performance, while an explicit "strict" or debug mode for Clojure would require extensive changes to Clojure core. Dynalint takes another approach: it is an external tool that can "instrument" core Clojure functionality to emit warnings and better errors. This approach has some limitations, but it can quickly make headway in an area that Clojure struggles with.

Expected results: A comprehensive suite of useful warnings and errors for the (near) latest version/s of Clojure.

Knowledge prerequisites: None

Difficulty: Easy

Mentor: Ambrose Bonnaire-Sergeant