SBML.org — the global portal for all things SBML

JSBML Project Ideas for Google Summer of Code 2012

This page describes our project ideas for students participating in Google Summer of Code 2012. If you have any questions, please feel free to contact the JSBML Team via email at jsbml-team@caltech.edu.

Contents


Image credit: GSoC 2012
Image credit: GSoC 2012

What is Google Summer of Code?

Google Summer of Code (GSoC) offers post-secondary student developers stipends to write software for open-source projects. Individuals apply to GSoC, pick a project, and if accepted, are paired with mentors from the project (in this case, SBML). More information is available from the Google Summer of Code 2012 FAQs.

What are the SBML and JSBML projects?

SBML is a data format for representing and exchanging computational models in systems biology. It has been in use for over a decade and continues to evolve and grow.

JSBML is a community-driven, open-source project to develop a complete pure-Java API library for reading, writing and manipulating SBML. Where possible, JSBML strives to attain 100% API compatibility with the Java interface of libSBML, a full-featured library with a core written in C++.
The JSBML Project is part of the broader SBML effort. Currently, the JSBML consortium of developers includes people at the University of Tübingen (Germany), the EMBL European Bioinformatics Institute (EBML-EBI, UK), and the California Institute of Technology (USA). Other institutions are welcome to join.

Why is the JSBML project participating in GSoC?

The current development release of JSBML is at version 0.8, and implements support for all constructs in SBML up to the latest Level 3 Version 1 specification, but more powerful features as well as support for SBML Level 3 Packages are still unimplemented. We could use help implementing these additional capabilities.

For several reasons, we believe working on JSBML would be a good project for someone interested in computational biology. First, it is a Java programming project that does not require knowledge of how to do numerical simulations – in fact, it hardly requires any knowledge of biology either. Second, there's a wide range of topics to choose from, including work on graphical layout and rendering, thereby providing a variety of interesting options for projects. Third, we have a number of developers already working on JSBML, so there are people who can answer questions. And finally, it's for a good cause: building tools that help scientists do better simulation and analysis in biology.

How to apply

The following resources provide general information about the application process:

The Google Summer of Code program is competitive. Accepted students typically have thoroughly researched their proposed project and have been in frequent contact with the project's mentors. Simply copying and pasting an idea here will not work. On the other hand, creating a completely new idea without first consulting potential mentors is unlikely to work out.

Information we will need from you

To help ensure a good match between the project and everyone involved, we would like to know who you are and also a little bit about how you think. Therefore, please include the following information in your application:

  1. Your contact information:
    1. Your name
    2. Your email address
    3. Any professional/resume or personal/blog URLs you would like to list
  2. Your background and education:
    1. A brief description of your education history
    2. Information about work experiences or projects that may be relevant to this project
  3. Your summer plans:
    1. Which city and country will you be spending this summer in?
    2. How much time do you expect to have for this project?
    3. Please list jobs, summer classes, and/or vacations that you'll need to schedule around, and times when you will have limited internet access.
  4. Your programming experiences and strengths:
    1. What are your programming languages of choice?
    2. What are some of your prior experiences working with Java?
    3. Do you have prior experiences doing open-source development?
  5. Your goals for GSoC:
    1. What do you want to learn this summer?
    2. What are your interests and background in biology or bioinformatics?
  6. Your goals or ideas for the project you would like to work on:
    1. Project Name: one of the suggestions listed below, or your own idea
    2. Project Description: your own description of the project and why it's interesting
      • Provide sufficient details. Include links to other projects or products that illustrate your ideas.
      • Strong applicants include a tentative implementation plan and timeline (hint!)
      • Identify possible hurdles and questions that will require more research/planning.
    3. If you had to choose an alternative project instead, what are some backup alternatives that would interest you?
  7. What can you bring to the team?
    1. How hard are you committed to working this summer?
    2. How enthusiastic are you about this work?

Hints for a successful application

The following are based in part on Google Summer of Code hints:

  • Submit your proposal early: early submissions get more attention from developers for the simple fact that they have more time to dedicate to reading them. The more people see it, the more it'll get known.
  • Interact: before submitting your proposal ask questions to the developers, you can even ask the potential mentor to review your proposal before sending it to Google.
  • Keep it simple: we don't need a 10-page essay on the project and on you. (Google won't even let you submit a text that long.) You just need to be concise and precise.
  • Know what you are talking about: the last thing we need is for students to submit ideas that cannot be accomplished realistically or ideas that aren't even remotely related to JSBML. If your idea is unusual, be sure to explain why you have chosen JSBML to be your mentoring organisation.
  • Aim wide: submit more than one proposal, to different areas of JSBML. We also recommend submitting to more than one organisation too (not just JSBML). This will increase your chances of being chosen for GSoC.

Project Ideas

For more information about any of these projects, please ask on the public JSBML development mailing list, jsbml-development@caltech.edu.

Image:icon-lightbulb.gif Idea #1: Your own original Idea

Feel free to propose your own idea if none of the ones below suit you. As long as it relates to the JSBML project, we will give it serious consideration. Creativity and self-motivation are great traits for open-source programmers (but, please make sure your proposal is also relevant to JSBML!).

  • Contact point : jsbml-development@caltech.edu

Image:icon-lightbulb.gif Idea #2: Improve the support for the SBML Layout and Render packages

Two more of the many packages for SBML Level 3 are Layout and Render. These packages define constructs for using inside SBML files that allow for diagrams of models to be stored as part of an SBML model. The constructs are used by some popular software systems such as COPASI. The JSBML team has already started implementations of the layout and render packages, but more needs to be done.

  • Languages and skills: Java
  • Potential mentors: Andreas Dräger, Nicolas Rodriguez

Image:icon-lightbulb.gif Idea #3: Implement support for the SBML Hierarchical Model Composition package

There are many packages in development for SBML Level 3. One of the highest-priority requests is to support the ability for SBML models to be subdivided into submodels, which is defined by the Hierarchical Model Composition package, known by the short name 'comp'. This project would involve implementing support for comp in JSBML. There is already a close-to-complete implementation in libSBML, so a lot is understood about the things that need to be implemented. No JSBML implementation exists yet.

  • Languages and skills: Java
  • Potential mentors: Lucian Smith, the JSBML Team

Image:icon-lightbulb.gif Idea #4: Implement support for the SBML Multistate/Multicomponent Species package

Another of the many packages for SBML Level 3 is Multistate and multicomponent species. This packages define constructs for models and modelers to represent biochemical species that have internal structure or state properties. These may involve molecules that have multiple potential states, such as a protein that may be covalently modified, and molecules that combine to form heterogeneous complexes located among multiple compartments. The JSBML team has already started implementation of the multi package, but more needs to be done.

  • Languages and skills: Java, some exposure to biochemistry
  • Potential mentors: Nicolas Rodriguez, Nicolas Le Novère

Image:icon-lightbulb.gif Idea #5: Improve the libSBML compatibility module

libSBML provides a Java API generated using SWIG, a language wrapper generator. This API is not as "Java-ish" as JSBML's native API. JSBML tries to provide compatibility with much of libSBML's API, and some of the API compatibility is achieved using a specific JSBML module known as the libSBML-JSBML module. This module is started, but need many enhancements and further work. Ultimately, the goal of the libSBML compatibility module in JSBML is to make it possible for current libSBML Java API users to switch to JSBML as transparently and painlessly as possible.

  • Languages and skills: Java, a little bit of C++
  • Potential mentors: Nicolas Rodriguez

Image:icon-lightbulb.gif Idea #6: Add support for Schema-based validation of SBML

SBML files need to be validated carefully to ensure that they conform to the specification. Currently, the most complete implementation of SBML validation is embodied in libSBML, although the rules of SBML validity are defined in the SBML specification documents. It is possible to validate SBML from JSBML using either the Online SBML Validator or a Java package we provide for calling libSBML locally (i.e., without a network connection) but we want to move toward capturing all of the SBML's validity rules in schema languages such as RELAX NG and Schematron, then having both libSBML and JSBML (and any other SBML-using system) use schema validation engines instead of hardcoded validation. This will be especially important as more SBML Level 3 packages become implemented. We have already made great strides in defining RELAX NG schemas for SBML Level 3, but we need to work on providing the hooks in JSBML to using those schemas for validating SBML files.

  • Languages and skill: Java, XML, RELAX NG, Schematron, SBML
  • Potential Mentor: Sarah Keating, Andreas Dräger

Image:icon-lightbulb.gif Idea #7: Finish Cytoscape 2.8 support for SBML

In collaboration with Cytoscape and The National Resource for Network Biology (NRNB), who also have their own GSoC application, this project involves completing an official Cytoscape Plugin. Work has already begun on this in the context of earlier versions of Cytoscape, but some changes in Cytoscape 2.8 have introduced incompatibilities with the JSBML-based reader in Cytoscape. The ultimate goal of this project is to create a plugin that could be downloaded by Cytoscape users.

  • Languages and skill: Java
  • Potential Mentor: Matthias König, Nicolas Rodriguez

Image:icon-lightbulb.gif Idea #8: Support SBML visualization in Cytoscape

Another project in collaboration with Cytoscape and The National Resource for Network Biology (NRNB) is the implementation of support for visualizing SBML networks in Cytoscape. This would obviously require finishing support for reading SBML in Cytoscape (see Idea #7), and then would involve such things as creating appropriate Cytoscape VisualStyle and Visualization elements, the application of symbols and layout algorithms, and so on.

  • Languages and skill: Java, some basic understanding of visualization algorithms
  • Potential Mentor: Matthias König, Nicolas Rodriguez

Final comments

From our perspective, the following are important criteria for a successful JSBML student project:

  • The software must have something that works and is in a finished (or nearly finished) state
  • The software must be integrated, or close to being integrated, in JSBML without too much effort
  • The individual must have interacted well, and continuously, with the JSBML community
  • The amount of work performed must have been significant enough (it's supposed to be a 2 person-month effort)

Some general comments about GSoC:

  • GSoC students should not block on anything for a long period of time. They should ask plenty of questions on the list (but they should also be autonomous!)
  • GSoC students should be as much as possible in contact with the community, following the mailing lists (and answering mails, when they know what to say), give regular status updates on their project. This does not mean that a GSoC student is not allowed to take a break, of course, but that, while working, a student should be integrated as much as possible with the community.
  • When taking a vacation/break, students have to notify the mentor. Mysterious, unexplained disappearances could lead to negative feedback.

Here are some additional resources:

Retrieved from "http://sbml.org/Software/JSBML/JSBML_Project_Ideas_for_Google_Summer_of_Code_2012"

This page was last modified 19:07, 9 March 2012.



Please use our issue tracking system for any questions or suggestions about this website. This page was last modified 19:07, 9 March 2012.