## My first program?
my $output = 'Hello world';   ### This is not very original
## We will talk about $variable{keyword} soon
print "$output,
as written by $ENV{USER}\n";
The 'my' keyword tells Perl the scope of $output, which is to say that it 
defines the lifetime of $output.  Write your own Hello world program,
experiment with the quotations to learn the difference between single and double
quotes.
For example: '$output' versus "$output"
An array is a list of scalars.  Thus they may be anything from a list of
numbers, strings, or memory addresses of other things including other scalars,
arrays, etc.  Example:

## All arrays start with @
my @animals = ('parrot', 'python', 'camel');
An array is a piece of data which contains a list of other data.  This data
might include scalars (like $output above), other arrays, or even references
(pointers) to scalars or arrays, or even more complicated pieces of data.

## Arrays are 0 indexed, just like in C; if you want a value
## from an array, remember that it is a scalar
print "I like @animals, but especially $animals[0]\n";
@animals prints the entire list, while $animals[0] prints the first entry in the
list.

$animals[4] = 'elephant';
## If the 5th element of animals is 'elephant,' what is the fourth?
print "What is the fourth element: $animals[3]\n";
In Perl it is quite easy to change the elements of existing arrays or add new 
elements.  Take the above code and run it so that errors and output are 
redirected into two separate files.  If you do not recall how to do so, check
back to the previous introduction to unix.

## Hashes are delineated with the '%' and key value pairs are separated
## with commas
my $keyname = 'orange';  ## Just another scalar
my %colors = ( green => 'kiwi',
## and may have strings for values
  yellow => 'banana',
## or lists... 
  red => [ 'strawberry', 'apple' ],
## keys may also be arbitrarily complex, but be careful
 'bigger key' => { funky => 'town', },
## keys may also be variables
  "$keyname" => 'citrus',
);
## Add another value:
$colors{blue} = 'blueberry';
The above code is quite complex.  Lets break it down one line at a time.
The actual hash consists of everything from the first '(' until the final ');'
Each key value pair is separated by either '=>' or a comma (I prefer the more
visible '=>').
The hash above consists of four elements.  The first key listed is 'green' and
holds the value 'kiwi.'  This is followed by yellow and banana.  Red is more 
interesting, it contains a list of red fruits.  Finally, 'bigger key' contains a
hash reference.  More on those shortly.
One is not limited to using static names as $keyname illustrated.
The final line is a separate declaration which adds a key for the color blue.
Therefore, the hash contains four scalars, a list, and a hash reference.

my %log = ();  ## Creating an empty hash
my $number = 1;
while ($number < "10000000.0") { ## It is so easy to switch between integers and
  ## floating numbers in Perl
  $log{$number} = log($number);  ## Fill out this hash with natural logs
}
print "$log{9465306}";

        

## A function to calculate the number of hydrogen bonds in a sequence
my $sequence = 'ATGCGCTTAAAGAAAGGGTAA';
sub Count_Hydrogen {
  ## sub makes the function
  my $sequence = shift;  ## among its other uses, shift may be used to create
  ## the arguments for a function
  my @seq = split(//, $sequence);  ## split is a quick way to make an array from
  ## a string
  my $bonds = 0;
  foreach my $base (@seq) {  ## this is an idiom to iterate over everything in a
    ## list
    if ($base eq 'A' or $base eq 'T' or $base eq 'U') {
    ## if statements, very useful.
      $bonds = $bonds + 2;
    }
    elsif ($base eq 'C' or $base eq 'G') {
      $bonds = $bonds + 3;
    }
    else {
      die("Bases can only be A,U,T,G,C!");
    }
  }
  return($bonds);  ## most functions have to return something
}

split
my $sentence = 'Violence is the last refuge of the incompetent.';
## Create an array out of every space separated word in the sentence.
my @word_list = split(/ /, $sentence);
## Now copy and sort it...
my @word_copy = sort(@word_list);
## print the first and last words...
my $num_elements = scalar(@word_list);
print "First word: $word_list[0], last word: $word_list[$#word_list]
first word alphabetically: $word_copy[0] and last: $word_copy[$#word_copy]
how many elements?  $num_elements\n";
One nice thing about printing in Perl as opposed to other languages includes
the fact that it allows one to have newlines in the middle of the code.

for(each) loops
for my $index (0 .. $#word_list) {
  print "The $index element is $word_list[$index]\n";
}
## OR, we can do this:
foreach my $element (@word_list) {
  print "The element is $element\n";
}
The .. operator is a nice shortcut for iterating from point a to point b
$#word_list returns the number of the last element of an array
When you do not care about keeping the number of the elements
of a list, foreach is quite useful

if statements
my $input = <STDIN>;
chomp $input;
my %passwords = ( superuser => 'rootpass',
  normaluser => 'userpass',
 );
if ($input eq $passwords{superuser}) {
  print "Welcome, super user!\n";
}
elsif ($input eq $passwords{normaluser}) {
  print "Welcome, normal user!\n";
}
else {
  die("You are a bad bad man.");
}
STDIN is a mechanism for accessing keyboard input among other things

while loops
my $counter = 10;
while ($counter >= 0) {
  print "You have $counter seconds!\n";
  $counter = $counter - 1;
  sleep(1);
}
die("Boom!");

open and close
open(FILEHANDLE, "sequence1.fasta") or
			  die("I could not open sequence1.fasta $!");
while(my $line = <FILEHANDLE>) {
  if ($line =~ m/^\>/) { print "Comment: $line\n" }
  else { print "Data: $line\n"; }
}
close(FILEHANDLE);
open(PROGHANDLE, "ps aux |") or
			  die("I could not run the ps program. $!);
my %pids = ();
while(<PROGHANDLE>) {
  my $line = $_;
  chomp $line;
  next if ($line =~ m/^USER/);
  my @information = split(/\t/, $line);
  print "The command, run by user: $information[0] is\
$information[$#information]\n";
  $pid{$information[1]} = $information[$#information];
}
close(PROGHANDLE);
Run perldoc -f open to learn about this one

## Here is an object oriented approach to writing interactive web pages
## The use directive compiles in the CGI module before running the
## rest of the script
use CGI;
## new is a function (or method) built into the CGI package, it
## creates an instance of the CGI object so that we may use/modify it
my $page = new CGI;
## In this case the -> is telling Perl to use the header() method provided by
## CGI, thus if some other piece of code also defines header() the two will
## not cause trouble with one another.
print $page->header;
print $page->start_html("A page!");
print $page->end_html;

use Data::Dumper;
## First make a data structure
my $boo = {'first' => 1, 'second' => 2};
## Now we can set some variables used by the Data Dumper
$Data::Dumper::Terse = 1;          # don't output names where feasible
$Data::Dumper::Indent = 0;         # turn off all pretty print
## Finally, use the Data Dumper to print our data structure
print Dumper($boo), "\n";

## BPlite is a parser written to make accessing the output
## from BLAST easier
use Bio::Tools::BPlite;
## We need to feed it some input
open(INPUT, "<some_blast_output.txt");
## The \* means we are feading BPlite a pointer to the filehandle
my $report = new Bio::Tools::BPlite(-fh=>\*INPUT);
## nextSbjct is a method provided by Bio::Tools::BPlite
while (my $subject = $report->nextSbjct) {
## As are name, score, bits, P, and sbjctSeq.
        my $name = $subject->name;
        my $hsp = $subject->nextHSP();
	my $score = $hsp->score();
	my $bitscore = $hsp->bits();
	my $pvalue = $hsp->P();
	my $subject_sequence = $hsp->sbjctSeq();
## Once we have some data, print it!
        print "Some stats from $name:  Score: $score,
Bitscore: $bitscore, P value: $pvalue,
sequence: $subject_sequence\n";
}

## My apologies to Lewis Carroll
my $string = 'Beware the Jubjub bird, and shun the frumious Bandersnatch!';
## =~ tells Perl to bind a scalar value to a pattern match
## In this case, the m/ tells Perl that it will perform a match with no other
## funny buisness.  Thus it should return any input which has the search string
## 'andersn' in it 
## slashes (/) are commonly used to delineate the beginning and end of rules.

if ($string =~ m/andersn/) {  ## Found in the word Bandersnatch!
  print "I found the string in $string\n";
}
else {
  print "I did not find the string in $string\n";
}
## You are allowed to use variables in your regular expressions.

my $search = 'funky';
if ( m/$search/) {
  print "I found the string 'funky' in $string\n";
}
else {
  print "I did not find the string 'funky' in $string\n";
}
##  copy the string to $output

my $output = $string;
## And perform a translation from all a...z to A...Z
$output =~ tr/a-z/A-Z/;
print "Now it is $output\n";
## Copy over $output back with the original string
$output = $string;
$output =~ s/^([^ ]*) *([^ ]*)/$2 $1/;
## Perform something a bit more complicated...
## The ^ character specifies the beginning of line or match
## Any * character tells Perl to match 0 or more occurrences of the pattern
## Any + matches on 1 or more
## {} can be used to specify a maximum and/or minimum number of matches
## Parentheses () make logical groups, each group fills 
## pre-named variables $1 .. $n
## (a (b) (c)) -- $1 gets all of a b c, $2 gets only b, $3 gets c
## Square brackets make a character based group or 'class', thus
## [a-z] consists of the group of characters from a ... z, in this case the group 
## consists of some text followed by 0 or more spaces, separated by spaces
## Each one of these groups gets a $1, $2 etc.
## The match rule terminates at the second /, then the print rule tells Perl
## to print the second word followed by a space, then the first word...

print "Now output is: $output\n";
my $last =  "The food is under the bar in the barn.";
if ( m/foo(.*)bar/ ) {
     print "got _$1_\n";
}
## Will this print out:
#  got _d is under the _
# or
#  got _d is under the bar in the _
# ?