Ideas for EmergeTk GSoC projects

Google Summer of Code is a wonderful program which sponsors students to work on real open source projects for three months.

This would be the first year EmergeTk participates in the project. Although EmergeTk is still a small community (~10 contributors), it is growing every month. As we increase the number of clients running production applications built with EmergeTk, more programmers are using the toolkit. Additionally, there is increased demand for more stability in the framework, more features, and better documentation.

The project ideas listed below are a starting point for areas that significant progress could be accomplished in three months by a programmer with little experience in the code base, and are features that would add compelling value to the toolkit to adopters, and contribute significantly to it's long term success as an open source project. In addition to the ideas below, any student is welcome to contribute or suggest their own ideas.

Applicants must be prepared at a minimum to write code in C# in either Mono or .NET. Different projects will emphasize different technologies and concepts, ranging from relational and distributed database theory to CSS, Javascript, AJAX, two-way browser sockets. We expect that any contributions made during the Summer of Code are thoughtfully considered. We would rather have an incomplete, well thought out codebase than one that accomplishes the objective while sacrificing long term maintainability.

Implement Addin Architecture

Priority: High
Complexity: Medium

Currently EmergeTk is a monolithic codebase, sporting some 25,000 lines of code. We'd like to clean up the code, trim down to a core code base, and extract optional functionality into addins. A preliminary version of this is working, using the excellent Mono.Addins project. The student could elect to work from that concept, or propose / collaborate on a new approach.

Benefit: This would open up EmergeTk contribution opportunities, while allowing us to manage the core code more tightly.

Deliverable: A functional plugin model including:

• An administration page to manage addins
• The ability to dynamically load assemblies and resources related to a plugin.
• Sufficient application extension points to provide opportunity for meaningful addins.
• Optional: ability to browse and install addins from online repositories.

Integrate distributed hashtable support (i.e. memcached)

Priority: High
Complexity: High

Some potential adopters are not looking for high scalability. For them, a standard database driven web architecture is sufficient. Other adopters however have either the real or potential need for highly scalable support in the framework they choose. Today, there is a cornucopia of methods and libraries in the open source community addressing the challenging problem of scale.

The O/R mapper in EmergeTk is object-oriented, as opposed to some other mappers which are RDBMS-oriented. As such, our data layer is well suited for supporting non-relational data stores. There is preliminary support for using memcached, a distributed hashtable (dht) for caching objects loaded from the data provider. We would also like to support a persisted, distributed hashtable provider, such as memcachedb (a merge of memcached and BerkelyDB.)

Benefit: Would be a compelling feature for projects anticipating high scale.

Deliverable:

• A stable implementation of memcached as a cache provider (still using an RDBMS like MySQL to persist data)
• Provide a provider for a persistent distributed hashtable like membachedb.

Solr Index Provider

Priority: Medium
Complexity: High

EmergeTk currently supports convenient integration with Lucene.net. Solr is emerging as a popular abstraction to Lucene that adds increased functionality, as well as increasing architectural options. We would like to abstract the search index component to allow for different providers, one of which would be Solr.

Deliverable: Ability to use Solr for all existing EmergeTk search / IndexManager functions.

Publish Worfklow Addin

Priority: Low
Complexity: Low

We developed a workflow system for a client. It could be useful for other projects. Currently it resides in the core code, and should be refactored into its own project as an addin.

Deliverable: A working implementation of EmergeTk worfklow clases as an addin.

Create MonoDevelop Addin and/or Command Line Tools

Priority: Medium
Complexity: Medium

In order to reduce the difficulty in building EmergeTk projects for newcomers, and to save time for existing EmergeTk programmers, we would like to build some tools to help with common actions, such as creating new widgets, defining models, binding between objects, and so forth. At a minimum, we'd like for this plugin to implement a new project type in MonoDevelop for EmergeTk, and add some basic file type support (Context, Widget, Record, etc.)

Any code for this project should preserve strong separation of UI from functionality, so as to allow us to target command line tools as well as IDE support. This is especially true of any specific, complex EmergeTk logic.

Deliverable: Either a MonoDevelop Addin, or a set of command line tools to ease the development of new EmergeTk applications.

Note: This could also conceivably be a Mono SoC project, as they specifically ask for new project ideas targeting MonoDevelop.

Create Test Tools / Support Selenium

Priority: High
Complexity: Medium

Having a good set of tools and recommendations on the best way to test EmergeTk applications would be a great benefit to potential adopters. There is some preliminary work in simulating a web server environment and bootstrapping EmergeTk Contexts and Widgets into a test runner, but this could be greatly enhanced.

Supporting Selenium, a browser driver would be very exciting. There are probably a few key functions to write that would greatly improve the ability for Selenium to grok EmergeTk applications.

Deliverable: Could be a set of helper classes to aid in test generation. Could also be examples and documentation providing insight into how new companies can write their own tests. Ideally would also include code supporting Selenium.

Finish Monodoc Online Documentation Editor

Priority: High
Complexity: Medium

We built an online editor for Monodoc in EmergeTk (You can look at it at http://monodoconline.skullsquad.com/). Miguel has expressed an interest in using this for Mono's API documentation, so this could be a highly visible project. Before it can be considered ready for consumption for Mono, there are a series of tasks that need to take care of.

Deliverable: Working MonodocOnline project that satisfies the needs of the Mono community.

Note: This could also conceivably be a Mono SoC project, as Miguel has expressed interest in having this work completed.

Implement Serialization / Session Persistence (support non-sticky / expired sessions.)

Priority: High
Complexity: Very High

One of the major weaknesses of EmergeTk is that the client and the server are tightly coupled. The browser is essentially a dumb terminal to an application running on a remote server. Typical AJAX based applications are designed in a stateless fashion, so they can be decoupled from a server and robustly continue to function. The simplest example to illustrate the brittle nature of EmergeTk state is that if server is restarted, every single link on the browser stops functioning.

This is a complex problem for EmergeTk. We have explored the problem for several years, and have not found a satisfactory solution. The basic goal we would like achieve is that an application developer is able to provide a series of hints to client side widgets that allow those widgets to function if the server is disconnected or restarted.

Deliverable:

• A recommended architecture for managing state in EmergeTk
• Code modifications that allow devellopers to provide hints to widgets to handle subsequent events.

Create Your Own EmergeTk Application

Priority: Low
Complexity: Variable

If you have a great idea for an open source web application you'd like to build using EmergeTk, let us know and we'll consider the application.

Deliverable:

• Some sort of intriguing web application built in EmergeTk.
• A blog or journal of the experience. Something that could be adapted to a tutorial at a later date.