2014 10-15-Nextbug edinburgh

@yannick__ http://yannick.poulet.org
Social insect evolution:
genomics opportunities
& approaches
2014-10-15-NextBUG

© National Geographic
Atta leaf-cutter ants

Oecophylla Weaver ants
© ameisenforum.de

© ameisenforum.de
Fourmis tisserandes

© ameisenforum.de
Oecophylla Weaver ants

Tofilski et al 2008
Forelius pusillus

Tofilski et al 2008
Forelius pusillus hides the nest entrance at night

Avant
Workers staying outside die
« preventive self-sacriﬁce »
Tofilski et al 2008
Forelius pusillus hides the nest entrance at night

Dorylus driver ants: ants with no home
© BBC

© Dirk Mezger
Ritualized ﬁghting
© Carsten Brühl
Camponotus gigas Pfeiffer & Linsenmair 2001

Army ant milling - “spiral of death”

Animal biomass (Brazilian rainforest)
from Fittkau & Klinge 1973
Other insects
49.6
Amphibians
2.8
Reptiles
3.7
Birds
5.3
Mammals
14.5
!
Earthworms
17.3
!
!
Spiders
4.7
Soil fauna excluding
earthworms,
ants & termites
148
Ants & termites
114

Well-studied:
• behavior

• morphology

• evolutionary context

• ecology

This changes
everything.454

Illumina

Solid...
Any lab can
sequence
anything!

Major research areas
Genes/mechanisms for evolution of
social behavior?

REPORTS
onMarch12,2013www.sciencemag.orgDownloadedfrom
Solenopsis invicta ﬁre ants are
a big problem!
verywellstudied!
Ascunceetal2011

Solenopsis invicta ﬁre ant:
two social forms
!
•1 large queen

•Independent founding

•Highly territorial

•Many sizes of workers
!
•2-100 smaller queens

•Dependent founding

•No inter-colony aggression

•All workers similar size
Single-queen form: Multiple-queen form:

Fire ants
+
Population genetics:Allozyme screen
Ken Ross L. Keller
“starch gel”+
1 2 3=> “Gp-9” locus associated to social form

Single queen form Multiple queen form
Ken Ross and colleagues

Laurent Keller and colleagues
Social form completely associated to Gp-9 locus

bbbbBB BB Bb bb

(>15% )(< 5% )

bbBB BB Bb
x
Gp-9 bb females rare

(>15% )(< 5% )

BB BB Bb

(>15% )(< 5% )

BB BB Bb
x

(>15% )(< 5% )

BB BB Bb
x x

(>15% )(< 5% )

BB BB Bb
x x x

(>15% )(< 5% )

Sex chromosomes
X Y
Gp-9 B
Gp-9 b
SB Sb
“Social chromosomes”
?
Wang et al Nature 2013

Major research areas
Genes/mechanisms for differences (e.g., lifespan?)?
Genes/mechanisms for evolution of
social behavior?
genome evolution social evolution

• Biology/life is complex

• Field is young.

• Biologists lack computational training.

• Generally, analysis tools suck.

• badly written

• badly tested

• hard to install

• output quality… often questionable.

• Understanding/visualizing/massaging data is hard.

• Datasets continue to grow!
Genomics is hard.

Best Practices for Scientific Computing
Greg Wilson ∗
, D.A. Aruliah †
, C. Titus Brown ‡
, Neil P. Chue Hong §
, Matt Davis ¶
, Richard T. Guy ∥
,
Steven H.D. Haddock ∗∗
, Katy Huff ††
, Ian M. Mitchell ‡‡
, Mark D. Plumbley §§
, Ben Waugh ¶¶
,
Ethan P. White ∗∗∗
, Paul Wilson †††
∗
Software Carpentry (gvwilson@software-carpentry.org),†University of Ontario Institute of Technology (Dhavide.Aru
State University (ctb@msu.edu),§Software Sustainability Institute (N.ChueHong@epcc.ed.ac.uk),¶ Space Telescope
(mrdavis@stsci.edu),∥University of Toronto (guy@cs.utoronto.ca),∗∗Monterey Bay Aquarium Research Institute
(steve@practicalcomputing.org),††University of Wisconsin (khuff@cae.wisc.edu),‡‡University of British Columbia (mi
Mary University of London (mark.plumbley@eecs.qmul.ac.uk),¶¶University College London (b.waugh@ucl.ac.uk),∗
University (ethan@weecology.org), and †††University of Wisconsin (wilsonp@engr.wisc.edu)
Scientists spend an increasing amount of time building and using
software. However, most scientists are never taught how to do this
efficiently. As a result, many are unaware of tools and practices that
would allow them to write more reliable and maintainable code with
less effort. We describe a set of best practices for scientific software
development that have solid foundations in research and experience,
and that improve scientists’ productivity and the reliability of their
software.
Software is as important to modern scientific research as
telescopes and test tubes. From groups that work exclusively
on computational problems, to traditional laboratory and field
scientists, more and more of the daily operation of science re-
volves around computers. This includes the development of
new algorithms, managing and analyzing the large amounts
of data that are generated in single research projects, and
combining disparate datasets to assess synthetic problems.
Scientists typically develop their own software for these
purposes because doing so requires substantial domain-specific
and open source software development [6
ical studies of scientific computing [4, 31,
development in general (summarized in
practices will guarantee efficient, error-fr
ment, but used in concert they will re
errors in scientific software, make it easie
the authors of the software time and effo
focusing on the underlying scientific ques
1. Write programs for people, not c
Scientists writing software need to write
cutes correctly and can be easily read and
programmers (especially the author’s fut
cannot be easily read and understood it is
to know that it is actually doing what it i
be productive, software developers must t
aspects of human cognition into account
(steve@practicalcomputing.org), University of Wisconsin (khuff@cae.w
Mary University of London (mark.plumbley@eecs.qmul.ac.uk),¶¶Unive
University (ethan@weecology.org), and †††University of Wisconsin (wil
Scientists spend an increasing amount of time building and using
software. However, most scientists are never taught how to do this
efficiently. As a result, many are unaware of tools and practices that
would allow them to write more reliable and maintainable code with
less effort. We describe a set of best practices for scientific software
development that have solid foundations in research and experience,
and that improve scientists’ productivity and the reliability of their
software.
Software is as important to modern scientific research as
telescopes and test tubes. From groups that work exclusively
on computational problems, to traditional laboratory and field
scientists, more and more of the daily operation of science re-
volves around computers. This includes the development of
new algorithms, managing and analyzing the large amounts
of data that are generated in single research projects, and
arXiv:1210.0530v3[cs.MS]29Nov2012
1. Write programs for people, not computers.
2. Automate repetitive tasks.
3. Use the computer to record history.
4. Make incremental changes.
5. Use version control.
6. Don’t repeat yourself (or others).
7. Plan for mistakes.
8. Optimize software only after it works correctly.
9. Document the design and purpose of code rather than its mechanics.!
10. Conduct code reviews.

Inspiration?
• Technologies

• Planning for mistakes

• Automated testing

• Continuous

• Writing for people: use style guide

Code for people: Use a style guide
• For R: http://r-pkgs.had.co.nz/style.html

Coding for people: Indent your code!
ers
and and improve your code in 6
pproximate Damian Conway

Line length
Strive to limit your code to 80 characters per line. This ﬁts comfortably on a printed page with a
reasonably sized font. If you ﬁnd yourself running out of room, this is a good indication that you
should encapsulate some of the work in a separate function.

R style guide extract
!
ant_measurements <- read.table(file = '~/Downloads/Web/ant_measurements.txt', header=TRUE, se
!
ant_measurements <- read.table(file = '~/Downloads/Web/ant_measurements.txt',
header = TRUE,
sep = 't',
col.names = c('colony', 'individual', 'headwidth', 'mass')
)
!
ant_measurements <- read.table(file = '~/Downloads/Web/ant_measurements.txt', header=TRUE,  
sep='t', col.names = c('colony', 'individual', 'headwidth', ‘mass'))

Code for people: Use a style guide
• For R: http://r-pkgs.had.co.nz/style.html

• For Ruby: https://github.com/bbatsov/ruby-style-guide

Automatically check your code:
install.packages(“lint”) # once
library(lint) # everytime
lint(“file_to_check.R”)

Four tools
suck less.
(hopefully)
Four tools that

“Can you BLAST this for me?”

Anurag Priyam,  
Mechanical engineering student, IIT Kharagpur
Sure, I can
help you…

Antgenomes.org SequenceServer

BLAST made easy
(well, we’re trying...)

http://www.sequenceserver.com/
(requires a BLAST+ install)
Do you have BLAST-formatted databases? If not:
sequenceserver format-databases /path/to/fastas
1. Installing
gem install sequenceserver
# ~/.sequenceserver.conf
bin: ~/ncbi-blast-2.2.25+/bin/
database: /Users/me/blast_databases/
2. Conﬁgure.
sequenceserver
### Launched SequenceServer at: http://0.0.0.0:4567
3. Launch.

Antgenomes.org SequenceServer

BLAST made easy
(well, we’re trying...)
Web server:
Anurag Priyam & Git community - http://sequenceserver.com
blast on 48-core
512gig fat machine
via ssh

Module counts
Node = “NPM”

Reusable, small and tested
modules

Examples
BASH
JavaScript
bionode.io (online shell)
bionode-ncbi urls assembly Solenopsis invicta | grep genomic.fna
http://ftp.ncbi.nlm.nih.gov/genomes/all/GCA_000188075.1_Si_gnG/
GCA_000188075.1_Si_gnG_genomic.fna.gz
bionode-ncbi download sra arthropoda | bionode-sra
bionode-ncbi download gff bacteria
var ncbi = require('bionode-ncbi')
ncbi.urls('assembly', 'Solenopsis invicta'), gotData)
function gotData(urls) {
var genome = urls[0].genomic.fna
download(genome)
})
#
Get
descriptions
for
papers
related
to
SRA
search

!
bionode
ncbi
search
sra
Solenopsis
invicta
|

tool-‐stream
extractProperty
uid
|

bionode
ncbi
link
sra
pubmed
|

tool-‐stream
extractProperty
destUID
|
 

bionode
ncbi
search
pubmed

!

Difficulty writing scalable, reproducible and
complex bioinformatic pipelines.
Solution: Node.js everywhereStreams
var ncbi = require('bionode-ncbi')
var tool = require('tool-stream')
var through = require('through2')
var fork1 = through.obj()
var fork2 = through.obj()
ncbi
.search('sra', 'Solenopsis invicta')
.pipe(fork1)
.pipe(dat.reads)
fork1
.pipe(tool.extractProperty('expxml.Biosample.id'))
.pipe(ncbi.search('biosample'))
.pipe(dat.samples)
fork1
.pipe(tool.extractProperty('uid'))
.pipe(ncbi.link('sra', 'pubmed'))

Gene prediction
Dozens of software algorithms: dozens of predictions
20% failure rate:

•missing pieces

•extra pieces

•incorrect merging

•incorrect splitting
Visual inspection... and
manual ﬁxing required.
1 gene = 5 minutes to 3 days

Yandell&Ence2013NRG
GTTTTtACCTGTTTTtGAAAAGGTAATTTTCTTTAGATATATTATGTTGAATaTTAGGGTTTTTATAAAGAATGTGTATATTGUTTACAATATAAAAGACACAATTGCAAACTAGCATGATTGTAAACAATTGCTAAACGGATCAATATAAATTAAAATTGTAATATTAAGTATCAAACCGATAATTTTTA
Evidence
Consensus:

Monica Dragan
Ismail Moghul
https://github.com/monicadragan/GeneValidator
https://github.com/IsmailM/GeneValidatorApp

Monica Dragan
https://github.com/monicadragan/GeneValidator
https://github.com/IsmailM/GeneValidatorApp
Ismail Moghul

GeneValidator
Run on:

★whole geneset: identify most problematic predictions

★alternative models for a gene (choose best)

★individual genes (while manually curating)

Warning:Work in Progress
gem install GeneValidator
gem install GeneValidatorApp
http://afra.sbcs.qmul.ac.uk/genevalidator

3.Afra: Crowdsourcing
gene model curation

Gene prediction
Dozens of software algorithms: dozens of predictions
20% failure rate:

•missing pieces

•extra pieces

•incorrect merging

•incorrect splitting
Visual inspection... and
manual ﬁxing required.
1 gene = 20 minutes to 3 days

15,000 genes * 20 species =
impossible.
Yandell&Ence2013NRG
TTTTtACCTGTTTTtGAAAAGGTAATTTTCTTTAGATATATACAGTTTGTAATaTTAGGTATTTTATAAACAGTGTGTATATTTCTTACAATATAAAAGACACAATTGCAAACTAGCATGATTGTAAACAATTGCTAAACGGATCAATATAAATTAAAATTGTAATATTAAGTATCAAACCGATAATTTTT
Evidence
Consensus:

Algorithm discovery by protein folding game players
Firas Khatiba
, Seth Cooperb
, Michael D. Tykaa
, Kefan Xub
, Ilya Makedonb
, Zoran Popovićb
,
David Bakera,c,1
, and Foldit Players
a
Department of Biochemistry; b
Department of Computer Science and Engineering; and c
Howard Hughes Medical Institute, University of Washington,
Box 357370, Seattle, WA 98195
Contributed by David Baker, October 5, 2011 (sent for review June 29, 2011)
Foldit is a multiplayer online game in which players collaborate
and compete to create accurate protein structure models. For spe-
cific hard problems, Foldit player solutions can in some cases out-
perform state-of-the-art computational methods. However, very
little is known about how collaborative gameplay produces these
results and whether Foldit player strategies can be formalized and
structured so that they can be used by computers. To determine
whether high performing player strategies could be collectively
codified, we augmented the Foldit gameplay mechanics with tools
for players to encode their folding strategies as “recipes” and to
share their recipes with other players, who are able to further mod-
ify and redistribute them. Here we describe the rapid social evolu-
tion of player-developed folding algorithms that took place in the
year following the introduction of these tools. Players developed
over 5,400 different recipes, both by creating new algorithms and
by modifying and recombining successful recipes developed by
other players. The most successful recipes rapidly spread through
the Foldit player population, and two of the recipes became parti-
cularly dominant. Examination of the algorithms encoded in these
two recipes revealed a striking similarity to an unpublished algo-
rithm developed by scientists over the same period. Benchmark
calculations show that the new algorithm independently discov-
ered by scientists and by Foldit players outperforms previously
published methods. Thus, online scientific game frameworks have
the potential not only to solve hard scientific problems, but also to
discover and formalize effective new strategies and algorithms.
citizen science ∣ crowd-sourcing ∣ optimization ∣ structure prediction ∣
strategy
Citizen science is an approach to leveraging natural human
abilities for scientific purposes. Most such efforts involve
visual tasks such as tagging images or locating image features
(1–3). In contrast, Foldit is a multiplayer online scientific discovery
game, in which players become highly skilled at creating accurate
protein structure models through extended game play (4, 5). Foldit
recruits online gamers to optimize the computed Rosetta energy
using human spatial problem-solving skills. Players manipulate
protein structures with a palette of interactive tools and manipula-
tions. Through their interactive exploration Foldit players also uti-
lize user-friendly versions of algorithms from the Rosetta structure
prediction methodology (6) such as wiggle (gradient-based energy
minimization) and shake (combinatorial side chain rotamer pack-
ing). The potential of gamers to solve more complex scientific pro-
blems was recently highlighted by the solution of a long-standing
protein structure determination problem by Foldit players (7).
One of the key strengths of game-based human problem ex-
ploration is the human ability to search over the space of possible
strategies and adapt those strategies to the type of problem and
stage of problem solving (5). The variability of tactics and
strategies stems from the individuality of each player as well as
multiple methods of sharing and evolution within the game
(group play, game chat), and outside of the game [wiki pages (8)].
One way to arrive at algorithmic methods underlying successful
human Foldit play would be to apply machine learning techniques
to the detailed logs of expert Foldit players (9). We chose instead
to rely on a superior learning machine: Foldit players themselves.
As the players themselves understand their strategies better than
anyone, we decided to allow them to codify their algorithms
directly, rather than attempting to automatically learn approxi-
mations. We augmented standard Foldit play with the ability to
create, edit, share, and rate gameplay macros, referred to as
“recipes” within the Foldit game (10). In the game each player
has their own “cookbook” of such recipes, from which they can
invoke a variety of interactive automated strategies. Players can
share recipes they write with the rest of the Foldit community or
they can choose to keep their creations to themselves.
In this paper we describe the quite unexpected evolution of
recipes in the year after they were released, and the striking con-
vergence of this very short evolution on an algorithm very similar
to an unpublished algorithm recently developed independently
by scientific experts that improves over previous methods.
Results
In the social development environment provided by Foldit,
players evolved a wide variety of recipes to codify their diverse
strategies to problem solving. During the three and a half month
study period (see Materials and Methods), 721 Foldit players ran
5,488 unique recipes 158,682 times and 568 players wrote 5,202
recipes. We studied these algorithms and found that they fell
into four main categories: (i) perturb and minimize, (ii) aggressive
rebuilding, (iii) local optimize, and (iv) set constraints. The first
category goes beyond the deterministic minimize function
provided to Foldit players, which has the disadvantage of readily
being trapped in local minima, by adding in perturbations to lead
the minimizer in different directions (11). The second category
uses the rebuild tool, which performs fragment insertion with
loop closure, to search different areas of conformation space;
these recipes are often run for long periods of time as they are
designed to rebuild entire regions of a protein rather than just
refining them (Fig. S1). The third category of recipes performs
local minimizations along the protein backbone in order to im-
prove the Rosetta energy for every segment of a protein. The final
category of recipes assigns constraints between beta strands or
pairs of residues (rubber bands), or changes the secondary struc-
ture assignment to guide subsequent optimization.
Different algorithms were used with very different frequencies
during the experiment. Some are designated by the authors as
public and are available for use by all Foldit players, whereas
others are private and available only to their creator or their
Foldit team. The distribution of recipe usage among different
players is shown in Fig. 1 for the 26 recipes that were run over
1,000 times. Some recipes, such as the one represented by the
leftmost bar, were used many times by many different players,
while others, such as the one represented by the pink bar in the
Author contributions: F.K., S.C., Z.P., and D.B. designed research; F.K., S.C., M.D.T., and
F.P. performed research; F.K., S.C., M.D.T., K.X., and I.M. analyzed data; and F.K., S.C., Z.P.,
and D.B. wrote the paper.
The authors declare no conflict of interest.
Freely available online through the PNAS open access option.
1
To whom correspondence should be addressed. E-mail: dabaker@u.washington.edu.
This article contains supporting information online at www.pnas.org/lookup/suppl/
doi:10.1073/pnas.1115898108/-/DCSupplemental.
BIOPHYSICSAND
COMPUTATIONALBIOLOGY
PSYCHOLOGICALAND
COGNITIVESCIENCES
http://Fold.it

• Recruiting & retaining contributors
Crowd-sourcing the visual inspection + correction
of gene models.
Challenges

Recruiting & retaining contributors
Plan A: get students.

• Increase accessibility:

• Make tasks small & simple

• Need excellent tutorials & training

• Need an intelligent “mothering” user interface.

• Provide rewards:

• Better grades

• Learning experience

• Good karma (helping science)

• Prestige & pride (on facebook; points & badges “leaderboard”, with
certiﬁcates, in publications)

• Opportunities to develop expertise & responsibilities

Crowd-sourcing the visual inspection + correction
of gene models.
Challenges

• Ensuring quality

Ensuring quality
• Excellent tutorials/training

• Make tasks small & simple

• Redundancy

• Review of conﬂicts by senior
users.
Begin
Being curated
Curate
Being curated
Curate
Being curated
Curate
Submit Submit Submit
“
create nex

Crowd-sourcing the visual inspection + correction.
Challenges
http://afra.sbcs.qmul.ac.ukAnurag Priyam http://github.com/yeban/afra

• Ensuring quality

Timelines
• Rolled out to:

• 8 MSc students

• 20 3rd year students

• Need to improve tutorials/guidance/documentation

• Roll out to 200 ﬁrst years (few months)

• Expand

Summary• Ants are cool

• Exciting times & big challenges

• Inspiration from people working with computers more/longer

• SequenceServer - set up custom BLAST servers

• Bionode -modular streams for bioinformatics

• GeneValidator - identifying problems with gene predictions

• Afra - infrastructure to crowdsource gene curation to the
masses

Recruiting Genomehacker/
Bioinformatics support

Thanks!
y.wurm@qmul.ac.uk
@yannick__
http://yannick.poulet.org
Colleagues & Collaborators
@ QMUL & UNIL
Anurag Priyam @yeban
Monica Dragan
Ismail Moghul
Vivek Rai
Bruno Vieira @bmpvieira

genome evolution social evolution
Generally
Single- vs. Multiple queenness
in ﬁre ants
in similar independent species
•one or many loci?

•one or many genes?

•convergence?
Social parasitism
Strengths of selection in
social evolution
concepts & mechanisms
Medically relevant questions
Candidate gene studies
Vitellogenin
Sex determination genes
functional testing....
Tools for genomics work on emerging model organisms
Molecular response to
social upheaval

2014 10-15-Nextbug edinburgh

More Related Content

Viewers also liked (9)

Similar to 2014 10-15-Nextbug edinburgh (20)

More from Yannick Wurm (20)

Recently uploaded (20)

2014 10-15-Nextbug edinburgh