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

Scala Team

License: New and Simplified BSD licenses

Web Page: http://www.scala-lang.org/gsoc/2014.html

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/scala-js/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, 2012 and 2013 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 Berlin. 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, 2012 and 2013 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

  • Breeze and Spire Interoperability The goal of this project is to analyze the different strategies to successfully incorporate the numeric library Spire into Breeze and to provide an implementation of the suggested design. The interoperability will allow Breeze to take advantage of Spire's rich hierarchy of mathematical abstractions and their efficient implementations. The resulting library will be showcased by solving a specific numerical problem in Astrophysics which requires an efficient implementation of numerical procedures.
  • GPU Extensions for Breeze I would like to work on GPU extensions for Breeze, including matrix factorizations (LU, SVD, etc.), linear systems solver and as much of Breeze's functionalities as possible. This is an exciting topic, combining many interesting ideas: functional programming in Scala, numerical methods and GPU computing. As of now, probably the most popular tool for scientific computing is Python/SciPy. I would very much like to be a part of the revolution in that field and replace Python with Scala.
  • GSoC14 Project Proposal - Extensible Scala IDE (codename: project extide) The idea of this proposal is to give maximum productivity to developers by giving them the ability to extend the core of the Scala IDE with their own modules. Such a feature is well known by editors like Vim or Sublime Text, but more or less non-existent in the IDE world. The user defined modules should, on the one hand, be written entirely in Scala and be powerful enough to let them define the behavior of their IDE, but, on the other side, hide all the complexity of the Scala IDE internals.
  • Improve Sprite based gaming in Kojo The aim of this project is to enhance the functionality and usage of sprites thereby improving game creation in Scala using Kojo. 1)Sprite Collision Detection: A feature to detect collision among sprites to improve game and animation development in Kojo. This makes use of Image edge detection. 3)Physics Integration: Using JBox2D to integrate physics realism into game development. 2)Developing a 2D platform game based in Kojo to showcase and thoroughly try and test the functionality.
  • Improving numerical routines in Scala Breeze Breeze is a great numerical processing library. However, it lacks some high-level functions that you can find in other libraries like [SciPy](http://www.scipy.org/). The second issue is that Breeze lacks documentation. This makes the entry barrier higher for new contributors. My proposal is to revamp documentation and to introduce interpolation and integration facilities.
  • Macro-Based Generic XML Interpolator The goal of this project is to design a string interpolator for XML using the support of macros in Scala. The aim is to eliminate native support for XML literals in Scala and find a replacement which solely relies on macro expansion which results in better code generation and static type checking. Since it is to be a replacement for the XML literal syntax of Scala, the goal is to provide all the already existing features of that syntax as well.
  • Mars project (macros at runtime for Scala) Scala macros are functions that work with abstract syntax trees during compile time. Mars project (macros at runtime for Scala) is aimed at introducing runtime expansion for macros in Scala.
  • Miniboxing for Breeze and Spire The project is about improving the curent Miniboxing implementation in Scala compiler such that it will match optimal performance on large benchmarks, and it will be compatible with the 2.11 version of Scala.
  • MongoDB support for Slick Slick is a database access library for Scala. I'm going to provide MongoDB support for Slick (currently it supports relational databases only).
  • SubScript Actors The actor model and its implementation in the Akka library for Scala have proven their use for developing concurrent applications. However, the expression of an actor’s internal behavior using plain Scala is relatively clumsy. It seems this may be improved when the internal behavior is specified using a Scala extension named SubScript, which is based on the theory Algebra of Communicating Processes. The aim is to get Akka actors working together with SubScript.
  • Support for macros in Scala IDE Scala macros have brought previously impossible or prohibitively complex things to the realm of possible, but at the moment their support in IDEs is lagging behind. The main goal of this project is to add support for designing and debugging macros to the Scala IDE plugin for Eclipse.
  • Type-checking of plain SQL The use of Plain SQL queries in Slick requires users to know the result type of the query and how to map that back to Scala types. There is also no compile-time checking for these queries. The goal of this project is to alleviate both issues with macros. Plain SQL queries have all the necessary information (query string, parameter types) available at compile-time to allow a macro-based implementation to get the result type from the database, and translate that back into a Scala type.