Project #1: Incoming Mail Processing Microframework
The objective is to create an incoming mail processing microframework (with POP, IMAP, and MTA support), that works with Rails "out of the box," and that is compatible with other popular Ruby web frameworks, complete with a routing DSL and bounce detection.
Project #2: Simpler Ruby Deployment
The goal of this project is to make it trivial to deploy applications under multiple environments (e.g. Ruby interpreters) in a server setting. In doing so, this project will involve working on improving existing tools (such as RVM and bundler, possibly also extensions for tools such as chef and puppet) as well as creating new tools where necessary. Ideally, at the end of the period it will be simpler for developers and companies to test out their applications internally on different Ruby implementations (including a prebuilt server set of virtual machine images for testing purposes).
Project #3: Live Code Reloading
When writing Rails plugins, many developers run into issues with the class reloader. Especially since Rails raises an error whenever it detects that an old class is still in use. Not having to program with the reloader in mind would be an advantage. My plan is to refactor and improve the current class reloader, so it will offer multiple reloading strategies, deciding at runtime what strategy to use for which class.
Project #4: NArray on OpenCL
In this project, we will develop NArray on OpenCL that utilizes hardware resources such as GPU. The goal of our project is to translate NArray from C to OpenCL. The NArray has the characters that match well as OpenCL (GPU) applications. In addition, OpenCL is hardware agnostic so that the programs using OpenCL should run on various CPUs/GPUs. This means the translation of NArray to OpenCL will not detract the feature of the Ruby portability. Therefore, this project allows Ruby programmers to facilitate implementing and executing heavily calculation-oriented applications.
Project #5: Bringing More REST to Ruby with Restfulie
REST is an architectural style for distributed hypermedia systems. It's the style that guides the web architecture, and by developing applications that conform to its constraints we can enjoy many of the features that make the web successful, such as scalability, generality of interfaces, and intermediary components to reduce interaction latency, enforce security, and encapsulate legacy systems.
The goal of this project is to make it easier to write RESTful web applications and enjoy its advantages. This will be done on top of Restfulie, a library that help you write hypermedia-aware clients and servers. Rails brought REST to the Ruby world with the notion of resources and crud through HTTP, Restfulie goes one step further. I'll be working especially towards making Restfulie framework-agnostic and improving REST support in Rails.
Project #6: JRuby on Android
This project will make JRuby a viable option for Android development. I'll write tools to generate a fresh app that's already setup to use JRuby and tools to compile and package the app for distribution. I'll then write a framework that abstracts away a lot of the Java calls, allowing people to write more Ruby instead of writing Java or writing Ruby that just calls Java. At the end, I'll thoroughly document everything and write several sample apps.
Project #7: JRuby C Extensions
Wayne Meissner's jruby-cext proof-of-concept has shown C extension supported in JRuby. The task for this project is to provide a safe subset of the C API in order to run C extensions on JRuby. Being able to run more gems directly without needing to port them to Java first will further improve the ability of JRuby to combine the Java eco-system with the Ruby language.
Project #8: Benchmarking CI
This project consists in building an official full-stack benchmarking suite for Ruby on Rails. Each commit will automatically trigger a process where a remote machine starts a new server, runs the tests and reports back the results. As time goes by, it will be possible to watch the evolution of the framework's performance and developers will be able to keep track of the impact their changes have. In it's most basic form, it will bring a kind of performance-oriented continuous integration for the Ruby on Rails framework.
Project #9: ActiveRecord to DO
This project will attempts to port Rails' ActiveRecord database-specific code to a DataObjects backend. The completion of this project would allow us to centralize all the DB code in a single project that Rails and other Ruby projects can use. Things like full Ruby 1.9 support and a standardized API to talk to the different RDBMS will be available to all interested projects.
Project #10: Try Camping
In this Ruby Summer of Code project we’ll design, implement, and launch Try Camping. The site will be designed give newcomers a solid foundation in Ruby web development so they can easily continue with Rails and Sinatra. Try Camping will be an interactive web-development tutorial using Ruby and the Camping framework. It runs right in the browser and needs no setup so you can focus on learning. You start by writing a simple but functional application, then grow into more advanced topics like MVC and REST.
Project #12: ActiveRecord Identity Map
Our goal is provide plugable identity map implementation for ActiveRecord. An identity map is a design pattern used to improve performance by providing a in-memory cache to prevent duplicate retrieval of the same object data from the database, in our case in context of the same request or thread.
If the requested data has already been loaded from the database, the identity map returns the same instance of the already instantiated object, but if it has not been loaded yet, it loads it and stores the new object in the map. The main gains of this project will be performance improvement and memory consumption reduction.
Project #14/20: Rails Admin / Mountable Apps
Point-and-click data administration has been an important part of the success of web frameworks like Django. This project aims to bring that functionality to Rails 3 through a new gem based on Erik Michaels-Ober's admin slice for Merb. RailsAdmin will be built with focus on code readability and extensibility, with the idea that it may one day work with any Rack-based application. The goal of this project is to further increase the easy and speed of Ruby web application development.
There are many cases in which vertical stacks of functionality can be recycled, but there is still no easy way to share entire Rails applications in reusable way. A reliable and unobtrusive approach to adding a generic admin interface to Rails applications will require a solid API for reusing code between projects. The goal of this project is to make reusing entire Rails apps as easy as possible and provide examples of reusable applications.
The Rails Admin and Mountable Apps projects will be collaborating.
Project #15: Hackety Hack 1.0
Hackety Hack makes programming accessible to beginners, regardless of age or background. The current 0.9 version is nearly complete and in this project we’re going to push to a 1.0 release. That includes an editor, lessons, and a web application to share code with friends. The final project will be released on Github and publicized through the RailsBridge outreach group.
Project #16: ActiveRecord Sharding
The goal of this project is to better implement Database Sharding in ActiveRecord. Sharding allows multiple databases in the same Rails application. While there are several projects that implement Sharding (e.g. DbCharmer, DataFabric), each project has its own limitations. This project will include a Sharding API, master/slave replication support, capistrano and rake tools to manage database state (e.g. migrations, moving data between shards).
Project #17: Coming Soon!
Project #18: Ruby Archive Format
This project will focus on developing a file format and set of utilities for a Ruby archive format, similar to the JAR format for the Java language. My goal is to make it easier both to distribute Ruby applications to end users and to deploy server applications. It will be possible to package an entire application into a single file, including any required libraries. By the conclusion of this Ruby Summer of Code project I will have developed a specification for the archive file format and a set of utilities to interact with the format, and it will be possible to run most Ruby applications packaged into the format without significant modification to the application.
Project #19: Decimal to Stdlib
Decimal is a fast and small library which aims to replace BigDecimal. In it's existing state, it's already got a lot of potential, but its functions are not quite robust enough to be useful along with other standard libraries. In this summer project, I'll work to reimplement parts of Decimal; to polish it up a bit and get it in better, more useable shape, including a backward compatibility layer, math functions, OtherNumerics#to_decimal, and Decimal#to_*.