Google Summer of Code 2017 Project ideas

The details of each of our project ideas are listed below, including potential mentors. Interested mentors and students should subscribe to the OBF/GSoC mailing list and announce their interest.

See the main OBF Google Summer of Code page for more information about the GSoC program and additional ways to get in touch with us.

Cross-project ideas

OBF is an umbrella organization which represents many different programming languages used in bioinformatics. In addition to working with each of the “Bio*” projects (listed below), this year we are also accepting a category of “cross-project” ideas that cover multiple programming languages or projects. These collaborative ideas are broadly defined and can be thought of as “unfinished” — interested students should adapt the ideas to their own strengths and goals, and are responsible for the quality of the final proposed idea in their application.

Feel free to propose your own entirely new idea.

GeneNetwork Genome Browser (biodalliance)

GeneNetwork.org (GN) is a Web2.0 environment for genetic analysis in mouse, rat and human (QTL mapping and GWAS). GN is used daily by scientists with over a thousand publications citing it.

Biodiallance.org is a state-of-the-art Javascript genome browser. It is a fast, interactive, genome visualization tool that’s easy to embed in web pages and applications. It supports integration of data from a wide variety of sources, and can load data directly from popular genomics file formats including bigWig, BAM, and VCF. Biodiallance has been adopted by some major bioinformatics websites including, for example, UK10K.

Rationale

To improve user experience and improve biomedical discovery we are improving advanced genome visualisation and embedding the state-of-the-art biodiallance genome browser into GN with several new tracks for visualizing mapped QTL, underlying genotypes and SNP density.

Biodalliance

Approach

BioDiallance has good abstractions for tracks and fetching data. We will add fetching data on-the-fly from GN backends through a REST interface and/or cache locally. Also we will add interaction that when a user clicks on a QTL, for example, the browser can display additional information and even initiate some back-end processing.

We will use continuous open channels between the browser and the backend.

Languages and skill

Biodiallance is written in Javascript and the latest tracks support PureScript. GeneNetwork is mostly python and Javascript. The GN REST interface is written in Elixir.

Code

Difficulty

  • medium mostly PureScript and Javascript, but python and elixir may come in handy

Mentors

Pjotr Prins, Danny Arends and Karl Broman

Contact

Extending the fastest Dlang SAM/BAM/CRAM parser for ADAM format I/O (sambamba)

In 2012 we created sambamba as a Google Summer of Code project written in the D programming language. This tool is in active use in DNA sequencing centers around the world and is an important component of analysis pipelines such as bcbio-nextgen. It is easily installable from bioconda. For usage of sambamba read the docs.

Rationale

BAM is the most popular file format for storing sequence alignments, but it has some disadvantages (no support for modern light compression, row-based storage).

We believe that Adam columnar format needs more adoption: because under the hood it is a widely used Parquet format, it can be easily loaded as a Spark dataframe into Python, R, or Scala, thus providing easy scaling on a cluster even for simple one-off scripts.

The provided BAM → ADAM converter is rather slow, taking about half an hour (8 threads) to convert a 10GB BAM file. This is a barrier for adoption: for comparison, recompressing the same file with sambamba (BAM → BAM) using 8 threads takes only about 5 minutes.

Faster conversion speed is not easily attainable on JVM platform, partly because htsjdk BAM reader is single-threaded and is known to be slow. Sambamba, on the other hand, provides a solid base for building a fast converter.

Approach

ADAM files can be rather easily read/written with the aid of parquet-cpp and avro C/C++ libraries.

D has great support for interfacing with C and even some support for C++.

We suggest to begin with adding read support to familiarize with BAM and ADAM formats, sambamba codebase, and all the libraries involved. After that the writing codepath can be added. Optionally, filtering in the reader can be then enhanced by leveraging Parquet metadata and columnar structure.

Languages and skill

The student should have an interest in using different programming languages, but good knowledge of C++ is enough. We will provide the student with minimal code to get started.

The deployment and programming environment will be handled by GNU Guix which can run on any Linux distribution, including Ubuntu and Fedora.

Code

Difficulty

  • hard

Mentors

Pjotr Prins, Artem Tarasov. We will also ask James Bonfield (htslib) and one of the ADAM authors.

antiSMASH

antiSMASH is a tool to mine the genomes of micro-organisms for biologically interesting gene clusters, so-called secondary metabolites, to help find new antibiotics. It is a python-based open source tool that is developed at the Technical University of Denmark and Wageningen University.

Project ideas around antiSMASH range from very close to applied biology to more general software engineering projects.

Improve gene cluster visualization (SVGene)

Rationale

antiSMASH generates a static HTML page report with prediction results for analysis runs. This is the main UI used by the experimental biologists. To give an overview of the gene cluster layout, antiSMASH uses the SVGene JavaScript library to render gene cluster arrows as vector graphics. So far, this is a static SVG, with some tooltip boxes added to provide the user with extra context:

antiSMASH gene cluster

To further improve the user experience, zooming and panning should be implemented. Once zoomed in, additional details can be displayed as well.

Approach

antiSMASH renders gene clusters using the SVGene JavaScript library, which in turn is built on top of D3.js. D3.js supports controls for pan and zoom that should be used for SVGene. Gene cluster data for the HTML page is loaded from a JavaScript file included in the static web page. Additional details should be displayed on a bigger zoom level if available, possibly on separate tracks.

Languages and skill

SVGene is written in JavaScript and making heavy use of the D3.js library for drawing the SVG primitives. Some Python knowledge might make it easier to extend antiSMASH’s precalculated output, but is not required, as mock inputs can be used for the project.

Code

Difficulty

  • easy with previous knowledge of D3.js
  • medium otherwise

Mentors

Kai Blin, Tilmann Weber

Biopython SeqRecord access abstraction layer for antiSMASH

Rationale

Internally, antiSMASH uses Biopython’s SeqRecord objects to handle the data. A lot of the annotations are in custom feature entries or in free-text qualifiers of “gene” or “CDS” features. Code for handling this access is duplicated in parts of the code base. Additionally, directly using the SeqRecord object is a bit fragile.

Approach

Code for accessing the antiSMASH-specific features/qualifiers should be hidden behind an API layer that unifies the access. The new abstraction layer should then be utilized to reduce the code duplication and fagility of acessing the SeqRecord object special fields.

Languages and skill

antiSMASH is written in Python 2.7 (while Biopython targets Python 2.7 and 3.3 onward). Knowledge of unit testing in Python is a plus. Biological knowledge is not required.

Code

Difficulty

easy

Mentors

Kai Blin, Tilmann Weber

OpenMS

OpenMS is an open-source software C++ library for LC/MS data management and analyses. It offers an infrastructure for the rapid development of mass spectrometry related software. OpenMS is free software available under the three clause BSD license and runs under Windows, MacOSX and Linux. The source code is hosted publicly available on GitHub.

Implement algorithms for the generation of high-resolution isotope patterns

Rationale

Mass spectrometry has become one of the bioanalytical tools of choice for many life scientists. Technological advancements in the last years have led to an increase in acquisition speed and resolution. Common tasks, like identifying and quantifying proteins and metabolites from biological or medical samples are regularly performed in different fields of research, industry, and clinical diagnostics.

Modern mass spectrometers are becoming more and more capable of resolving not only the mass of a molecule but also of its naturally occurring variants with different isotopic composition. Simply speaking, if the “isotopic fine structure” is known, the exact chemical formula can be derived and be used to resolve ambiguities in the identification of molecules.

Approach

OpenMS currently includes a theoretical isotope pattern generator that calculates a coarse version of the isotopic structure.

Several papers have been published that describe implementations of a high-resolution isotope pattern algorithm, e.g.: MIDAS and Mercury5 Multidimensional Fourier Transform, https://github.com/alexandrovteam/ims-cpp/tree/master/ms

for which reference implementations are provided by the authors. They could be potentially interesting algorithms that can be validated against a reference implementation.

OpenMS tool developers and users alike would benefit from well-tested, native implementations using the OpenMS library. In the future, this implementation could be used by others to build novel tools or improve existing ones.

Languages and skills

  • Intermediate knowledge of C++ and its STL. Knowledge of Boost’s Math Library might be of use.
  • Depending on the implemented algorithm, intermediate knowledge of polynomial algebra and mathematical convolutions.
  • Basic knowledge on atom masses and isotopes (can be acquired in the first days).
  • Basic knowledge on mass spectrometry (can be acquired in the first days).

Code

Expected outcome:

The existing implementation for low-resolution data in OpenMS (IsotopeDistribution) should be extended by at least one algorithm for high-resolution data.

We suggest the MIDAS and Mercury5 algorithm but are open for suggestions. Pseudocode and reference implementations can be provided and found in the publications.

Difficulty

medium.

Mentors

Timo Sachsenberg, Julianus Pfeuffer, Oliver Alka

Implement algorithms for peptide identification

Rationale

In mass spectrometry based proteomics, identifying proteins from biological or clinical samples is a key task.

In the last years, there has been significant progress in peptide identification algorithms.

Approach

OpenMS mainly relies on external peptide identification engine. It includes a SimpleSearchEngine tool that performs basic peptide identification and has been mainly intended for educational purposes.

OpenMS tool developers and users alike would benefit from an improved implementation of a peptide search engine in the OpenMS library. In the future, this implementation could be used by others to improve algorithms, build novel tools or integrate identification into existing ones.

Languages and skills

  • Intermediate knowledge of C++ and its STL.
  • Good knowledge of tandem mass spectrometry.

Code

Expected outcome:

The existing implementation should be extended and improved. Improvement should be benchmarked on publicly available datasets.

Difficulty

hard.

Mentors

Timo Sachsenberg, Julianus Pfeuffer, Oliver Alka

Common Workflow Language

The Common Workflow Language standards enable bioinformaticians and other researchers to describe their data analysis workflows in a portable, interopable, and executable manner without being dependent on a particular workflow system.

CWL viewer

(image from https://view.commonwl.org/workflows/github.com/common-workflow-language/workflows/tree/master/workflows/lobSTR )

CWL reference implementation (cwltool)

also known as “Common Workflow Language reference implementation modernization”

cwltool is the reference implementation of the Common Workflow Language. cwltool’s main purpose is demonstrate the majority of the features of CWL by executing data analysis tools and workflows described in CWL v1.0 documents.

It is intended to be feature complete and provide comprehensive validation of CWL files as well as provide other tools related to working with CWL.

Rationale

The goal of the project is to enhance cross platform compatibility and usability of cwltool, specifically by migrating to Py2+3 and adding Microsoft Windows support

  • Python 3 support for schema-salad (rules for preprocessing, structural validation, and link checking for CWL documents) and cwltool overall
  • Windows support for cwltool, configuring continuous integration to keep it from breaking
  • Resolving some of the Github issues on the way

Approach

cwltool uses continuous conformance testing to comply with the latest specification.

Languages and skill

cwltool is written and tested for Python 2.7. Python 3 experience, familiarity with unit and continuous testing is desired. No background in data intensive science is required.

Code

Difficulty

  • medium

Mentors

Michael R. Crusoe, Anton Khodak

Contact

Add IO streaming to CWL reference implementation

You can mark parts of a data analysis workflow as supporting streaming IO when using the Common Workflow Language via the streamable: true directive

Rationale

However, cwltool (the reference implementation of the Common Workflow Language) does not implement any streaming IO optimzation and ignores the streamable flag.

In order to add streaming support cwltool will also need to be able to execute steps simultaneously.

Approach

One of the goals of the reference implementation is to have a simple code base to enhance learning and simplify maintenance.

This project will require studying multiple methods of enabling co-execution of steps (and enabling streaming IO via unix named FIFOs (“pipes”)) and choosing the method that produces the most maintable code. Preferably external libraries that are well maintained and well documented are used to keep code growth to a minimum.

cwltool uses continuous conformance testing to comply with the latest specification.

Languages and skill

cwltool is written and tested for Python 2.7. Python 3 experience, familiarity with unit and continuous testing is desired. No background in data intensive science is required.

Code

Difficulty

  • medium

Mentors

Michael R. Crusoe

Contact

Bionode

Bionode workflow engine for streamed data analysis (bionode-watermill)

Rationale

This is a continuation of a 2016 GSOC project, which got off to a good start, but needs more work!

Researchers should be able to:

  • Perform analyses while data are generated (i.e., with “data streams”);
  • Easily and rapidly update results if input data or analysis approaches/parameters change (with minimal recomputation);
  • Effortlessly change and scale underlying computing platforms while pipeline is running;
  • Easily visualise results.

This is largely impossible because current approaches were developed when datasets were simpler and smaller. The student will take advantage of recent improvements in generic analysis tools (Node.js Streams & asynchronous concurrency) to attain the above objectives.

Approach

The student will create a workflow engine for streamed data analysis with concurrent pipelining. Julian Mazzitelli, the developer of bionode-watermill will be available for discussions regarding code implementation, design patterns of the existing project, and general programming aid. Max Ogden and Mathias Buus, top Node.js contributors and founders of Dat-data.com, will provide technical help with aspects related to streaming and JS. Bruno Vieira (founder of Bionode.io) and Yannick Wurm (lecturer in Bioinformatics at QMUL) will co-supervise.

As well, the student will incorporate the Common Worklflow Language (CWL) specification into the project. This will entail implementing interoperability/validation between bionode-watermill’s task objects and CWL documents.

Some work on the data structures and programming interfaces for commonly used data sources (e.g., NCBI, Uniprot, Ensembl/Biomart) and data types (e.g., VCF, BAM, FASTQ) will be required.

The underlying computational architecture should be abstracted. This means that analysis code will run identically using different traditional high performance computing system (e.g., Torque, SGE) and modern systems (e.g., Hadoop MapReduce).

Languages and skill

JavaScript skills are required. Node.js and some biology knowledge is a plus. Difficulty is medium.

Difficulty

medium

Mentors

Julian Mazzitelli, Max Ogden, Mathias Buus, Bruno Vieira, Yannick Wurm

Code

Contact

ETE TOOLKIT

The ETE toolkit is a Python software intended for the integrative reconstruction, analysis and visualization of phylogenetic trees. ETE is widely used in the computational biology field, particularly for large phylogenomic studies (>270 citations, >3000 ETE 3.0 downloads).

GSoC Contact

If interested in any of the following project ideas, or you want to propose a new one, please contact us early, preferably at ete-gsoc-mentors@googlegroups.com

1. Developing a novel format for phylogenomic data

Rationale

Phylogenetic trees are usually encoded using the so called Newick format. While convenient, this format has limitations to store metadata associated to the different nodes in a tree. Some alternative formats exist (NeXML, PhyloXML, Nexus) which are already supported by the ETE toolkit. However, none of those formats is optimal to i) encode ETE graphical properties associated to nodes ii) store large trees or huge collections of trees iii) access metadata from large datasets in an indexed way.

In addition, a community of developers specialized in tree visualization software is brainstorming about possible ways to make the process of composing and sharing figures more portable and transparent. It is expected that this project keeps in sync with the expected outcome of such meetings and provide support for the conventions and tree annotation vocabulary agreed.

Goals

  1. Develop a data format capable of storing trees, metadata and graphical features associated to nodes. The following features are ambitioned: Tree structure and node metadata indexing, data compression, possibility of having multiple trees in a file, possibility of exporting in plain text, portability.
  2. Integrate the format into ETE, so annotated ETE trees (including graphical features) can be read, exported and exchanged with ease.
  3. Develop basic converters from most common formats to date: i.e. Newick, Extended Newick and Nexus.

Possible approaches

  • Use SQLite: See this prototype API implementation currently used to store and query a very large tree
  • Use a novel data format based indexing a tabular tree format

Difficulty

Medium

Languages and skills

  • Good Python programming skills
  • Experience on Object Oriented Programming in Python

Mentors

  • Jaime Huerta-Cepas (EMBL, Germany)
  • Francois Serra (CNAG-CRG, Spain)
  • Renato Alves (EMBL, Germany)
  • Łukasz Roguski (CNAG-CRG, Spain)

Contact

ete-gsoc-mentors@googlegroups.com

2. Improve the usability of the command line tools and develop a Graphical User Interface (GUI) to execute jobs

Rationale

ETE-build is a command line tool that provides a unified interface for the reproducible execution of complex phylogenetic workflows. Those workflows are composed of several steps that require calling multiple third-party programs as well as parsing and processing results. At the moment, ETE-build can be used to easily execute those workflows with a single command line. All the required tasks are then handled by an internal scheduling system, so third party software is executed transparently.

Goals

  1. Developing a graphical user interface that allows to run workflows and visualize results
  2. Adding windows support (currently only Linux and OSX are officially supported).
  3. Fixing and improving known issues in the scheduling and pipeline system
  4. Adding new workflows and application bindings.

Difficulty

Medium

Languages and skills

  • Good Python programming skills
  • Experience on Object Oriented Programming in Python
  • Some tasks will require basic understanding of the phylogenetic reconstruction process.

Mentors

  • Jaime Huerta-Cepas (EMBL, Germany)
  • Francois Serra (CNAG-CRG, Spain)
  • Renato Alves (EMBL, Germany)

Contact

ete-gsoc-mentors@googlegroups.com

Rationale

Although the syntax of ETE’s tree rendering engine is highly flexible and allows creating a variety of complex tree visualizations, this usually involves substantial scripting work. Predefined layouts could be provided in the form of ETE python scripts, that permit to style trees according to most common usages. For instance, the following tree figures could be entirely renderable using ETE, but not predefined scripts exist yet for that purpose:

alt text

Goals

  • Develop a gallery of layouts in the form of Python scripts that cover most common visualizations in phylogenetics (i.e. selection of good color schemes, deciding what graphical features to show or hide depending on context)
  • Develop new Face types as necessary
  • Improve ETE’s rendering system, so multiple layouts can be applied as semantic layers. For instance:

TreeStyle.layout = [block_alignment_layout, color_duplication_nodes_layout, ….]

Difficulty

Easy (from a programming point of view, but good graphical designing skills necessary)

Languages and skills

  • Good Python programming skills
  • Experience on Object Oriented Programming in Python
  • Good in data visualization

Mentors

  • Jaime Huerta-Cepas (EMBL, Germany)
  • Francois Serra (CNAG-CRG, Spain)
  • Renato Alves (EMBL, Germany)

Contact

ete-gsoc-mentors@googlegroups.com

4. Tree searching using regular-expression-like queries

Rationale

Although several methods allow comparing trees using ETE, no search capabilities exist that permit to query tree topologies for specific patterns. The goal of this project is to develop a new ETE module that allows querying large collections of trees using custom criteria. Searches should be flexible and allow for regular-expression-like queries, returning a list of all internal nodes in the matching trees where the criteria is fulfilled.

Applications of the framework would enable any user to perform complex queries on a variety of tree-like data in research, such as clustering results and phylogenetic trees. This is specially relevant in the Phylogenomics field (ETE focus), where thousands of phylogenetic trees are being generated and scanned for specific evolutionary patterns. Based on previous ETE developments and last-year GSoC work, a prototype tree-matcher program exists, which provides basic functionality and examples.

Goals

Difficulty

Medium

Languages and skill

  • Good Python programming skills
  • Experience on Object Oriented Programming in Python
  • Familiarity with the Newick Tree format and the concept of phylogenetic gene trees (i.e. see this)
  • Familiarity with tree related algorithms (i.e. tree traversing, tree comparison)
  • Optional (for addressing visualization): familiarity of Qt4 drawing system (QGraphicsScenes)

Mentors

  • Francois Serra (CNAG-CRG, Spain)
  • Łukasz Roguski (CNAG-CRG, Spain)
  • Jaime Huerta-Cepas (EMBL, Germany)
  • Renato Alves (EMBL, Germany)

Contact

ete-gsoc-mentors@googlegroups.com

Web services

Create submission and publication web server for the ‘Journal of Open Data’

Rationale

We are creating a Journal of Open Data (JOD) in the vein of the Journal of Open Source Software (JOSS) of which we are editors.

The idea is simple: anyone who has a ‘stable’ data provider with a long living URL can publish the URL with some simple metadata (description, authors, license) and receive a DOI. This DOI can be cited by others using that data.

Having a citable publication will encourage scientists to put their data in the public domain. It will also encourage data providers to offer such services.

For submissions we want to create a system similar to what JOSS has, but we do not want to have to rely on github-based issue trackers. If we create a good system the web server may also be adopted by JOSS itself.

Approach

We will use a Python or Ruby based frame work, depending on the skills of the student. The browser code will be PureScript and Javascript. The issue tracker can be implemented as a BLOG style tracker with comments. We will need facilities for pre-review, review, acceptance and rejection. We will also provide RDF support that can be used for data discovery and a SPARQL endpoint.

Languages and skill

This requires web programming with a database as a backend. JOSS is written in Ruby on Rails, so that may be a good starting point.

Code

Difficulty

  • medium mostly Ruby or Python for the back-end and PureScript and Javascript for the front-end. Understanding of HTML and SQL may come in handy.

Mentors

Joep de Ligt, Pjotr Prins, George Githinji and Arfon Smith

Contact

  • IRC: #genenetwork on Freenode
  • JOSS issue tracker
  • The opiniated mailing list for JOSS editors
  • Direct: pjotr.public345 at thebird.nl