The first version required the Camping rubygem, but I have decoupled that dependency, cleaned up the code a bit and added a few tests.

I got it working just fine using the Elastic Load Balancer. I configure exim “dpkg-reconfigure exim4-config” to use my elastic load balancer as it’s Mail Server Name. For example, if I have the website example.com, I make sure the DNS for this site points to my load balancer (and in the load balancer I register the server/s hosting my site). So, when I send mails from somebody@example.com it will reverse DNS correctly.

p.s. you cannot actually point the DNS for example.com to the load balancer since the load balancer is not a IP you have to use CNAME and can only point www.example.com (or any subdomain) to the load balancer. You could point example.com to an elastic IP for one of your servers and have permanently point example.com to www.example.com.

Another great thing about EC2 is that in addition to great GUIs like ElasticFox there are also the EC2 API tools, making it possible to script your server management. For example, you can use these tools to dynamically start/stop servers, for example if your servers are very loaded, you could define some server load thresholds and automatically add/remove servers based on these thresholds. Also, since Amazon charge by the hour, you can set your servers to shutdown after office hours if your employees are the only people using your server. Using Ubuntu, this page is a good place to start using the ec2-api-tools (of course you will first need an EC2 account).

You should be aware that once you shutdown your server, all data will be lost. That’s why Amazon also have Elastic Block Storage (EBS). You can, also scripting it with ec2-api-tools, create an EBS volume, which is is your disk space (which according to Amazon should be as fast or faster than local disks), and have your server mount it automatically when you start your server. So you can have the server write its data to this EBS volume and avoid loosing data when you stop your server.

This is only a fraction of the possibilities that I mention here and I am still fairly new to EC2, but so far I am really impressed with it and hope to use it a lot in the future. Thumbs up to the developer team at Amazon for some well thought out solutions.

Complete Genomics have published its first few genomes, and despite (somewhat) dodgy statistics on the quality of the assembly they are in business. More here.

Nature paper out on the ‘complete’ epigenome hints that embryonic cells may use different mechanisms for gene regulation than more differentiated cells. Abstract here.

Lastly, Microsoft would like to take a step into the world of bioinformatics. What they really want to is to take a strong tradition for open source and wrap it in proprietary frameworks so we can be even more reliant on Microsoft products. Posted here (Gleen Moodys comment) and here (Microsoft statement).

In short, the idea is to assign each letter A, C, G and T to the number 0 to 3. Then generate the number of barcodes as base 10 numbers, for instance 0 to 15 and convert these to base 4 numbers, these are then converted into the barcode sequence. Taking modulo of the sum of the base 4 vector we get a new number between 0 and 3. This number is our checksum and is also converted into the corresponding base. Now any single mutation in the barcode will lead to a sum not generating the right checksum, and a mutation in the checksum base will not give the right checksum if the barcode is not affected. Thus all single mutations in the barcode + checksum position can be detected. For a worked example please refer to the original posting by user wraithnot.

But a good idea is not worth much if you cannot make use of it. Therefore we wrote a small python GUI for generating barcodes using the above strategy. Below is an example of our GUI for generating such barcodes.

Assuming you have python and wxpython installed you can start the GUI by python barcodeGUI.py and you should see this (on os x, will look different dependent on platform):

In number of codes you specify the number of codes you want, leaving it blank will give you all the codes generated. Next you specify the number of positions the code can take, remember you will be using one more to incorporate the checksum base. Next are some options regarding the barcode, avoiding three identical consecutive bases (triplets), avoiding palindromes and must have a specific GC content. Finally you can specify a small string that the code must not match, for instance the primer, linker or overhang caused by a restriction enzyme. Finally pressing OK will let you save the barcodes to a tab delimited file. Obviously, your settings may not allow for generating the desired number of barcodes, in that case increase the number of positions or relax your filters.

Now here is an example where 16 barcodes are generated and a random single mutation is added to any position. The first line shows the numbers generated from decoding the possible ‘mutated’ barcode. Next line is the call whether or not the barcode was mutated. finally the third line shows the possibly mutated barcode, the original barcode and the corresponding checksum and checksum base. Remember that taking modulo of the sum of the barcode should give the checksum number.

[0, 2, 2] ['A', 'G', 'G', 'T']

Mutation

AGGT (’AGC’, 3, ‘T’)

[3, 3, 3] ['T', 'T', 'T', 'G']

Mutation

TTTG (’TTA’, 2, ‘G’)

[3, 0, 3] ['T', 'A', 'T', 'G']

No mutation

TATG (’TAT’, 2, ‘G’)

The above example is shown if you run the python script barcode.py

Currently, this decoding is only included in the script version of the python code, only a neat interface for the barcode generating is provided. Both are offered as open source, currently by contacting troels at bio-geeks dot com, but soon via our open source portal.

I share an interest in microRNAs together with my fellow biogeek, Morten Lindow. Using data from the official miRNA registry, miRBase, we have designed and implemented a data model and software framework for miRNA data. It is built in the Ruby on Rails framework that has a really intuitive object-relational layer (ActiveRecord), which basically means that you can access data in your SQL database as Ruby objects. If for some reason you prefer a different programming language than Ruby, then you can use miRMaid’s general RESTful web-service interface.  but the software is open source (LGPL) and it can be used remotely on the web or as a local installation. I will not go into the gory details here but if you are interested you can read more at www.mirmaid.org. The framework is NOT meant as a competitor to the official miRNA registry, www.miRBase.org, instead it is tightly coupled to miRBase data and aims at providing bioinformaticians (and web-services) with easy and intuitive access to structured miRNA data.

I thought the best way to quickly introduce the framework is with a really short example. So this is what I am going to do in this post. I wanted a quick overview of the evolutionary history of human miRNAs. How many miRNAs are not conserved in other species? How many are conserved in i.e. other mammals? Using the Ruby object-relational models, I can query the inter-linked models for species, miRNA precursors and precursor families (as defined by miRBase). For each human miRNA precursor, p, (line 5) we select the name of the most general clade among the taxonomies of p’s family members (line 6+7). The counts are tallied in a hash and printed on the final line. Perhaps there is too much magic going on in line 7 but I had to keep the number of code lines below 10

conservation = Hash.new(0)
sp = Species.find_by_abbreviation("hsa")
tx = sp.taxonomy.split(";") + [sp.name]
 
sp.precursors.each do |p|
  ps = p.precursor_family ? p.precursor_family.precursors : [p]
  clade = tx[ps.map{|x| (tx & (x.species.taxonomy.split(";")+[x.species.name])).size}.min-1]
  conservation[clade] += 1
end;nil
 
pp conservation
# output
#{"Chordata"=>7,
# "Metazoa"=>3,
# "Homo sapiens"=>66,
# "Hominidae"=>83,
# "Mammalia"=>215,
# "Deuterostoma"=>3,
# "Primates"=>157,
# "Bilateria"=>63,
# "Vertebrata"=>124}

The plot below tells us that of the 721 human miRNA precursors, 66 do not have evidence in other species, and that 215 human precursors have mammalian (non-primate) origin.

There is one project that did many of the things I was interested in, pdfetch, by Edoardo ‘Dado’ Marcora, a nice simple script that allows you to setup a service on your localhost where you can access the service with a given pubmed ID, and the service will attempt to download the PDF and load it in your browser. BUT, I could not get it work out of the box and I wanted something which made it simple to retrieve PDF’s via the terminal. Luckily, Edoardo’s code was nicely written and easy to fix so that it ran with the latest versions of the gems he used and to update any journal links that might have changed since his implementation (which are the major reasons it did not run out of the box).

So I updated his script and added some journals/features and implemented a couple of scripts to call it command line using pubmed IDs or search terms.

Install:
These are ruby scripts so you will need to have ruby installed, furthermore you will need to install some gems

sudo apt-get install git-core #On ubuntu if you do not have git installed
git clone git://github.com/elfar/PubmedPDF.git
gem install mechanize
gem install bio #Not needed to load PDF's by pubmed IDs
gem install socksify  #only needed if you plan on using a SOCKS proxy

For the bio gem, it is probably better to install it via github

git clone git://github.com/bioruby/bioruby.git
cd bioruby
sudo ruby setup.rb

Call the scripts with no arguments to get some help:

pubmedid2pdf.rb
searchTerm2pdf.rb

Retrieve PDFs from a comma-separated list of pubmed IDs:

pubmedid2pdf.rb 19508715,18677110,19450510,19450585

Retrieve PDFs from a given search term: The outputted list is a .csv like file (’|’ instead of ‘,’) with various meta data. This can easily be parsed into a database (or you can modify the ruby script itself) if you prefer that. This is what we do. We, Biogeeks, have a rails framework with all our papers, where we can search etc. in our database. But I made these simple scripts like this so you could easily match this to your own setup, whatever it may be.

searchTerm2pdf.rb 'Lindow M[Author] OR Torarinsson E[Author]' > list

Optional arguments (for both scripts): You can use a SOCKS proxy, f. ex. if you’re at home and do not have access to many of the journals (we do not bypass the law, you will need to have legal access to the non-free PDFs ), but your University/Company has, you can always go through them. To do this, first, make a connection in a different terminal to your server:

ssh -D 9999 username@server  #In another terminal
searchTerm2pdf.rb 'Torarinsson E[Author]' 127.0.0.1 9999
OR
pubmedid2pdf.rb 19508715 127.0.0.1 9999

Conclusion: This works quite well for me, for example, I use the same search which I use for the pubmedlist wordpress plugin I wrote, to retrieve all the Biogeeks articles ‘(Lindow M[Author] OR Torarinsson E[Author] OR Lindgreen S[Author] OR Marstrand T[Author]) AND (1998/01/01[PDAT]:3000[PDAT])’ and it loads the 36 articles into the output list with corresponding meta data and retrieves 33 out of 36 PDFs. The three missing are one with no PDF available and two Nature (Gen) papers I don’t have access to through the server I am using.

While everyone is thrilled about next-generation sequencing and the added complexity level, the possible novel discoveries, detection of splice variants etc. Fact is that micro arrays still provide a cheaper and possibly more reliable platform for gene expression studies and we already have a vast amount of such data available in public databases for testing various biological hypotheses. Testing that requires no more than the good idea, and some CPU time. However, as with any test we need the right tool set. Broadly micro array analysis is done either by investigating differential expressed genes, or by globally group genes based on expression profiles and investigate the inferred classes.

In the first case the term Gene Set Enrichment Analysis has recently received a lot of attention. The archetype of this type of analysis is that presented by Subramanian et al (2005), although a variety of methodologies based on the same conceptual idea have been proposed.

Instead of assessing the significance of individual genes, the idea is to borrow strength by assessing the significance of an externally defined set of genes. For instance, the genes involved in a specific pathway or similarly. Gene sets should therefore, ideally, produce more robust results in the presence of technical and biological variability. However, gene set enrichment analysis (of any kind) is not the magic bullet, and comes with it own share of issues to consider, most of which are ignored if using the tools out of box. A very recommendable publication by Efron and Tibshirani (2007) address these issues. In short, simply permuting the genes within each experiment to assess the significance of a given gene set ignores the possible correlation between biologically related genes, and therefore under-estimates the null model. This in turns leads to significant results for gene sets simply caused by the fact that they are treated as independent which they are clearly not when members of the same pathway or similarly.

While permutation of the experiment labels will retain the correlation between the genes, it does not take into account that the detected significance could be due to a global effect leading to a general up-regulation of most genes. Therefore both between and within sampling is needed.

Now gene set enrichment analysis is excellent when the main question of interest is differential expression. In general more information is gained from scaling down the multi-dimensional expression data to a set of interpretable groupings across all levels of expression, not just the extremes. Doing so involves some sort of inference. Often a pattern recognition algorithm is applied to classify single genes to belong to a limited set of group, which hopefully have biological interpretations based on their member genes. Such unsupervised techniques are popular and widely applicable, however they often suffer from lack of reproducibility at the gene level, in that individual genes change group membership and or a group contains a subset of genes which a readily interpreted as belonging to a particular biological function while the rest of the set is not easily co-classified.

As the main exercise is to reduce the expression data into a limited number of biological interpretable groups, the problem can be approached oppositely as in gene set enrichment analysis. A publication by Sangurdekar et al. 2006 describe how measuring the entropy of a pre-defined group of genes decreases as a function of an experiment can be used to classify transcriptional response in terms of extent of co-expression of functionally related genes. The expectation is that if genes form a functional group under a given condition, experimental setup, they should be better correlated than a random assortment of genes.

To assess whether a given set of genes are specific for a condition and further if they are more so than the other sets specific for that condition both between experiment and within experiment permutations are performed. The measured quantity is the entropy measured over the singular values of the expression values of the gene set, a general idea previously described by Alter et al 2000. As the entropy tends towards zero the more stable and structured the gene expression profiles from the set are. Naturally genes that do not change expression levels across all conditions are highly correlated and therefore show low entropy a composite score involving the amplitude of expression across conditions are therefore incorporated.

Ultimately each gene set can be a relative importance both between and within all conditions, moreover a condition can be described by the median class activity, that is, the overall performance of all queried gene sets within the conditions, thereby elucidating if the phenotype is associated with a very specific response triggering a few pathways or more global changes in expression profiles. Hence leading to a much richer description of the data sets than obtained from testing differential expression.