Scott Edmunds

![ShinyLearner](http://gigasciencejournal.com/blog/wp-content/uploads/2020/04/giaa026fig7-300x206.jpeg){.alignright
.size-medium .wp-image-3275 loading="lazy" decoding="async" width="300"
height="206"
srcset="http://gigasciencejournal.com/blog/wp-content/uploads/2020/04/giaa026fig7-300x206.jpeg 300w, http://gigasciencejournal.com/blog/wp-content/uploads/2020/04/giaa026fig7.jpeg 766w"
sizes="(max-width: 300px) 100vw, 300px"}This week [we
showcased](http://gigasciencejournal.com/blog/codecheck-certificate/) a
new way of peer reviewing software, testing code in an independent
manner and providing a CODECHECK *"certificate of reproducible
computation"* when the results in the paper can be reproduced. We've
[written a post on the CODECHECK
process](http://gigasciencejournal.com/blog/codecheck-certificate/)
featuring a Q&A with [CODECHECK](http://codecheck.org.uk/) founder
Stephen Eglan, and here we'll provide a follow up with a Q&A with the
author of the software that was subject to the
[CODECHECK](http://codecheck.org.uk/) certification process. Another
Stephen, author Stephen Piccolo talks here about his new paper on
ShinyLearner, a benchmarking tool for machine-learning classification
algorithms.

![ShinyLearner
author](http://gigasciencejournal.com/blog/wp-content/uploads/2020/04/brightspotcdn.byu_.edu_-150x150.jpg){.alignleft
.wp-image-3276 loading="lazy" decoding="async" width="135" height="135"
srcset="http://gigasciencejournal.com/blog/wp-content/uploads/2020/04/brightspotcdn.byu_.edu_-150x150.jpg 150w, http://gigasciencejournal.com/blog/wp-content/uploads/2020/04/brightspotcdn.byu_.edu_.jpg 200w"
sizes="(max-width: 135px) 100vw, 135px"}The paper stands out by making
this process very systematic and reproducible, and we ask Stephen about
why [classification
algorithms](https://dzone.com/articles/introduction-to-classification-algorithms)
are so important, why he uses reproducible and open research in his
work, and how the CODECHECK review process was from an authors
perspective. Stephen is an [Assistant Professor in the College of Life
Science](http://piccolo.byu.edu/) at Brigham Young University, working
in an open and reproducible way to integrate knowledge and techniques
across biology, computer science, medicine, and statistics.**  
**

**Why are there so many classification algorithms and why do they need
to be benchmarked?**

Computer scientists and statisticians have been creating and refining
classification algorithms [for
decades](https://doi.org/10.1111/j.1469-1809.1936.tb02137.x). Research
papers have been published on hundreds of these algorithms, and
implementations are available in the public domain for many of them. In
many research areas (biological or otherwise), classification algorithms
can help to identify patterns that distinguish two or more groups and
then be used to predict the group to which new observations belong.
However, it is difficult for scientists to know which classification
algorithm is best for a particular research application. In addition,
most algorithms support
[hyperparameters](https://en.wikipedia.org/wiki/Hyperparameter_(machine_learning)),
which allow the scientist to modify the algorithm's behavior, but it is
inefficient and bias-prone to tune these algorithms in an *ad
hoc* manner. Benchmark analyses address this problem by making the
algorithm/parameter comparisons systematic in nature. We can apply tens
or even hundreds of algorithm variations to benchmark datasets and
identify which tend to perform best.

**Why did you build ShinyLearner and what technical approaches did you
take to design it?**

We created [ShinyLearner](https://github.com/srp33/ShinyLearner) to make
it easier to perform benchmark comparisons. Several open-source software
libraries are available for performing classification analyses. But most
require the scientist to write computer code to perform analysis.
Generally, these libraries perform parameter tuning, but they provide
little insight into this process. We sought to provide a tool that
requires no coding to perform the analysis and that generates simply
formatted output files so users can more easily gain insight into
benchmark results. It encapsulates 4 open-source, machine-learning
libraries into a "software container" and provides a consistent
interface for working with any of them. The use of software containers
makes the installation process easier because it already includes all
the software you need to execute the analysis. All you need is to
install the [Docker](https://www.docker.com/) software (or a related
tool for working with containers) and download the container image. The
user then executes the software at the command line (terminal). To ease
this process, we created a web application that helps the user construct
the commands they need to execute. One more tidbit: within the software
container, we use a combination of 4 programming languages to piece
everything together: Python, R, Java, and bash scripting. Most projects
would limit themselves to 1-2 programming language, but we needed to
write code in these various languages to interface with the different
machine-learning libraries but also because in some cases, it seemed
more efficient to use one language over another to implement the desired
functionality. By using software containers, the end user doesn't need
to worry about this complexity or install (specific versions of )
runtimes for all of these languages.

**This was an open source tool that used many techniques for
computational reproducibility, so what drove you to follow open science
practices?**

Nowadays, most scientists will not take seriously a journal article
describing a piece of research software unless it is open source. They
want to be able to see the code and verify its design and functionality
directly. This is a great thing! I am still baffled when I see a
research article that describes software or an algorithm but doesn't
make the code available.

In [this paper](https://doi.org/10.1093/gigascience/giaa026), we also
followed open-science practices by sharing our analysis scripts (in
addition to the actual [ShinyLearner
software](https://github.com/srp33/ShinyLearner)). We wanted others to
be able to see the exact code we used to generate the figures in our
paper. [We used CodeOcean](https://doi.org/10.24433/CO.5449763.v1), a
cloud-computing service that provides a free tier for open science
projects \[see [previous
blog](http://gigasciencejournal.com/blog/data-intensive-software-publishing-sailing-the-code-ocean-qa-with-ruibang-luo/)
on the platform\]. We did this for the sake of transparency and because
we knew that when we submitted the paper to a journal, at least one
reviewer would want us to tweak our analysis. Because we had already
packaged it up nicely and made it available for others, it was also easy
for us to remember each step of the analysis and tweak what we needed to
tweak. Finally, we used open-science practices because that's what we
like to see in others.

**How was the process of undergoing a CODECHECK review as an author?**

For me, the [CODECHECK](http://codecheck.org.uk/) process was easy. The
reviewer set everything up. I just needed to verify that his review was
reasonable and had been configured properly \[see the [certificate
here](http://doi.org/10.5281/zenodo.3674056)\].

**From an author's perspective does the CODECHECK certificate seem a
good incentive and reward for making your work easy to use? Do you think
it may drive authors to improve the way they release and write up
software papers?**

![CODECHECK
certificate](http://gigasciencejournal.com/blog/wp-content/uploads/2020/04/Screenshot-2020-04-06-at-4.27.42-PM-300x281.png){.alignright
.wp-image-3272 loading="lazy" decoding="async" width="222" height="208"
srcset="http://gigasciencejournal.com/blog/wp-content/uploads/2020/04/Screenshot-2020-04-06-at-4.27.42-PM-300x281.png 300w, http://gigasciencejournal.com/blog/wp-content/uploads/2020/04/Screenshot-2020-04-06-at-4.27.42-PM-768x721.png 768w, http://gigasciencejournal.com/blog/wp-content/uploads/2020/04/Screenshot-2020-04-06-at-4.27.42-PM-1024x961.png 1024w, http://gigasciencejournal.com/blog/wp-content/uploads/2020/04/Screenshot-2020-04-06-at-4.27.42-PM.png 1068w"
sizes="(max-width: 222px) 100vw, 222px"}It's nice to have that stamp of
approval and peace of mind knowing that at least one outside person was
able to reproduce our work. I wasn't aware of this certificate before
submitting to this journal. So it wasn't a big motivation for me at the
time. But going forward, I would be motivated by the certificate because
it would tell me the journal is serious about following good scientific
practices. Few other journals make the extra effort to really verify
your code when it is open source. I would love to see this become
standard practice. It's more work for everyone in the short term, but in
the long run it's very beneficial. It won't always prevent research
misconduct or ensure that a scientific analysis is impactful, but it's a
simple way to encourage open science.

If authors knew that they would need to pass a
[CODECHECK](http://codecheck.org.uk/) from the beginning, it would
motivate them to follow practices early in the process that would
support open, reproducible science. This would benefit themselves but
also the broader community. I touch on this in more detail in an earlier
*Gigascience* paper ([Tools and techniques for computational
reproducibility](https://doi.org/10.1186/s13742-016-0135-4)).

*Read more in our [previous post on
CODECHECK](http://gigasciencejournal.com/blog/codecheck-certificate/).
Stephen Eglen presented CODECHECK at The 14th Munin Conference on
Scholarly Publishing 2019 and you can watch a [video recording
here](https://mediasite.uit.no/Mediasite/Play/8027873496dc465ebc4b9b3ab0338ad01d?playFrom=1772000).*

### **References**

Piccolo SR. et al.,  ShinyLearner: A containerized benchmarking tool for
machine-learning classification of tabular data, *GigaScience*, Volume
9, Issue 4, April 2020,
doi:[10.1093/gigascience/giaa026](https://doi.org/10.1093/gigascience/giaa026)

::: {.col-md-8}
::: {.blog-post}
Eglen SJ. CODECHECK Certificate 2020-001. Zenodo. 2020[
<http://doi.org/10.5281/zenodo.3674056>]{.ng-binding}
:::
:::

::: {.col-md-3 .col-md-offset-1}
::: {.panel-body}
Piccolo SR, Frampton MB. Tools and techniques for computational
reproducibility. *Gigascience*. 2016;5(1):30. Published 2016 Jul 11.
doi:[10.1186/s13742-016-0135-4](https://doi.org/10.1186/s13742-016-0135-4)
:::
:::

The post [Reproducible Classification. Q&A on ShinyLearner & the
CODECHECK certificate, pt.
2](http://gigasciencejournal.com/blog/shinylearner-codecheck/){rel="nofollow"}
appeared first on
[GigaBlog](http://gigasciencejournal.com/blog){rel="nofollow"}.


This week we showcased a new way of peer reviewing software, testing code in an independent manner and providing a CODECHECK
<em>
 “certificate of reproducible computation”
</em>
when the results in the paper can be reproduced.

Reproducible Classification. Q&amp;A on ShinyLearner &amp; the CODECHECK certificate, pt. 2

::: {#attachment_1843 .wp-caption .alignright style="width: 180px"}
![Björn
Grüning](http://gigasciencejournal.com/blog/wp-content/uploads/2016/09/Bjorn-256x300.jpg){.wp-image-1843
loading="lazy" decoding="async"
aria-describedby="caption-attachment-1843" width="170" height="199"
srcset="http://gigasciencejournal.com/blog/wp-content/uploads/2016/09/Bjorn-256x300.jpg 256w, http://gigasciencejournal.com/blog/wp-content/uploads/2016/09/Bjorn-768x900.jpg 768w, http://gigasciencejournal.com/blog/wp-content/uploads/2016/09/Bjorn-873x1024.jpg 873w, http://gigasciencejournal.com/blog/wp-content/uploads/2016/09/Bjorn.jpg 1589w"
sizes="(max-width: 170px) 100vw, 170px"}

Björn Grüning modelling one of our t-shirts.
:::

Nowadays, massive amounts of diverse data are generated in biomedical
research. To manage it and extract useful information, bioinformatic
solutions are needed and software must be developed. The development of
a tool should always follow a similar process. First, to solve a
scientific question or a need, some source code is developed, that can
be distributed as it is. To help its deployment and simplify the tool
installation, the code is packaged in various package formats. The tool
behind the code is then deployed and used by the targeted users.
Ideally, documentation, training and support are also provided to help
users spread the solution and advertise it.

This process, from development to support, is the golden path to develop
a tool for wider adoption and reuse. But issues for deployment and
sustainability of the tool are found for many bioinformatic tools. What
bioinformaticians have not dealt with is the situation of missing tool
dependencies, or an older version of a tool could not be installed due
to various reasons. Deployment and sustainability of tools are therefore
a major issue for productivity and reproducibility in science \[see
*GigaScience*'s "[Ten recommendations for software engineering in
research](https://gigascience.biomedcentral.com/articles/10.1186/2047-217X-3-31)"
for more on this topic\].

For deployment issues, we need a [package
manager](https://en.wikipedia.org/wiki/Package_manager) that is
operating system and programming language agnostic, as bioinformatic
tools are developed in a myriad of languages and operating systems,
including ancient ones. Moreover all available packages have to be
permanently cached to be always reachable and to enable reproducibility.

One community effort to create a flexible, scalable and sustainable
system to fix the tool deployment problem once and for all is
[Bioconda](https://bioconda.github.io/), and here I describe work over
the last six months integrating Conda packages as a new standard for
tool dependencies in [Galaxy](http://usegalaxy.org/). Not only do Conda
packages make tool dependencies in Galaxy more reliable and stable, they
are also easier to test and faster to develop than previous processes.

Galaxy tools (also called wrappers) traditionally use [Tool
Shed](https://toolshed.g2.bx.psu.edu/) package recipes to install their
dependencies. At the tool's installation time the recipe is downloaded
and executed in order to provide the underlying software executables.
Introduction of these Galaxy-specific recipes was a necessary step at
the time, however there are now more mature and stable options to
install software in a similar manner. The Galaxy community has taken
steps to improve the tool dependency system in order to enable new
features and expand its reach.

[Bioconda](https://bioconda.github.io/) is a community that packages
bioinformatics software for Conda, an open source package manager. A
single conda package recipe can be used on a wide range of operating
systems (Windows, Linux, OS X) with no restrictions regarding the tools'
programming language. Installation of Conda packages is fast and robust.
No root privileges are required and multiple versions of every software
can be installed and managed in parallel. Helped by an extensive
documentation, writing a Conda package is very simple, easing community
contribution. These packages are also stored long-term in a public
repository [(Cargo Port)](https://depot.galaxyproject.org/software/),
the distribution center of the Galaxy Project, resolving the
sustainability issue. Moreover, a technique called "layer donning" has
been recently introduced to build Docker containers automatically and
very efficiently for all Conda packages.

Development of Conda packages through the Bioconda community eases the
packaging and the deployment of bioinformatic tools. The interface with
Cargo Port enables sustainability by mirroring all sources. Building
efficient Linux containers automatically ensures an even higher layer of
abstraction and isolation of the base system. Thanks to these
collaborative projects, their community and their collaborations,
bioinformatics tools can be easily packaged, deployed and will be
available to help biomedical research.

As a community, we have decided that Conda is the one that best fulfils
our needs. The following are some of the crucial Conda features that led
to this decision:

- Installation of packages does not require root privileges
  (installation at any location the Galaxy user has write access to)
- Multiple versions of software and corresponding dependencies can be
  installed in parallel
- Ready for High Performance Computing
- Faster and more robust package installations through pre-compiled
  packages (no build environment complications)
- Independent of programming language (works with R, Perl, Python,
  Julia, Java, pre-compiled binaries, and more)
- Easy to write package recipes (1 YAML description file + 1 install
  script)
- An active, large and growing community (with more and more software
  authors managing their own recipes)
- Extensive documentation: both for
  [Conda](http://conda.pydata.org/docs/building/build.html)
  documentation and [Conda
  quick-start](http://conda.pydata.org/docs/get-started.html).

For more technical details we have [FAQ
documentation](https://docs.galaxyproject.org/en/master/admin/conda_faq.html)
on the Galaxy website, and Lance Parsons has collected some of the most
common questions (including [how to enable Conda for existing Galaxy
installations](https://docs.galaxyproject.org/en/master/admin/conda_faq.html#how-do-i-enable-conda-dependency-resolution-for-existing-galaxy-installations),
[how do Conda dependencies
work](https://docs.galaxyproject.org/en/master/admin/conda_faq.html#how-do-conda-dependencies-work-where-do-things-get-installed),
[requirements](https://docs.galaxyproject.org/en/master/admin/conda_faq.html#what-is-required-to-make-use-of-this-any-specific-packages-galaxy-revision-os-version-etc),
[finding
packages](https://docs.galaxyproject.org/en/master/admin/conda_faq.html#where-can-i-find-a-list-of-existing-conda-packages-that-i-can-point-to-so-i-don-t-have-to-reinvent-the-wheel-for-common-dependencies),
and more). If this list does not solve your problem or you have any
trouble following the instructions, please ask on the galaxy [mailing
list](https://wiki.galaxyproject.org/GetInvolved#Mailing_Lists) or the
[IRC channel](http://webchat.freenode.net/?channels=#galaxyproject).

One last thing that is important to me: the entire Conda project is an
amazing community effort -- not only within the Galaxy community, but we
team up with the Conda community as well, in particular with the
**BioConda** folks. Thanks to **Johannes Köster, Ryan Dale** and the
entire community around this package manager which have created around
1500 bioinformatics packages just in the last year.

Thanks to **John Chilton** who has written the Galaxy Conda integration
last December and is pushing tool development in Galaxy to a new level.
Many thanks to **Nicola Soranzo** for his constant support and reviews
in all mentioned projects, he is everywhere to help -- you will see!
Thanks also to **Peter van Heusden**, **Marius van den Beek** and **Brad
Langhorst** -- they have worked hard on Conda-Galaxy Integration to make
it shine. I want to thank **Lance Parsons** for his questions that
inspired me to write this down and his constant support in making tools
better in Galaxy -- I hope with Conda you will have less pain with
tool-dependencies.

![](http://gigasciencejournal.com/blog/wp-content/uploads/2016/09/Screen-Shot-2016-09-20-at-13.50.57-300x190.png){.alignright
.wp-image-1845 loading="lazy" decoding="async" width="278" height="176"
srcset="http://gigasciencejournal.com/blog/wp-content/uploads/2016/09/Screen-Shot-2016-09-20-at-13.50.57-300x190.png 300w, http://gigasciencejournal.com/blog/wp-content/uploads/2016/09/Screen-Shot-2016-09-20-at-13.50.57-768x488.png 768w, http://gigasciencejournal.com/blog/wp-content/uploads/2016/09/Screen-Shot-2016-09-20-at-13.50.57-1024x650.png 1024w, http://gigasciencejournal.com/blog/wp-content/uploads/2016/09/Screen-Shot-2016-09-20-at-13.50.57.png 1852w"
sizes="(max-width: 278px) 100vw, 278px"}Last but not least I would like
to thank the entire [IUC](https://wiki.galaxyproject.org/IUC) and the
over **50 IUC contributors** that have migrated most of the IUC tools to
Conda packages over the last 6 months.

Enjoy Galaxy + Conda,

Björn Grüning, on behalf of The Intergalactic Utilities Commission.

***For more on the efforts between** **GigaScience** **and the Galaxy
community see** [**this
blog.**](http://blogs.biomedcentral.com/gigablog/2014/02/06/rewarding-reproducibility-first-papers-in-our-galaxy-series-utilizing-our-gigagalaxy-platform/)
**We also have our** [**GigaGalaxy.net**](http://gigagalaxy.net/)
**server for presenting and hosting the computational outputs and
methods of studies published in** **GigaScience, as well as our related
[Galaxy Series.](http://www.gigasciencejournal.com/series/Galaxy) Please
contact us if you are interested in submitting your Galaxy related work
to us.***

*<http://www.gigasciencejournal.com/series/Galaxy>*

The post [Guest posting: Conda as a new standard for Galaxy tool
dependencies](http://gigasciencejournal.com/blog/guest-posting-introducing-conda-for-galaxy/){rel="nofollow"}
appeared first on
[GigaBlog](http://gigasciencejournal.com/blog){rel="nofollow"}.


Björn Grüning modelling one of our t-shirts. Nowadays, massive amounts of diverse data are generated in biomedical research. To manage it and extract useful information, bioinformatic solutions are needed and software must be developed. The development of a tool should always follow a similar process.

Guest posting: Conda as a new standard for Galaxy tool dependencies

University of Glasgow

Roderic Page

![Docker](https://lh3.googleusercontent.com/-1XZ61dPP9RU/V7SXvuFJO5I/AAAAAAAAEP8/FDrRi3cmHDs/docker.png?imgmax=1600 "docker.png"){border="0"
width="128" height="128" style="float:right;"} Some notes on containers,
microservices, and data. The idea of packaging software into portable
containers and running them either locally or in the cloud is very
attractive (see [Docker](https://www.docker.com)). Some use cases I\'m
interested in exploring.

#### Microservices

In Towards a biodiversity knowledge graph
([doi:10.3897/rio.2.e8767](http://dx.doi.org/10.3897/rio.2.e8767)) I
listed a number of services that are essentially self contained, such as
name parsers, reconciliation tools, resolvers, etc. Each of these could
be packaged up and made into containers.

#### Databases

We can use containers to package database servers, such as CouchDB,
ElasticSearch, and triple stores. Using containers means we don\'t need
to go through the hassle of installing the software locally. Interested
in RDF? Spin up a triple store, play with it, then switch it off if you
decide it\'s not for you. If it proves useful, you can move it to the
cloud and scale up (e.g., [sloppy.io](https://sloppy.io)).

#### Data

A final use case is to put individual datasets in a container. For
exmaple, imagine that we have a large Darwin Core Archive. We can
distribute this as a simple zip file, but you can\'t do much with this
unless you have code to parse Darwin Core. But imagine we combine that
dataset with a simpel visualisation tool, such as
[VESpeR](http://www.vesper.org.uk) (see
[doi:10.1016/j.ecoinf.2014.08.004](http://dx.doi.org/10.1016/j.ecoinf.2014.08.004)).
Users interested in the data could then play with the data without the
overhead of installing specialist software. In a sense, the data becomes
an app.


Some notes on containers, microservices, and data. The idea of packaging software into portable containers and running them either locally or in the cloud is very attractive (see Docker). Some use cases I'm interested in exploring. Microservices   In Towards a biodiversity knowledge graph (doi:10.3897/rio.2.e8767) I listed a number of services that are essentially self contained, such as name parsers, reconciliation tools, resolvers, etc.

Containers, microservices, and data

::: {#attachment_1566 .wp-caption .alignleft style="width: 310px"}
[![biogasdigester](http://gigasciencejournal.com/blog/wp-content/uploads/2015/07/biogasdigester-300x217.jpg){.wp-image-1566
.size-medium loading="lazy" decoding="async"
aria-describedby="caption-attachment-1566" width="300" height="217"
srcset="http://gigasciencejournal.com/blog/wp-content/uploads/2015/07/biogasdigester-300x217.jpg 300w, http://gigasciencejournal.com/blog/wp-content/uploads/2015/07/biogasdigester-768x555.jpg 768w, http://gigasciencejournal.com/blog/wp-content/uploads/2015/07/biogasdigester-1024x741.jpg 1024w"
sizes="(max-width: 300px) 100vw, 300px"}](http://gigasciencejournal.com/blog/wp-content/uploads/2015/07/biogasdigester.jpg)

An anaerobic digester at BGI.
:::

**Biofuels Research Shows the Utility of Container Publishing**  
One of the most promising areas in biofuel development is
[biogas](https://en.wikipedia.org/wiki/Biogas){target="_blank"
rel="noopener"}, which has huge potential as a renewable and clean
source of energy. Biogas is the production of methane gas through the
anaerobic digestion (fermentation) of organic matter such as
agricultural or food waste (see the picture of a typical digester used
to collect methane from our colleagues at BGI's experimental farm).
Detailed knowledge on the functioning of the fermentation process is key
for optimizing this process; however, the vast majority of the microbes
involved remain unknown and cannot be cultivated in laboratories.

In a Data Note [out
today](http://dx.doi.org/10.1186/s13742-015-0073-6){target="_blank"
rel="noopener"} researchers from Bielefeld University in Germany have
now characterized the complex communities of micro-organisms in a biogas
plant that generates heat and power from maize silage and pig manure.
Furthermore, the authors demonstrated the state-of-art in making their
research more reproducible by disseminating everything in a [virtual
"Dockerised" container of their data and
tools](https://registry.hub.docker.com/u/metagenomics/2015-biogas-cebitec/){target="_blank"
rel="noopener"}.

For their study, the researchers carried out metagenomic and
meta-transcriptomic analyses, which resulted in the generation of DNA
and RNA sequences from the thousands of microbial species present. From
this they were able to create a catalogue of 250,000 genes that enabled
them to begin defining the underlying biology of methane production.
While this data production only scratches the surface of the vast amount
of information gathered, the authors furthered the usefulness of this
resource by releasing all of the data and computational methods as a
shareable docker container to enable others to execute the same analyses
in the cloud. This not only makes the research reproducible, but also
allows researchers around the world to build on these resources to more
rapidly delineate the important processes involved in biogas generation
and to better explore its use for biofuel.

::: {#attachment_1568 .wp-caption .alignright style="width: 310px"}
[![Elucidating the pathways involved in methane
production](http://gigasciencejournal.com/blog/wp-content/uploads/2015/07/methfig11-300x224.png){.size-medium
.wp-image-1568 loading="lazy" decoding="async"
aria-describedby="caption-attachment-1568" width="300" height="224"
srcset="http://gigasciencejournal.com/blog/wp-content/uploads/2015/07/methfig11-300x224.png 300w, http://gigasciencejournal.com/blog/wp-content/uploads/2015/07/methfig11-768x574.png 768w, http://gigasciencejournal.com/blog/wp-content/uploads/2015/07/methfig11-1024x766.png 1024w, http://gigasciencejournal.com/blog/wp-content/uploads/2015/07/methfig11.png 1270w"
sizes="(max-width: 300px) 100vw, 300px"}](http://gigasciencejournal.com/blog/wp-content/uploads/2015/07/methfig11.png)

Elucidating the pathways involved in methane production.
:::

Andreas Schlüter, microbiologist at the [Center for Biotechnology of
Bielefeld
University](http://www.cebitec.uni-bielefeld.de/){target="_blank"
rel="noopener"} highlights the utility of this data, saying:
"Metagenomics in connection with advanced bioinformatics approaches
greatly promoted our understanding of complex microbial communities
involved in biofuel production." Microbial conversion of biomass and
organic wastes under anaerobic conditions is of importance for the
generation of valuable products and biofuels. Detailed knowledge on the
functioning of fermentation community members is considered to be the
key for process shaping and optimization strategies. Hence, metagenome
and metatranscriptome sequence data obtained from biomass degrading
communities is a valuable resource regarding elucidation of their
structural composition and functional potential. Moreover,
identification of dominant key microorganisms and functions will help to
improve and advance production of valuable intermediate metabolites and
biofuels such as biogas from renewable resources.

As experiments become more data-intensive, reviewing and publishing the
methods and results of scientific studies become increasingly
challenging. To get around this the authors used the [Docker
platform](https://www.docker.com/){target="_blank" rel="noopener"},
which effectively wraps software in a system that includes everything
needed to rerun it. This removes the need for other researchers to
install and maintain the many complex bioinformatics tools and software
libraries: something that can be very technically challenging for
researchers without the computational resources and skills.

**Bioboxes for Biogas  
**Reviewing and publishing the methods and results of scientific studies
become increasingly challenging, especially as experiments become more
data-intensive. To ensure reproducibility scientific journals are
increasingly asking authors to make their code and data publicly
available. Nevertheless, complex analysis workflows with their
dependency on certain versions of bioinformatics tools and software
libraries are not trivial to install and maintain. "We decided to use
virtualisation techniques to encapsulate our analysis workflow and make
it basically independent from the host it is executed on" says Andreas
Bremges, first author of the study. "We containerized our analysis
workflow [in
Docker](https://registry.hub.docker.com/u/metagenomics/2015-biogas-cebitec/){target="_blank"
rel="noopener"} which can be executed virtually anywhere".

The reproducibility of published research is an important aspect of
science, and one that *GigaScience* is trying hard to tackle highlights
Peter Li, our Lead Data Manager, who undertook the step of trying to
exactly recreate the results in the paper. "Andreas and his colleagues
provided a Docker container that encapsulated the method used to process
the data from their biogas study. This made my job of checking the
reproducibility of their results much easier as their Docker container
took care of installing the bioinformatics tools and their dependencies
on my cloud server". Being an [open review embracing
journal](https://doi.org/10.1186/2047-217X-2-1){target="_blank"
rel="noopener"} you can see his and the other reviewers reports in
publons [here,](https://publons.com/publon/120708/){target="_blank"
rel="noopener"} as well as a [blog post by reviewer Titus
Brown](http://ivory.idyll.org/blog/2015-docker-and-replicating-papers.html){target="_blank"
rel="noopener"} that conveniently crowdsourced advice while he was
reviewing the paper. You can even try to recreate the results yourself
with the [Docker accessible version of the
study](https://registry.hub.docker.com/u/metagenomics/2015-biogas-cebitec/){target="_blank"
rel="noopener"}, and snapshots of the container and supporting data
[hosted in our GigaDB
database](http://dx.doi.org/10.5524/100151){target="_blank"
rel="noopener"}.

[Docker](https://www.docker.com/){target="_blank" rel="noopener"} is a
rapidly emerging framework to keep the virtualization environments small
using the Linux OS container concept. "We like the idea of Docker to
ensure reproducibility of analysis workflows so much that we adopted the
approach in our CAMI challenge" says Alexander Sczyrba, senior author of
the study and one of the organisers of [CAMI, the Critical Assessment of
Metagenome
Interpretation](http://www.cami-challenge.org){target="_blank"
rel="noopener"}. In collaboration with
[nucleotid.es](http://nucleotid.es){target="_blank" rel="noopener"} we
started the [bioboxes project](http://bioboxes.org) to standardize
interchangable bioinformatics software containers. Peter Belmann, core
team member of bioboxes, helped in building the Docker container for the
biogas study. "The container for this study is not yet
bioboxes-conforming, but the next step will be to define a bioboxes
standard for this kind of workflow". The bioboxes community is currently
gathering feedback on the standards they are developing, and
contributions are welcomed via their [GitHub RFC
page](https://github.com/bioboxes/rfc). For more on container publishing
you can see [Mike Barton's talk on
nucleotide.es](https://youtu.be/Au_8wWA0ZQI){target="_blank"
rel="noopener"} at this years Dockercon (much of this also presented at
the [Balti & Bioinformatics
--](https://youtu.be/ZACVcJt0oJA){target="_blank" rel="noopener"} [[Open
data and reproducible
bioinformatics](https://youtu.be/ZACVcJt0oJA){target="_blank"
rel="noopener"} google hangout we also presented and participated
in).]{#eow-title .watch-title dir="ltr"
title="Balti and Bioinformatics - 21st January - Open data and reproducible bioinformatics"}

The post [Fermenting a Reproducible Research
Revolution](http://gigasciencejournal.com/blog/fermenting-reproducible-research-revolution/){rel="nofollow"}
appeared first on
[GigaBlog](http://gigasciencejournal.com/blog){rel="nofollow"}.


An anaerobic digester at BGI.
<strong>
 Biofuels Research Shows the Utility of Container Publishing
</strong>
One of the most promising areas in biofuel development is biogas, which has huge potential as a renewable and clean source of energy.

Messaggi di Rogue Scholar

Reproducible Classification. Q&A on ShinyLearner & the CODECHECK certificate, pt. 2

Guest posting: Conda as a new standard for Galaxy tool dependencies

Containers, microservices, and data

Fermenting a Reproducible Research Revolution