This year the Scala team applied for the third time for the Google Summer of Code [1] program to work with enthusiastic students on challenging Scala projects and got accepted again!

What is Google Summer of Code

Google invites students to come up with interesting, non-trivial problems for their favourite open-source projects and work on them over the summer. Participants get support from the community, plus a mentor who makes sure you don't get lost and that you meet your goals. Aside from the satisfaction of solving challenging problems, students get paid for their work. But wait, there's more! Successful participants also receive an official Google Summer of Code t-shirt! This is an incredible opportunity to get involved in the Scala community and get helpful support along the way.

Project Ideas

Below we have collected a list of project ideas. The suggestions are only a starting point for students. We expect students to explore the ideas in much more detail, preferably with their own suggestions and detailed plans on how they want to proceed. Don't feel constrained by the provided list! We welcome any of your own challenging ideas, but make sure that the proposed project satisfies the main requirements mentioned here below.

How to get involved

The best place to propose and discuss your proposals is our "scala-language" mailing list (scala-language @ Google Groups, instructions to subscribe are available at http://www.scala-lang.org/node/199#scala [2]). This way you will get quickly responses from the whole Scala community.

Previous Summer of Code experience

This is the third time Scala team will apply for the GSoC. We had 6 projects in 2010 edition and 4 in 2011 and they were widely accepted by the Scala community. We encourage you to have a look at our Summer of Code 2010 [3] and 2011 [4] page to get an idea on what we and you can expect while working on Scala.

Please make sure to read carefully the instructions at the end of this page for requirements and submission details.

Project Ideas

Here are some project ideas for you (our community members have posted more on the mailing list so have a look there as well):

Porting Parallel Collections to the Android Platform

Parallel collections [1] available in the Scala programming language since version 2.9 [2] are an easy way to leverage parallelism for multithreaded applications which are data-parallel. They parallelize bulk operations like collection traversal, transformation or filtering. This framework is generic in the sense that it can be extended with new collection types and it's modular in the scheduler implementation. Parallel collections can also be used from within Java, at the cost of a less clean syntax. Scala applications and libraries are compiled to the JVM bytecode, so they can easily be ported to the Android platform [5] [6].

Parallel collections have shown to be a useful extension to the Scala collection framework and can bring significant speedups for the JVM programs. With the arrival of the new multicore devices for the Android platform, an opportunity presents itself to port parallel collections to mobile devices and tablets. The goal of this project is to implement a task scheduler for the parallel collections on the Android platform, based either on a port of the fork-join pool for Java [3] [4] or the thread pool executors available on the Android platform, followed by a detailed performance evaluation to see how big the benefits are on Android.

[1] http://infoscience.epfl.ch/record/150220/files/pc.pdf [5]
[2] http://www.scala-lang.org/api/current/scala/collection/parallel/ParIterableLike.html [6]
[3] http://docs.oracle.com/javase/tutorial/essential/concurrency/forkjoin.html [7]
[4] http://gee.cs.oswego.edu/dl/cpjslides/fj.pdf [8]
[5] https://github.com/jberkel/android-plugin [9]
[6] http://lampwww.epfl.ch/~michelou/android/scala-to-android.html [10]

Interactive Documentation

Projects like code school [11], responsible for efforts like tryruby.org [12] have recently generated a lot of interest and positive feedback, for their ability to integrate live code examples with documentation in their "learn by doing" approach. Meanwhile, Scala's documentation effort at docs.scala-lang.org [13] remains a completely static project. The goal of this project would to bring the functionality of a site like tryruby.org [14] or simplyscala.com [15] to the Scala documentation site, on top of the popular Play! web framework.

The candidate should have experience with Scala and javascript. Knowledge of Play! [16] desired but not required.

IDE-specific GSoC ideas

Integration of giter8 in Scala IDE / Eclipse

Giter8 (https://github.com/n8han/giter8 [17]) is a command line tool to generate files and directories from templates published on github.

Scala IDE (http://scala-ide.org/ [18]) is the extension to Eclipse providing advanced editing and debugging support for the development of pure Scala and mixed Scala-Java applications.

Eclipse is a great platform to create development environments, but it can lack of flexibility as all extensions need to implemented in a Java VM compatible language inside a plug-in. This makes implementing and updating small features like a project template cumbersome.

Giter8, on the other side, is a project defined to allow everybody to create project templates with little to none knowledge on anything but the templating system used.

The idea is to combine these 2 projects together, to allow to create new Eclipse projects based on giter8 templates. The goal is to have a New Project wizard to choose and configure a template, and run the template engine to generate the new project. And to provide a set of templates for some of the Scala frameworks like Akka or Play, and some documentation about the specificity of creating a project template for Eclipse.

This may require to improve and extend giter8 to extract configuration information, and to make it support some of Eclipse characteristics.

Scala IDE is an application written in Scala for Scala. Giter 8 is written in Scala, is using sbt (https://github.com/harrah/xsbt/wiki [19]), and is mostly used by Scala projects. And we expect this project to be written in Scala. But the result will be usable by all, for any type of projects.

Sbt console for the Scala IDE

Sbt (http://github.com/harrah/xsbt [20]) is the build tool of choice for Scala projects. Sbt is infinitely configurable and can do a multitude of tasks: resolve dependencies, package projects, deploy artifacts, build and run tests, to name just a few. Sbt can be used to build both Java and Scala projects, and it widely deployed. The goal of this project is to add an Sbt console in the Scala IDE for Eclipse.

The Sbt console should work similarly to the command line console of Sbt. It should support command history, command completion, color highlighting. The console should be designed to be usable by other command line tools, such as the Scala Repl.

If time allows it, we can tackle a deeper integration of Sbt in the Scala IDE:

Import Sbt Project wizard: This can be done using the existing sbteclipse Sbt plugin
Sbt task support: run Sbt tasks from a contextual menu
.sbt file editor: .sbt files are a DSL for describing `Settings`. The editor should support completion, outline and hyperlinking.

The candidate should have experience with Scala, and ideally with Sbt. You'll get to work closely with the Scala IDE and gain experience in Scala, Sbt and the Eclipse API plus your work may reach more than 10k users!

Smart Quick Fixes for Scala IDE for Eclipse

The Scala IDE for Eclipse offers a number of essential features for Scala development, such as completion, hyperlinking and refactoring. A 'QuickFix' is an automatic suggestion for fixing a compilation error. For instance, when a type is not found a quick fix would add the required import statement. The goal of this project is to extend the number of available quick fixes, by finding and implementing a number of useful code transformations. These transformations are not limited to fixing compilation errors, and can even amount to implementing a new refactoring.

A couple of example fixes (the candidate is encouraged to come with his own proposals!):

"type mismatch: found T; required Option[T]" -> suggest to wrap the result in Some()

* List[T] but found List[List[T]] -> suggest .flatten or list.head

* Array[T] but found List[T] -> suggest .toArray (likewise for other types)

* etc

"Surround with" (try-catch, match, breakable, Option, etc.)
"foreach/map/flatmap" transform to "for-yield"
and even go wild and "Paste Java as Scala code" -> could be based on https://github.com/mysema/scalagen [21] for instance

The candidate should have experience with Scala, and be creative. You'll get to work closely with the Scala IDE and gain experience in Scala, the Eclipse API, plus your work may reach more than 10k users!

Integration of specs2 with Scala IDE for Eclipse

specs2 [22] is a library for Scala which provides support for writing "executable software specifications" in the form of Behavior-Driven-Development specifications or Test-Driven-Development unit tests. specs2 is integrated with Intellij IDEA at the moment but not ScalaIDE.

ScalaIDE is an environment development for the Scala language based on Eclipse. It support the editing/navigation of Scala code, incremental compilation, refactoring tools, "run" configurations and more.

Expected results:

An Eclipse plugin to execute specs2 specifications from the ScalaIDE. This plugin will allow:

to create a "Run" configuration based on the selection of a specs2 Specification class
to execute the specification and visualize the results
the navigate to failures and errors
to run only one or some examples of the specification based on a selection in the code editor

This plugin could be either independent or based on the work-in-progress plugin for ScalaTest and offer a generic API for executing Scala tests/specifications.

Knowledge Prerequisite: Scala, Eclipse API

Skill level: medium to high.

Of course the list is non-binding and any reasonable project related to Scala that is proposed by student will be thoroughly reviewed.

Requirements and Guidelines

General Student Application Requirements

This is the second time the Scala project has applied to the Summer of Code, and from last years experience, increased popularity of the language and stories of other mentor organizations we expect a high number of applications. First, be aware of the following:

Make sure that you understand, fulfill and agree to the general Google Summer of Code rules [23]
The work done during GSoC requires some discipline from the students as they have to plan their day-to-day activities by themselves. Nevertheless we expect regular contact with the mentors by the usual forms of communication (mail, chat, phone) to make sure that the development is going according to the plan and students don't get stuck for weeks at a time (3 months may seem long, but in reality it is very easy to run out of time).
The official SoC timetable [24] mentions May 21st as the official start of coding, but if you have time you are encouraged to research your proposals even before that (and definitely learn the basics of Scala, if you haven't done that already)

Student Application Guidelines

Student proposals should be very specific. We want to see evidence that you can succeed in the project. Applications with one-liners and general descriptions definitely won't make the cut.
Because of the nature of our projects students must have at some knowledge of the Scala language. Applicants with Scala programming experience will be preferred. Alternatively, experience with functional programming could suffice, but in your application we want to see evidence that you can quickly be productive in Scala.
You can think of Google Summer of Code as a kind of independent internship. Therefore, we expect you to work full-time during the duration. Applicants with other time commitments are unlikely to be selected. From our previous experience we know that students' finishing their studies (either Bachelor, Master of PhD) are likely to be overwhelmed by their final work, so please don't be too optimistic and carefully plan your time for the project.
If you are unsure whether your proposal is suitable, feel free to discuss it on our "scala-language" mailing list (registration instructions are at http://www.scala-lang.org/node/199#scala [2]). We have many community members on our mailing list who will quickly answer any of your questions regarding the project. Don't be afraid of asking questions, we enjoy solving puzzles like that!

General Proposal Requirements

The proposal will be submitted via the standard web-interface at http://socghop.appspot.com [25], therefore plain text is the best way to go. We expect your application to be in the range of 700-1500 words. Anything less than that will probably not contain enough information for us to determine whether you are the right person for the job.

Your proposal should contain at least the following information, but feel free to include anything that you think is relevant:

Please include your name (weird as it may be, people do forget about it)
Title of your proposal
Abstract of your proposal
Detailed description of your idea including explanation on why is it innovative (maybe you already have some prototype?), what contribution do you expect to make to the Scala community and why do you think your project is needed, a rough plan of your development and possible architecture sketches.
Description of previous work, existing solutions (links to prototypes, bibliography are more than welcome!)
Write us about yourself and convince us that you are the right person for the job (linking to your resume/CV is good but not sufficient)
- Mention the details of your academic studies, any previous work, internships
- Any relevant skills that will help you to achieve the goal (programming languages, frameworks)?
- Any previous open-source projects (or even previous GSoC) you have contributed to?
- Do you plan to have any other commitments during SoC that may affect you work? Any vacations/holidays planned? Please be specific as much as you can.
Contact details (very important!)

Summer of Code 2012 Scala Projects