GSoC/GCI Archive
GSoC/GCI Archive
Google Summer of Code 2013

Scala Team

Web Page: http://www.scala-lang.org/gsoc2013

Mailing List: http://groups.google.com/group/scala-language

Scala is a general purpose programming language designed to express common programming patterns in a concise, elegant, and type-safe way. It smoothly integrates features of object-oriented and functional languages, enabling Java and other programmers to be more productive. Code sizes are typically reduced by a factor of two to three when compared to an equivalent Java application.

Many existing companies who depend on Java for business critical applications are turning to Scala to boost their development productivity, applications scalability and overall reliability.

Scala runs on the JVM integrating near-seamlessly with libraries on that platform. Javascript backend is currently actively developed for Scala (https://github.com/lampepfl/scala-js). This signficantly reduces barriers to adoption and has been a key factor in Scala’s success. Worldwide, there are an estimated 100,000 skilled Scala programmers - a number that is continually increasing. We run very succesful Scala Days conferences in 2010, 2011 and 2012, which gathered significant interest within the community - both conferences were quickly sold out before the deadline. We expect an even larger turnout for this year’s conference in New York. Scala development is supported by quality development tools: Jenkins for build, issue tracking with Jira, mailing lists (user discussions as well as architecture decisions are made there) and an extensive test-suite. All Scala source code is currently at github and we are receiving a lot of contributions from the community.

The Scala team was participating in GSOC 2010, 2011 and 2012 editions and we had many successful projects that were involved in extending the main language compiler, improving IDE support and working on external open-source projects that were written in Scala (like Akka or Lift or Kojo).

We look for motivated students are who are good in object- and functional-oriented programming (preferably have some familiarity of Scala itself or at least took the Coursera online course). Apart from the projects proposed on the ideas page we are interested in supervising any projects as long as they are written in Scala.

Projects

  • Comprehensive Comprehensions In this proposal I explain my plan to greatly improve the utility of for comprehensions in Scala. My proposal is based on a Pre-SIP by Stefan Zeiger, a Pre-SIP by Christopher Vogt and Jan Braun, and the original Comprehensive Comprehensions (henceforth, _CC_) paper by Phillip Wadler and Simon Peyton (with generalizations). If my proposal is implemented, for comprehensions would gain a power similar to what is offered by LINQ on .NET, but, of course, since this is Scala, they wouldn't be nearly so inflexible as LINQ, allowing seamless integration of any correctly-signautured method defined on comprehendables.
  • Constraint Solver in Scala This GSoC project proposal is based on the idea described at http://lara.epfl.ch/w/solver. It consists of two separate goals: First, DPLL(T) solving architecture. Currently scabolic uses an imperative solving algorithm which is difficult to modify. DPLL(T) is well-established and would provide a better framework. One part of this implementation is incremental SAT solving. Second, a decision procedure to reason about functional data structures. Such a decision procedure is, for example, described in the paper "Decision procedures for algebraic data types with abstractions". Having such an implementation would, for example, allow to replace Z3 as the theory solver in Leon. It would be nice to have the complete stack written in Scala. Especially regarding certain optimizations, which are impossible with a black box solver.
  • Cross-language refactorings for the Scala IDE This proposal aims to improve the refactoring support of the Scala IDE. Right now refactorings on Scala code are not connected to refactorings on Java code - this may lead to problems in projects with a mixed codebase in Scala and Java. The main goal is to provide a reliable crosslanguage version of the 'Rename' refactoring. Additional goals are to extend the Rename refactoring to Play framework templates and routing files in the Scala IDE Play plugin.
  • Numerically Solving Partial Differential Equations Many of models in science are based upon partial differential equations. In most cases, these equations are too complicated to solve exactly or even to approximate mathematically. To remedy this, we resort to using numerical methods. Scala's blend of object-oriented and functional programming paradigms provides a nice framework for working in, but it's main advantage is building libraries with an easy to use user iterface.
  • parboiled2: a macro-based PEG parser generator for Scala Grammar-based parsing of text data is a ubiquitous problem in real-world applications. One popular technique for implementing parsers is parser combinators. However, even though it's comparatively easy to build a parser with combinators the end-result is logic that essentially "interprets" the grammar rules against the input, which is rather slow. Hand-writing a parser can yield a much faster implementation but is tedious and error-prone. It is possible to implement a parser defined via an embedded DSL that is translated into runnable code by the host language compiler at compile time. The macro support introduced with Scala 2.10 provides the required and sufficient infrastructure for such an endeavor. The goal of this project is to use Scala 2.10 macros to implement a compile-time generator for highly efficient PEG parsers. Rule definition is based on the parboiled DSL embedded in Scala with a few extensions (such as shapeless' HLists for combining flexibility with strong type-safety).
  • Scala Library as a Deep EDSL Module Yin-Yang project development and improvement
  • Script Tracing with Kojo IDE As suggested by Kojo, my project will be the implementation of script tracing in the IDE. Such a feature would be a powerful tool in the hands of programmers attempting to debug their code. It will consist of a new window mode in Kojo, where pressing a "trace" button will trace the program. A history of the trace will allow the user to go through all calls and see the state of visible variables at that point.
  • Slick migration projects Schema manipulations DSL, and/or database migration system
  • Specializing parallel collections with customized work-stealing and Scala Macros and developing micro-benchmarking suite for collections. This project aims at creating new parallel collection implementations, that take advantage of macros to generate a specialized parallel operation instance for a particular invocation. This specialized parallel operation instance avoids abstraction overheads such as boxing, dynamic dispatch or iterator state updates. Orthogonally, to improve scalability for data-parallel operations on highly irregular workloads, work-stealing tree scheduling will be used. Work-stealing tree scheduling is a novel scheduling technique for load-balancing parallel execution of highly irregular data-parallel workloads currently being implemented as part of the Parallel Collections for the Scala programming language. To ensure scalability and the appropriate performance of the new parallel collection implementations, a suite of micro-benchmarks and benchmark applications is planned to be developed using the ScalaMeter performance regression testing tool previously developed as part of the Scala programming language project.