Accepted Summer of Code Projects

Scalable Remote Actors

Student: Stephen Tu
Mentor: Philipp Haller

This project aims to solve two main bottlenecks in the current Scala implementation of remote actors: Java serialization and blocking IO. The proposed solution is to build a fast serialization facility directly into Scala, using an existing serialization format (e.g. Apache Avro). To solve the blocking IO problem, an NIO-based net-kernel implementation will be explored.

ENSIME, a new Scala development environment for Emacs

Student: Aemon Cannon
Mentor: Hubert Plociniczak

Emacs modes usually lack sophisticated IDE functions such as type checking, type inspection and method completion. Since the introduction of the Scala presentation compiler, it is now possible for an IDE to interact directly with the Scala compiler, leveraging the core type checking and type inference support. The ENSIME project [1] aims to expose the Presentation Compiler to Emacs in a client/server architecture similar to SLIME, in order to provide advanced Scala IDE functionality to Emacs users.

Screencast [2] of preliminary features now available!

Lift and SBT template engine

Student: Mads Hartmann Jensen
Mentors: David Pollak and Tim Perrett

Lift [3] is a cutting edge web framework written in Scala. Soon, SBT (Simple Build Tool) [4] will be the default built tool used with Lift apps, which opens up some new opportunities. The idea is to leverage the power of SBT-processors to make the deleting and creating of source files easier.

The final product will include two artifacts:

SBT-templating. A template engine that allows SBT processor writers to easily generate and delete source files. The engine will be able to handle existing files and things, as well as option parsing to ease the work-load of potential users. A processor using this engine would look like this:
```
> processor-name <create | destroy> <thing-to-create-or-delete> <args this thing needs>
```
Lift-SBT. A SBT-processor that uses the template engine to manage lift-specific thing-to-create-or-delete. The processor will be able to manage (at-least) the following things: 'app-blank','app-basic', 'snippet' and 'model.'

Though the second part is Lift specific, any other project should be able to benefit from the SBT-templating framework.

Hardware Accelerated 2D Graphics

Student: Dariusz Kosz
Mentor: Ingo Maier

The Java platform provides a relatively sophisticated 2D graphics interface that can target different GPU accelerated backends. Unfortunately, there is no API to these backends so that clients can make use of GPU shaders directly. This project will involve developing a 2D graphics API that implements most of Java2D's functionality on top of OpenGL (LWJGL/JOGL) that lets programmer make use of fragment shaders (and possibly geometry/vertex shaders as well) for visual effects.

Adding LINQ-awareness to Scala.Net

Student: Bartosz Lipinski
Mentor: Miguel Garcia

A productivity feature that seasoned .NET developers want to keep from C# is LINQ, not so much because of its notational convenience (Scala has supported comprehensions since the start) but rather due to the accompanying tooling that realizes most of what we perceive as "LINQ power" (e.g., Object- Relational Mapping, query shipping and server-side optimization, etc.) It makes sense thus make Scala.Net play a good host for embedded LINQ queries by:

desugaring LINQ syntax into plain method calls, i.e. into Standard Query Operators (SQO) invocation and by
reifying SQO expressions into the "format" expected by (third-party) authors of Query Providers

Advanced Semantic Tools for the Scala IDE for Eclipse

Student: Mingjian Jin
Mentor: Miles Sabin

The Scala programming language has a number of features which would benefit from additional feedback in programming tools and IDEs. This project will explore the following ideas:

A mechanism for showing inferred type hovers for expressions (currently inferred types can only be shown for simple terms).
Visual indicators of the application of implicit conversions and the provision of implicit parameters.
A mechanism, possibly similar to code folding, for transiently expanding inferred types and implicit conversion and parameters inline in source text.

Collaborative Scaladoc

Student: Petr Hosek
Mentor: Gilles Dubochet

This project eases the contribution of Scala API documentation. The goal of this project is to design and write a collaborative editor for API documentation, most likely based on wiki technology. A secondary goal is to explore specific social issues related to collaborative editing of API documentation.

Outline of possible implementation:

The existing Scaladoc 2 [5] web frontend is extended into a web application (possibly using Lift [6]) that offers in-place, wiki-like editing of comments. The underlying server collects edits.
An IDE plugin (based on the existing XML-Scaladoc patching tool [7]) or a standalone tool is used to select acceptable edits, patch the source code, and resolve conflicts.

Summer of Code Scala Projects