Web Page: http://www.scala-lang.org/gsoc2013
Mailing List: http://groups.google.com/group/scala-language
- 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.