So, now for something somewhat completely different, but to completely familiar things, put
together in a new way, I think.
Thank you very much.
Just for a show of hands for Michael Rostick, who here has any experience of interest in
cloning or theorem editing, like making new constructs and organisms?
Oh, the question was, who here has any experience with cloning plasmids or genome editing
or engineering organisms, spans?
Okay, perfect.
Then a lot of you are going to learn some new stuff as well, so that's great.
What I'm here to present is, get for genomes, it's about a tool we made, specifically for
doing version control on sequences, DNA sequences, protein sequences, and engineering context.
And where this comes from, is actually the reason I go into Sintai Biology, is this notion
that DNA is like code for computers, means like we can read it, we can also create it and
design new genetic scripts to allow cells to execute, like what we want to do.
But the thing is, it does not feel at all like software engineering.
So it's once you add for a while, like you'll notice it's much harder and it's actually
much more tricky than you would think coming into it.
And to illustrate it with an example, let's say at the project where we are tasked with
making beer yeast that produces the hop flavor compounds, so that we can just make beer
with yeast alone and then not have to worry about hops, like if you're on Mars or something
or Space Station, you don't have access to hops.
We are going to explain that in the context of like the design build test cycle, the Sintai
Biology people like to use, and starting with a design part, here I would start with
sourcing genetic parts to express these genes, so parts that you have put in front of your
genes or the genes itself, to help the cell express them.
I jam, an amazing resource, it's an open source collection of the unique parts.
They do this massive competition every year for high schoolers to undergrad, to
overgrads, where people come together to make genetic engineering machines.
It says a lot of fun, I recommend checking them out.
Then we would create combinations of all these variable parts, because I think we're not
that good at it yet.
So we always test a bunch in parallel, because it's a slow test process, so we might
as well test quite a few at once.
Then second point is that we go with our built, so this is where it takes our digital
sequences.
We're going to make them real, so that means like ordering synthetic sequences, putting
them together, putting them into your host, and creating these organisms that have been
engineered to execute these genetic programs.
That part tends to be a little bit expensive, so you oftentimes, especially academia, try
to build the strategy as you can reuse as many parts as possible.
So it's like you're using a little Lego bricks, and you're trying to use your synthetic
DNA multiple times, so you get some more mileage out of that.
That's where I could first issue comes in.
If you're trying to do this design build test on a large scale, is that when you want
to build an efficient build strategy, you kind of need to know what's going to enter the
design.
You need some context.
You can just give these build people a synthesis company, a list of sequences, and
then go like have added, and that's going to cost you a lot of money.
So there's this loss of context sometimes you see in an industry between a design and
a built stage.
Then the third stage, then is that where we would like read back our genome, especially
for everyone like possibly somebody or if you're doing an insertion into a genome, the
genome editing process is not perfect, so oftentimes it doesn't work.
So you end up with these assays where you say, like, our genes got into our bug, our genes
is not getting into our bug, but more often than not, you end up in a third category where
your genes got into your genome, but there's some limitations.
You're in the stuff you put in there, or somewhere completely else.
And that's a point where you really end up in a lot of trouble in the sense that we don't
yet know well how to deal with that.
So a lot of our software is based on these are genes that get into the host, or they
do not get into host.
And on the other side, like the variant colors, they're great, they tell you the variants,
but you lose the engineering context.
So then you don't know exactly what is that variant, and it's important to me, or what
should I expect.
So that in total basically leads to this issue, where closing this design, built test
group is, yeah, then remaining, or then fast, that's, gets really tricky, and the whole
engineering process becomes a lot harder than it should be.
So like, like, synthetic biology hasn't really taken off that much yet, and that's important
because we're missing some gaps that's, we can be inspired by software engineering to
solve.
So that's where our project comes in.
So David is like my co-workers sitting right there, and he's another fellow contributor,
and we built a client called Gen, that is heavily inspired by get, and it is good to
design specifically for sequences.
It's a risk rate, we have command line interface, we have Python bindings, we have a nice
tool as well, and what it is, is it's a way to organize your sequences in repositories,
there are SQLite databases, where we track every change you make here in the design stage,
or in the observation stage, when you use sequence your samples, and we track those as operations
basically commits, and then we supply the familiar get commands to initialize your repository,
synchronize your remote repository, make branches, basically like the workflow of software
engineers are used to, but on top of that, we add a whole bunch of sequence specific commands
and operations.
So when you look back at our design bill test, for example, here are some of the functions
like I would use to reflect what I did in the lab, and what I saw in my, in my data,
and load them onto my repository, so I was like building the story of what happens to
this train, what went into the design, why did it do it, and sort of end up with a more
reviewable PR for your collaborators, for governments, agencies, for any one really.
So here, for instance, when we're planning this planning strategy, we can chunk out
the sequences, we can stitch them back together and keep track of all that.
Yeah, and then here's some other ones as well, where we have ways of interacting with
these variant call files and loading up in a way that we can view and study like that.
Now why don't we just use get, like why can't we, why do we need this whole new system,
if we are just working with sequences, why can't we use our existing tools?
And the reason for that is that coordinate frames on genomes are really, really fragile.
So what you end up with is I can be talking about age genome, and I say like base 1,255,
and then you can think we're talking about the same thing, but if you have a different reference
in mind, then we're screwed.
Now the references also have an issue, like there's no one here who is like the reference
human, right?
So but we're still working with these reference genes, and part of that is because that
was just the best we had at the time, but it's also slow down, like the engineering side,
because we don't also get to do these issues of these intended and observed variants,
where if you are thinking that you're working with a certain sequence, you're reference
sequence, and then in the lab, you soon see your real data that tells you, there's actually
a thousand differences compared to your reference, like how do you find like the relevant ones
from that and how do you find your own engineering context there?
So how do you solve that?
We solved it a little earlier, so actually I'm going to ask again, how many people here
are familiar with like pan genomes and graph genome representations?
Okay, okay, so as a very brief introduction to that, it's a way of representing genome
sequences with DNA sequences in a nonlinear fashion, so what you do is every linear sequence
is a walk and a graph from like a start to an end, and when you have a variant, you add
an edge, so it's an edge in a node, and a node carries sub sequences.
So in this case, what I'm showing here is when you have an AT that muted to a TG, instead
of this following your initial reference, you then hop on to another node and then hop back,
and that allows you to very efficiently store a ton of variants in one object, let's see,
and then what's also interesting there, when I spend a lot of effort for the engineering
sites, more than the pan genomes site, is that these points where you're forks, that can
actually represent many things that are very useful for us.
On the one site, it can represent mixed populations and polyploidy as in like these are real
things that happen that you don't see in any of your sequences. On the other hand, it can
give you historical variants, so our software, every variant that sees it adds, I just do this
additive data model so that we keep a change log like that, and then you can also use that to
represent all of the variants you're screening. So let's see, I'm testing 10 sequences, that
can be 10, like, like, legs of that fork, and then we can, we can work with this entire screening
library at once, and that becomes really interesting once you start combining many metvenny
parts because that quickly blooms, so oftentimes we find people restricting their experiments
based on what they think they can cover, but then this allows them to go much, much higher
without having these huge data sets. And I like to call shooting a smaller kill, because these
are smaller kills, they can be anything, and tell you sequence, and then like this proposition
collapses, and it becomes this useful metaphor of working with the sequences where you think
you know what it is, but you don't know yet. So what we're offering here is then, not just
then a version control client, but also tools for working with these graphs, to make it easier to
to visualize and conceptualize and do some printing and pasting, and hoping to get more people
on the graph geomes space, especially on the engineering side. We also have done a web interface at
general bio, that is also being worked on so that we have as many ways as possible to get people
on this, and to get people familiar with this and working with this. And then the whole idea is that
we want to promote collaborative engineering. So we support common bio from many file formats,
and anyone, if you want to get your format on here, let us know, and then we'll work on that.
We have ways of doing this decentralized distribution via patch files, so you can just email patches
to each other and keep your repositories in sync. We have remote repositories, like you're
used to with Gets, that we host ourselves at general.io, or that you can host yourself yourself,
and our Gets repo is there, we're a patchy to licensed, and we're accepting PRs.
So the basically our entire goal is going from a world where we're sharing sequences in
word files, or horrible patterns that you're eligible, and we're getting to a world where it
looks more like a Gets repo, and we can get as fast as software engineering with Android biology.
Thank you.
So it's time for questions. Do we have any questions? Yes, I get friends. How can you
store your data? So the question was, how do you store your data? It's SQLite. We have per repository,
we can make one or more SQLite databases as files. So it's a graph model on SQLite.
So we import center files, so one of the things that we did, that wasn't there in the
Pan Genomex space, is when you have your GFA file from that space, and you add more variants with
your changes, everything changes. It's a very fragile model in the sense that if you break up and
notice, then all edges are connected, there's no need to be changed. So the way we do it is we
work a slightly different model of graphs, that's additive. So we set it up in a way that is
completely additive, and then we put it in SQLite, so it's a good scale. But the import
export center files.
Yeah, so could you use this for genome alignments? We don't include an aligner, but we do interface with
those aligners. So you can have your aligner like cactus is like a common one, and then pipe it into
into a gen, and have then the results and the pinnure repo.
Yeah, so this is, as I said, the question was, you have these files where you have
instead of ACTG of ACTN, or K, or whatever, like ambiguous basis. It's not in our main
branch yet, but we have some scripts where we convert those on the fly into a graph. So you
underpate these barcode, that can be like millions of possible sequences, and you have like 20 nodes.
And that sort of what makes that exponential problem like all these years.
Yeah, one more final. We share a plan also to have like the human, you know, one a repo
where we can put all our stuff. Yeah, so one of our developers, he stressed us, everything was like
100,000 human genomes at once, so it's built to handle that scale, and it does, but it does as well.
Yeah. Okay, so everybody, please, thank you, Bob.