Add projects from last year and some new ideas

GSoC-2015-Ideas.md

@@ -11,6 +11,188 @@ We encourage you to join the #nim IRC channel on Freenode to discuss these proje
 
 The following list of projects are just some ideas that the community and the developers have come up with. You will be contributing to a programming language so there is a lot of flexibility when it comes to the projects that you can work on, this list is certainly not comprehensive so we are happy to hear any suggestions that you may have.
 
+# Projects
+
+## Nim Compiler
+
+#### Make Nim a viable research platform for Garbage Collection algorithms
+
+**Desirable skills:** Familiarity with the various GC approaches and algorithms, knowledge of the compiler codegen modules.
+
+**Description:**
+
+Most of the popular garbage collected languages of today require a separately distributed run-time environment, providing only a predetermined set of garbage collection algorithms. This leaves little room for experimentation with various approaches and condemns GC researchers to develop and test their algorithms on specialized platforms such as the [Jikes RVM](http://jikesrvm.org/) that have limited practical significance. 
+
+In contrast, in Nim, the garbage collection algorithm is chosen at compile-time and embedded in the resulting stand-alone native executable. This enables the users to pick a GC algorithm that's most suitable to their project and allows for a proliferation of GC algorithms, developed by independent groups and individuals, without requiring any modifications to be made to the standard Nim distribution.
+
+The Nim code generator and type system can provide various GC roots marking strategies, various kinds of write/read barriers and all necessary static type information (e.g. static cycle analysis) and a GC implementation will consist only of a single Nim module (supplied as a command-line parameter) that
+provides configuration for the code generator and implements the logic of the garbage collection algorithm. This module will be compiled as C code with the rest of the program and it could be easily debugged using standard C/C++ debugging and profiling tools.
+
+**Tasks:**
+  * Add support for precise stack marking
+  * Add support for read barriers and polish the support for Levanoni/Petrank style of write barriers
+  * Implement the infrastructure for picking a user-supplied GC module
+
+**Bonus points:** Implement simple forms of variety of GC algorithms as a proof-of-concept
+
+**Difficulty:** Medium to Hard
+
+**Mentor:** def- ([@def-](http://github.com/def-)), ?
+
+___
+#### Improve the JavaScript Backend
+
+**Desirable skills:** Familiarity with JavaScript.
+
+**Description:**
+
+Nim has a JavaScript backend, which allows one to write the backend as well as
+frontend in Nim. The JS backend is simple, so this is a good way to get started
+with learning about Nim compiler internals.
+
+**Tasks:**
+  * Fix JavaScript backend bugs
+  * Port relevant parts of the standard library to JS
+  * Make JS test cases
+
+**Bonus points:**
+  * Speed up the JavaScript backend by targetting `asm.js`
+
+**Difficulty:** Medium
+
+**Mentor:** def- ([@def-](http://github.com/def-)), ?
+
+## Libraries
+
+#### Enhance and expand standard library documentation
+**Desirable skills:** Basic writing and documentation skills, webdesign and infrastructure setup.
+
+**Description**:
+The [Nim documentation](http://nim-lang.org/lib.html) is generally good but it
+lacks helpful code examples. Writing documentation is also a great way to get a better understanding for Nim. [Read the docs](https://readthedocs.org/) is a good example of attractive as well as readable documentation, it is something we would be after in this project.
+
+**Tasks:**
+
+  * Ensure that documentation exists for all public methods and modules.
+  * Add code examples to all modules and to all procedures (where appropriate).
+  * Add search capabilities to the online documentation.
+  * Improve the website design and usability
+  * Add cross-linking capabilities in nim doc
+  * Make nimble build and install the documentation locally so you have
+    docs of all your installed libraries
+
+**Difficulty:** Medium
+
+**Mentor:** def- ([@def-](http://github.com/def-))
+
+___
+#### Implement a YAML parser library
+**Desirable skills:** Ability to write efficient parsers.
+
+**Description**:
+
+The Nim standard library currently lacks a YAML parsing module. YAML is a popular "human-readable data serialization format", its popularity is especially evident in the Ruby community. As such it would be a great addition to Nim's standard library. This task requires you to read the [YAML specification](http://yaml.org/spec/) and to create a module which will be able to parse YAML data into an AST. Subsequently the parser can be used to create a high-level API to access the data similar to the current design of the [json](http://nim-lang.org/json.html) module which provides a low-level parser and a higher-level interface which builds on top of the parser.
+
+**Tasks**:
+* Write an efficient parser which will turn YAML data into an AST.
+* Design and implement an API on top of the AST to query the data contained in the AST easily.
+
+**Expected Result**: A working YAML module with the ability to read all YAML compliant data.
+
+**Bonus points**: Thorough testing of the YAML module to ensure that the parser works as expected.
+
+**Difficulty:** Medium
+
+**Mentor:** def- ([@def-](http://github.com/def-)), ?
+
+___
+#### Improve times module
+**Desirable skills:** Knowledge of date time representations, native time APIs.
+
+**Description**:
+
+The current times module lacks some useful features. The ability to tell how long ago a certain time occurred is for example missing. This should be implemented using the existing ``TimeInterval`` type which provides a ``-`` operator for subtracting two ``TimeInfo`` values. A bug exists in this implementation however which prevents this operation from working in the Julian calendar, this should be 
+fixed.
+
+Some research is also required in this task. Other languages should be looked at to see what their standard library provides in terms of time handling. Features from those languages should be ideally ported over to Nim.
+
+**Tasks**:
+
+  * Fix limitations to do with time intervals, specifically subtracting a ``TimeInterval`` from a ``TimeInfo``.
+  * Provide a ``$`` for ``TimeInterval``. Goal is to be able to get timing info like "5 minutes ago".
+  * Add a parser for time strings
+  * Look at time handling in other languages and implement missing features.
+
+**Bonus Points**: Ensure that the times module works with the JavaScript backend.
+
+**Difficulty:** Easy
+
+**Mentor:** def- ([@def-](http://github.com/def-))
+
+___
+#### MPI support
+
+Message Passing Interface (MPI) is a portable system for writing highly
+parallel programs. Nim with its excellent performance/productivity ratio would
+make a great language for this use.
+
+**Tasks**:
+
+  * Create a low level wrapper for the MPI standard using c2nim
+  * Write a high level abstraction library for comfortable MPI in Nim
+
+**Difficulty:** Medium
+
+**Mentor:** def- ([@def-](http://github.com/def-))
+
+## Tooling
+
+#### nimfmt: Automatically format Nim code
+
+Gofmt is often cited as one of the major points for the Go programming
+language. It completely elimantes the need to manually adhere to style
+formatting, by automatically converting go code into a consistent style.
+Something similar would be nice to have in Nim, where we have additional
+freedoms, like case insensitivity, that should be handled in a onsistent way
+for big projects.
+
+**Tasks**:
+
+  * Write a `nimfmt` tool
+
+**Difficulty:** Medium to Hard
+
+**Mentor:** def- ([@def-](http://github.com/def-)), ?
+
+___
+#### c2nim: Improve the automation of low-level C bindings
+
+**Desirable skills:** Knowledge of C
+
+**Description**:
+Nim's c2nim tool helps create nim bindings for C libraries. However, c2nim does not parse the whole C language, and is not currently supposed to import whole APIs into nim mechanically, but rather to serve as a starting point for manual definition of interfaces to C libraries. c2nim is particularly effective in dealing with C's preprocessor macros, but is
+not currently capable of parsing many C header files.
+
+Make c2nim accept more C declarations than it currently does, and produce corresponding Nim declarations. This can be done either by directly filling-in the missing capabilities, or by interfacing it with a mature tool for parsing C code, such as LLVM's CLang or the GCC-XML tool. If one of these tools is used, then it is expected that it would not suffice by itself, but rather augment the current c2nim parser, since these tools have their own limitations. A possible implementation might pass 
+the header file once through gcc-xml to parse C declarations, and would use the current c2nim parser on lines that start with '#' to parse preprocessor definitions. c2nim would then process the parsed headers and produce constants, types, macros and proc declarations similar to those that it produces now.
+
+C comments should be converted into nim documentation where appropriate.
+
+Although c2nim currently converts function implementations (and not only declarations), this functionality is outside the scope of this task.
+
+**Tasks**:
+Depending on the chosen implementation technique, the tasks would be either:
+  * detect individual deficiencies in c2nim support for .h files and fix them
+or:
+  * interface with a feature-complete parser for C, such as that of GCC or CLANG.
+  * refactor c2nim so that it can generate declarations from the parsed output of the above parser, rather than directly from .h files as it currently does.
+  * combine the output from the previous task with the declarations that c2nim produces for preprocessor macros.
+
+**Difficulty:** Medium
+
+**Mentor:** def- ([@def-](http://github.com/def-)), ?
+
+
 # Project spec
 
 Please add your project ideas in the following format.
@@ -27,6 +209,4 @@ Please add your project ideas in the following format.
 
 **Difficulty:** ...
 
-**Mentor:** Mentor name ([@MentorName](http://github.com/MentorName))
-
-# Projects
+**Mentor:** Mentor name ([@MentorName](http://github.com/MentorName))