The new features include

(i) building gene-based and supermatrix-based phylogenies using a single command,

(ii) testing and visualizing evolutionary models,

(iii) calculating distances between trees of different size or including duplications, and

(iv) providing seamless integration with the NCBI taxonomy database.

ETE is freely available at http://etetoolkit.org

Address of the bookmark: http://etetoolkit.org

https://bsapubs.onlinelibrary.wiley.com/doi/pdf/10.1002/aps3.1207

Address of the bookmark: http://eyechrom.com:3838/EyeChrom/

Address of the bookmark: http://sysomics.com/deephic

Address of the bookmark: https://www.encodeproject.org/data-standards/reference-sequences/

Ruby is a dynamic, reflective, general purpose object-oriented programming language that combines syntax inspired by Perl with Smalltalk-like features. Ruby originated in Japan during the mid-1990s and was initially developed and designed by Yukihiro "Matz" Matsumoto. It was influenced primarily by Perl, Smalltalk, Eiffel, and Lisp.

Ruby supports multiple programming paradigms, including functional, object oriented, imperative and reflective. It also has a dynamic typesystem and automatic memory management; it is therefore similar in varying respects to Python, Perl, Lisp, Dylan, Pike, and CLU.

The standard 1.8.7 implementation is written in C, as a single-pass interpreted language. There is currently no specification of the Ruby language, so the original implementation is considered to be the de facto reference. As of 2010, there are a number of complete or upcoming alternative implementations of the Ruby language, including YARV, JRuby, Rubinius, IronRuby, MacRuby and HotRuby, each of which takes a different approach, with IronRuby, JRuby and MacRuby providing just-in-time compilation and MacRuby also providing ahead-of-time compilation. The official 1.9 branch uses YARV, as will 2.0 (development), and will eventually supersede the slower Ruby MRI.

Ruby Quick Reference
http://www.zenspider.com/Languages/Ruby/QuickRef.html

Ruby Annotation
http://www.w3.org/TR/ruby/

Ruby in Linux Journals
http://www.linuxjournal.com/article/5915

Ruby Documentation: Programming Ruby
http://ruby-doc.org/docs/ProgrammingRuby/

The Top 10 Reasons The Ruby Programming Language Sucks

http://www.slideshare.net/vishnu/the-top-10-reasons-the-ruby-programming-language-sucks

Ruby : The Programmers best friends
http://www.ruby-lang.org/en/

For Ruby Beginners
http://www.squidoo.com/ruby-programming-beginner

Ruby Programming
http://en.wikibooks.org/wiki/Ruby_Programming

Ruby CookBook
http://en.wikibooks.org/wiki/Cookbook:Table_of_Contents

Ruby Programming Challenge for Newbies -
http://rubylearning.com/blog/ruby-programming-challenge-faq/

Common "issues" faced by Ruby Newbies by Chris Strom -
http://japhr.blogspot.com/2009/10/newbie-feedback.html

Books
http://www.sapphiresteel.com/The-Book-Of-Ruby

Free Online Ruby Programming along with many Ruby newbies here -
http://rubylearning.org/class/

Code in almost all popular languages using Coding Ground. Edit, compile, execute and share your projects, 100% cloud.

http://www.tutorialspoint.com/codingground.htm

Address of the bookmark: http://www.tutorialspoint.com/codingground.htm

Many times in bioinformatics we need to deal with huge datasets which  are more than 100GB size. The traditional way to analysis a file is using the while loop

while (FILE){

Do something;

}

This is very slow(since we are using only one processor) and if we have 500 million lines in the dataset it takes more than a day to iterate through the whole dataset. So how do we make best use of all our processors and get the work done quickly?

Here is a very simple and efficient technique with perl which i have been using. I am  more inclined towards using perl fork than perl threads.

One of the oldest way to fork is

my $fork = fork();
if($fork){   
push (@childs,$fork); 
}
elseif($fork==0){
your code here;
exit(0);
}
else{die “Couldnt fork : $!”;}

## wait for the child process to finish
foreach(@childs){
my $tmp=waitid($_,0);
}

what a fork does is it creates a child process and takes the variables and code with it to analyze it separately (detached from the parent process) and thus a separate process is created( which usually runs on a separate processor). Thats it!! One big disadvantage of forking is its very difficult to share variables among the different processes. I will show you how to do it easily but still it has its own drawbacks.

Okie, now if you really do not want to use fork in your code, that’s okie too..There are many useful modules which do it for you very efficiently. One really useful module is Parallel::ForkManager. You can use Parallel::ForkManager to manage the number of forks you want to generate (number of processors you want to use).

Simple usage:
use Parallel::ForkManager;
my $max_processors=8;
my $fork= new Parallel::ForkManager($max_processors);
foreach (@dna) {
$fork->start and next; # do the fork
you code here;
$fork->finish; # do the exit in the child process
}
$pm->wait_all_children;

so you will be generating 8 forks which do the same thing for your each element of array. when one child finishes, Parallel::ForkManager generates a new one and thus you will be using all your processors to analyze the data. Now, if you have generated 8 child processes and want to write the data to one file. You need to lock the file to do this, because you will have problems with the buffering. You can lock the file using flock command.

open (my $QUAL, “myfile.txt”);
flock $QUAL, LOCK_EX or die “cant lock file $!”;
print $QUAL “$output”;
flock $QUAL, LOCK_UN or die “$!”;
close $QUAL;

I would not suggest using flock when dealing with multiple processes because it will decrease the processing efficiency( each child process must wait for the lock to be released by the other child process). Instead, I would suggest each fork writing to a separate file and after the processing just concatenating them.

Putting it all together, If you have 100GB data you can do this

step 1 : split the dataset equally according to number of processors you have. this may take a few hours(about 2-3 hrs for 100GB file)
You can use unix “split” command for this
for example:
my $number_split=int($number_of_entries_in_your_dataset/$max_processors);
my $split_Files=`split -l $number_split “your_file.fasta” “file_name”`;

step2: open you directory comtaining you split files and start Parallel::ForkManager.
For example:
opendir(DIRECTORY, $split_files_directory) or die $!; ### open the directory
my $fork= new Parallel::ForkManager($max_processors);
while (my $file = readdir(DIRECTORY)) { ### read the directory
if($file=~/^\./){next;}
print $file,”\n”;
########## Start fork ##########
my $pid= $super_fork->start and next;
Whatever you want to do with the split file ;
analyze my piece of $file;
######### end fork ###############
$super_fork->finish;
}
$super_fork->wait_all_children;

So basically each processor will be active with its piece of data (split file) and thus you have created 8 processes at one time which run without interfering with the other process. I again will not suggest writing output from each child process to one file(for reasons above). Write output from each fork to a separate file and finally concatenate them. Thats it, you have just increased your program speed by 8 times!! Isnt it easy?

Note:
You may worry about concatenation of the output each child generates, since it does take some time(remember 100GB). I think now you can use a mysql database LOAD DATA LOCAL INFILE command to load all the files into a single table(Should take about 3hrs for 100Gb dataset) and then export the whole table into one file. This should be faster than just concatenating them using “cat” command.(correct me if I am wrong)

Or much simpler way is to use pipes

cat output_dir/* | my_pipe or my_pipe <(file1) final_file;

Thats it guys!! Enjoy programming and please do comment. I am not a computer scientist so forgive me for any mistakes and if any please report them. Thank you.

Find more @ https://developers.google.com/edu/python/

 http://cosmos.hms.harvard.edu/.

Address of the bookmark: https://cosmos.hms.harvard.edu/

Professionally, Python is great for backend web development, data analysis, artificial intelligence, and scientific computing. Many developers have also used Python to build productivity tools, games, and desktop apps, so there are plenty of resources to help you learn how to do those as well.

For pros and cons visit http://www.bestprogramminglanguagefor.me/why-learn-python and http://bioinformaticsonline.com/discussion/view/459/python-vs-perl

More resources at https://github.com/CodementorIO/Python-Learning-Resources

Following are the list of useful python programming resources:

• 20 Python Libraries You Aren't Using (But Should) (Just fill the fields with any values)
• A Beginner's Python Tutorial
• A Byte of Python (3.x) (HTML, PDF, EPUB, Mobi)
• A Guide to Python's Magic Methods - Rafe Kettler
• A Whirlwind Tour of Python - Jake VanderPlas (PDF) (EPUB, MOBI)
• Automate the Boring Stuff - Al Sweigart
• Biopython (PDF)
• Build applications in Python the antitextbook (3.x) (HTML, PDF, EPUB, Mobi)
• Building Machine Learning Systems with Python - Willi Richert & Luis Pedro Coelho, Packt. (Just fill the fields with any values)
• Building Skills in Object-Oriented Design (Python) (PDF) (2.1.1)
• Building Skills in Python (PDF) (2.6)
• Code Like a Pythonista: Idiomatic Python
• CodeCademy Python
• Composing Programs (3.x)
• Data Structures and Algorithms in Python - B. R. Preiss (PDF)
• Dive into Python 3 - Mark Pilgrim (3.0)
  • Dive into Python - Mark Pilgrim (2.3)
• From Python to NumPy
• Full Stack Python
• Functional Programming in Python (Just fill the fields with any values)
• Fundamentals of Python Programming - Richard L. Halterman (PDF) (3.2)
• Google's Python Class (2.4 - 2.x)
• Google's Python Style Guide
• Hacking Secret Cyphers with Python - Al Sweigart (3.3)
• Hadoop with Python (Just fill the fields with any values)
• High Performance Python (PDF)
• Hitchhiker's Guide to Python! (2.6)
• How to Make Mistakes in Python - Mike Pirnat (PDF) (1st edition)
• How to Think Like a Computer Scientist: Learning with Python, Interactive Edition (3.2)
  • How to Think Like a Computer Scientist: Learning with Python - Allen B. Downey, Jeff Elkner and Chris Meyers (2.4)
  • Think Python - Allen B. Downey (2.x & 3.0)
• Intermediate Python - Muhammad Yasoob Ullah Khalid (1st edition)
• Introduction to Programming with Python (3.3)
  • Introduction to Programming Using Python - Cody Jackson (1st edition) (2.3)
• Introduction to Python - Kracekumar (2.7.3)
• Invent Your Own Computer Games With Python - Al Sweigart (3.1)
• Learn Python, Break Python
• Learn Python in Y minutes
• Learn Python The Hard Way (2.5 - 2.6)
• Learn to Program Using Python - Cody Jackson (PDF)
• Learning Python - Fabrizio Romano, Packt. (Just fill the fields with any values)
• Learning to Program
• Lectures on scientific computing with python - J.R. Johansson (2.7)
• Making Games with Python & Pygame - Al Sweigart (2.7)
• Modeling Creativity: Case Studies in Python - Tom D. De Smedt (PDF)
• Natural Language Processing with Python (3.x)
• Non-Programmer's Tutorial for Python 3 (3.3)
  • Non-Programmer's Tutorial for Python 2.6 (2.6)
• Picking a Python Version: A Manifesto (Just fill the fields with any values)
• Porting to Python 3: An In-Depth Guide (2.6 - 2.x & 3.1 - 3.x)
• Practical Programming in Python - Jeffrey Elkner (PDF)
• Problem Solving with Algorithms and Data Structures using Python - Bradley N. Miller and David L. Ranum
• Program Arcade Games With Python And Pygame (3.3)
• Programming Computer Vision with Python (PDF)
• Python 2 Official Documentation (PDF, HTML, TEXT) (2.x)
• Python 2.7 quick reference - New Mexico Tech (2.7)
• Python 3 Official Documentation (PDF, EPUB, HTML, TEXT) (3.x)
• Python Cookbook - David Beazley
• Python Data Science Handbook - Jake VanderPlas (HTML, Jupyter Notebooks)
• Python for Econometrics - Kevin Sheppard (PDF) (2.7.5)
• Python for Everybody Exploring Data Using Python 3 - Charles Severance (PDF, EPUB, HTML)
  • Python for Informatics: Exploring Information (2.7.5)
• Python for you and me (2.7.3)
• Python for you and me (3.x)
• Python Idioms (PDF)
• Python in Education (Just fill the fields with any values)
• Python in Hydrology - Sat Kumar Tomer
• Python Koans (2.7 or 3.x)
• Python Module of the Week (3.x)
  • Python Module of the Week (2.x)
• Python Notes for Professionals - Compiled from StackOverflow documentation (3.x)
• Python Practice Book (2.7.1)
• Python Practice Projects
• Python Programming (PDF) (2.6)
• Scipy Lecture Notes
• SICP in Python (3.2)
• Snake Wrangling For Kids (3.x)
• Suporting Python 3: An In-Depth Guide (2.6 - 2.x & 3.1 - 3.x)
• Test-Driven Web Development with Python (3.3 - 3.x)
• Text Processing in Python - David Mertz (2.3 - 2.x)
• The Coder's Apprentice: Learning Programming with Python 3 - Pieter Spronck (PDF) (3.x)
• The Definitive Guide to Jython, Python for the Java Platform - Josh Juneau, Jim Baker, Victor Ng, Leo Soto, Frank Wierzbicki (2.5)
• The Little Book of Python Anti-Patterns (Source)
• The Programming Historian - William J. Turkel, Adam Crymble and Alan MacEachern
• The Python Ecosystem: An Introduction
• The Python GTK+ 3 Tutorial
• The Standard Python Library - Fredrik Lundh
• Think Complexity - Allen B. Downey (2nd Edition) (PDF, HTML)
• Web2py: Complete Reference Manual, 6th Edition (pre-release) (2.5 - 2.x)
• Wikibooks: Python Programming (2.7)