[DAS] 1.6 draft 7
mitch_skinner at berkeley.edu
Wed Sep 29 09:22:07 UTC 2010
On 09/23/2010 07:44 AM, Thomas Down wrote:
> Just getting in touch to let you know that we're very interested in getting
> big piles of sequencing data onto genome browsers, and are certainly
> interested in alternative formats. My current thoughts are that -- at least
> for what we're doing -- a slightly more concise XML schema, plus richer
> control of server-side summarization/binning (think maxbins++) might be the
> sweet spot, but very interested to see other options as well.
I've only just joined the list, so I think I'm entering this
conversation mid-way, and I apologize if I'm speaking out of turn. I do
have a few opinions about putting genomic data into JSON, though, and it
looks like this might be the time to express them, if you're discussing
DAS alternative content formats.
As you may know, JBrowse client-server communication is (currently) not
DAS. And that's on purpose, for multiple reasons that may be relevant
to this discussion. They are:
1. XML verbosity
3. need for server-side code
JBrowse does something different from DAS in each of those areas. In
order of decreasing ease-of-adoption, they are:
1. XML verbosity:
It's true that if you gzip then this doesn't cost you too much in terms
of size-on-the-wire, but you still have to deal with it in memory on the
client and server.
Most of the genomics data formats I've seen have attributes that are
either *named* or *positional*. Positional data formats, like GFF2,
specify in advance the attributes (columns) that each record (line) can
have. This saves space, but makes the format awkward to extend (e.g.,
what happened when different people extended GFF in different ways).
With XML, by contrast, each attribute is named. That makes the tradeoff
the other way around; it takes up more space, but it's easier to extend,
because new attributes get new names and don't step on each other.
And then there are hybrids like GFF3, where some attributes are
specified positionally, and the rest are named.
But there's another middle ground--you can have positional attributes,
but have the *positions* be named. This is what JBrowse does; each
feature is represented in JSON as an array. Each position in the array
is named, in a separate array of strings. In other words, there are a
bunch of genomic features like this:
and a separate array (not sure what to call it, a "schema" array,
maybe?) that names each position, e.g.:
["start", "end", "strand", "name"]
or what have you. And, since it's JSON, attribute values can have their
own nested structure; for example, one of the attributes could be
"subfeatures" which could be an array of subfeatures. In JBrowse, each
track can have its own "schema"; attributes like "phase", "score", and
"subfeatures" can be left out of a track if it doesn't use them.
For genomic applications, where the space used by the schema array can
be amortized over large numbers of features, I think this is a pretty
substantial win. And if you need ad-hoc additional attributes, you can
always pull the GFF3 trick and have a set of named attributes at the end.
JBrowse partitions feature data by refseq, track, and genomic region.
And the boundaries between those chunks of data are defined statically.
That makes those chunks of data more cacheable; if you're viewing a
given region, and you move a little to the left or to the right, you
usually don't need to make a new HTTP request. And if you come back to
the same region the next day, your browser will likely have the same
data in its cache.
You could, potentially, provide useful caching-related HTTP headers from
current DAS servers, but my understanding is that implementations
typically don't. And I think that has something to do with dynamic
queries being harder to usefully cache.
Gregg has been working on proxying DAS sources for JBrowse clients; I
asked him if his proxy would provide useful caching headers, and he
said, "well, I could make them up" :) But it would be nice if we could
get them without having to do that.
3. Server-side code
The fact that the boundaries of the data chunks are statically defined
means that you can just pre-generate them and serve them with a plain
static HTTP server. Sometimes I meet people who disagree with this
choice, but if you have have a workload that's dominated by reads then I
think it's a pretty clear win, especially if you have a lot of users.
Plus, the HTTP server will generate appropriate caching-related headers
for free. And it's easier for less-technical users, or users with
limited rights on a server, to set up a JBrowse instance if they don't
need to set up CGI/servlets/whatever.
BAM and BigBed have made a similar choice to be statically-serveable;
you could view the JBrowse approach as doing something like what they're
doing, in a way that's easier to digest for web browser clients. In the
JBrowse case, range queries are done by the client using a lazily-loaded
nested containment list, described here:
It's possible to store the JSON gzipped on the server and then send it
out as-is; I compress the json files and give them a .jsonz extension,
and then add this to my apache config:
Header set Content-Encoding: gzip
which works in all the web browsers that JBrowse supports, including IE
I hope this contributes to the discussion,
More information about the DAS