Merge branch 'master' of https://github.com/scala/scala-lang

Author: heathermiller

gsoc/2016.md

@@ -46,16 +46,88 @@ project related to Scala that is proposed by a student will be thoroughly
 reviewed.
 
 ### Revamp Slick Code-generator
+
 There is a long list of smaller and medium sized open tickets for the Slick code generator.
-Time to tackle them and give it another overhaul.
+Time to tackle them and give it another overhaul. This is going to be a very useful and somewhat easier project.
 
 https://github.com/slick/slick/issues?q=is%3Aopen+is%3Aissue+label%3Atopic%3Atype-providers
 
-Supervised by @cvogt and/or @szeiger
+Supervised by [@cvogt](https://github.com/cvogt) and/or [@szeiger](https://github.com/szeiger)
 
+### Slick bug and feature hunt
 
-*... Mentors: please insert your projects here ...*
+There are lots of open tickets in the Slick issue tracker. Some which have long time fallen behind. This project would
+be about tackling as many of them as time permits. It will be a good chance to learn about the Slick code base
+and have an impact in this successful project. Some issues may be simple, but many issues may be challenging to fix and will require someone smart, dedicated and persistent enough to learn the details of how Slick works.
+
+https://github.com/slick/slick/issues
+
+Supervised by [@cvogt](https://github.com/cvogt) and/or [@szeiger](https://github.com/szeiger)
+
+### Super-charged for-comprehensions
+
+Super-charged for-comprehensions are an effort to implement an alternative direct-style dyntax for monadic comprehensions in Scala.
+The goals are reduction in syntax, enabling more control flow expressions, inline Monad value extraction and transformer operations on the Monad context (as in Comprehensive Comprehensions). At the time of writing the project is in heavy flux. Depending on its status there will likely be interesting idea how to take the project further. One likely topic would be exploring type changing comprehensive comprehension transformers, such as groupBy or aggregations. The implementation heavily relies on macros and will require learning how to work with Scala's compiler ASTs and make changes to the AST transformation stages.
+
+Work in progress: https://github.com/cvogt/flow-comprehensions
+
+Supervised by [@cvogt](https://github.com/cvogt)
+
+### A next generation Scala build tool
+
+This project is about extending and contributing to the implementation of a vision that only exist in partial, unreleased prototypes right now. The idea is to build a tool for a intuitive, easy to use, composable, statically checked builds that is used like an ordinary Scala library with no surprises. Several pieces of the puzzle exist as prototypes, but need improvement and many other pieces are entirely missing. In particular this GSOC project could be about building an interface to interoperate with SBT builds and SBT plugins, using them as components in new style builds. Other features yet to be built include publishing artifacts, signing them using GPG, packaging and many more. The exact tasks will depend on the state of the project at the time GSOC applications happen. It will be a chance to work on tooling and contribute to something that has a chance to maybe some day change something fundamental in the Scala eco system.
+
+Supervised by [@cvogt](https://github.com/cvogt)
+
+### Pushing Scala Coroutines to the Next Level
+
+[Scala Coroutines](http://storm-enroute.com/coroutines/) is a library-level extension for the Scala programming language that introduces first-class coroutines.
+
+Coroutines are a language abstraction that generalizes subroutines (i.e. procedures, methods or functions). Unlike a subroutine, which is invoked once and executes until it completed, a coroutine can pause execution and yield control back to the caller, or another coroutine. The caller can then resume the coroutine when appropriate. Coroutines have a number of use cases, including but not limited to:
+
+* data structure iterators
+* event-driven code without the inversion of control
+* cooperative multitasking
+* concurrency frameworks such as actors, async-await and dataflow networks
+* expressing asynchrony, and better composition of asynchronous systems
+* capturing continuations
+* expressing backtracking
+* AI agents such as behaviour trees
 
+The goal of this project is to extend documentation and tests of Scala Coroutines, potentially improve parts of the Coroutines implementation, and then implement a standard suite of extensions for Scala Coroutines. These extensions will be a separate module in the project, and will offer support for the use cases listed above: concisely creating collection iterators using coroutines, async-await support, continuation support, backtracking testing support, and/or a fiber library module. All the extensions will have to be documented.
+
+Supervised by [@axel22](https://github.com/axel22)
+
+### Better Scripts in Scala
+
+There are several hacky, ad-hoc ways to write scripts in Scala already, e.g. SBT's script-runner, and the Ammonite REPL's script loader. Your task in this project would be to improve the experience writing scripts using Ammonite to be on-par with the experience writing scripts in any other language, as well as on-par with the experience writing Scala code in a large project. This includes:
+
+* Improving startup time: SBT is terribly slow, and even Ammonite scripts take 1-2 seconds to boot up, This is speed-up-able.
+* Improved error reporting: Ammonite's scripts currently report line-numbers and file-names based on the mangled compilation-unit. We should report based on the location within the source file a user wrote.
+* Ammonite requires two steps to install (Java, Ammonite). There is no reason it should take more than 1 command to bootstrap the script-runner on a new system
+* IDE support: Ammonite's syntax isn't supported by major IDEs, meaning you lose in-editor errors, autocomplete, and other things when writing your script. This can be added
+* Windows support: the Ammonite-REPL does not currently work on windows due to terminal-interaction issues. We should make it work and put it in CI.
+
+Supervised by [@lihaoyi](https://github.com/lihaoyi/)
+
+### Flexible Fast Parser Combinators
+
+The FastParse library is a modern replacement for Scala's old parser combinators library. It provides similar API, drops a lot of redundant operators, and runs 50-100x faster. However, right now it only parses Strings.
+
+This project would be to extend FastParse to parse other things. Cases to cover include:
+
+* Binary data: Array[Byte], ByteBuffer, ByteString, letting us parse things like binary files, network protocols, or other formats
+* Streaming data: Iterator[String] and Iterator[Char], letting us parse files while not materializing the entire contents in memory
+* Pre-tokenized data: Seq[T] for an arbitrary T, letting you re-use a pre-written lexer before your parser
+
+Using virtual classes, we should be able to extend FastParse to do this while still re-using most of our code. Your task would be to:
+
+* Make FastParse able to handle 2 or 3 of the above cases
+* Demonstrate use-cases by using FastParse to write parsers for well-known formats: .zip, .class, streaming JSON or XML-SAX parsing
+
+Supervised by [@lihaoyi](https://github.com/lihaoyi/)
+
+*... Mentors: please insert your projects here ...*
 
 ## Requirements and Guidelines