• Creates fast runtime programs. 
• Complete access to hardware, memory and I/O. 
• Strict type checking helps prevent errors.

• The language has few high level constructs, so development is relatively slow. 
• Heavy use of memory pointers, and necessity of the programmer managing the memory, often leads to intermittents and bugs. 
• Strict type checking slows development.

• All advantages of C, although not quite as fast runtime. 
• Classes and objects make programs more scalable. 
• Strict type checking helps prevent errors. 
• Full object encapsulation makes for rock solid programs, except for pointer problems and buffer overflow.

• The same disadvantages as C. 
• Strict type checking slows development.

• Scalable to huge projects due to innate OOP. 
• Built-in memory garbage collection and lack of pointers minimize bugs. 
• The debugging phase of Java programs is incredably fast. 
• Strict type checking helps prevent errors. 
• Full object encapsulation makes for rock solid programs.
• Huge market for Java programmers.
  

• Runtime performance can be very slow. 
• Even simple programs require OOP, meaning simple programs aren't as simple as you'd like. 
• Strict type checking slows development.

• Well integrated OOP makes Python scalable to fairly large projects.
• Built-in memory garbage collection and lack of pointers minimize bugs. 
• Loose type checking makes for faster development.
• Object encapsulation is available if you know how (__variable), so you can write pretty solid programs.
• Python's indent sensitive nesting makes it the most readable language on the planet.
  

• Loose type checking encourages subtle bugs.
• Runtime performance cannot match C or C++.
• There's almost no market for Python programmers.
  

• Well integrated OOP makes Ruby scalable to large projects.
• Built-in memory garbage collection and lack of pointers minimize bugs. 
• Loose type checking makes for faster development.
•  Object encapsulation makes for solid programs.

• Runtime performance cannot match C or C++.
• There is zero market for Ruby programmers.
  

• Substantial programs can be made with just a few TCL statements.

• No OOP, and not very scalable.
• TCL is seldom used, and there's little market for TCL programmers.
  

• Creates fast and efficient graphical applications.
• There are a few QT jobs out there.
  

• Complicated to use.
  

• Creates fast and efficient graphical applications.
• There are a few gTk jobs out there.
  

• Complicated to use.
  

• Outstandingly modularity is achieved with separate executables, piping and redirection.
• Quality control is easy if you assemble the program from tested, known good executables.
  
• Non-looping performance is as fast as the optimized programs it calls.
• Available from very early in bootup, so bash scripts can be used to control bootup.
  

• Looping performance is unacceptably slow.
• The syntax is maddeningly quirky.
• No OOP.
  
• Little support for complex data constructs
  

• Availability of OOP makes Perl scalable to moderate sized projects.
• Built-in memory garbage collection and lack of pointers minimize bugs. 
• Loose type checking makes for faster development.
• Used ubiquitously throughout the UNIX/Linux/BSD world. 
• A Perl program is likely to run on any target machine.
  
• Substantial market for Perl skills.
• Very fast for an interpreter.
  
• The CPAN Perl module repository contains tools to simplify almost anything you need to do.
  

• Lack of encapsulation and private variables can lead to bugs in larger projects.
• The "many ways to perform a task" philosophy of Perl leads to unreadable code and difficult debugging, and a lack of "best practices".
• Lack of "best practices" leads to some mighty bad Perl code out there.
  

my @output = `./child.pl`;
foreach my $line (@output) { chomp($line); print "$line\n"; }
my $childexit = ($? <= 32768 ? $? >> 8 : 0 - ((65536 - $?) >> 8));
print "\nReturn value=>$childexit<\n";

print "Hello World\n";

[slitt@mydesk slitt]$ perl ./test.pl
Hello World
[slitt@mydesk slitt]$

#!/usr/bin/perl -w
print "Hello World\n";

#!/usr/bin/perl -w
use strict;
print "Hello World\n";

#!/usr/bin/perl -w
use strict;
my $var = "Hello World\n";
print $var;

#!/usr/bin/perl -w
use strict;
my $var = "Hello World\n";
print $var;
$var = 32;
print "Number is ", $var *  10, "\n";

[slitt@mydesk slitt]$ ./test.pl
Hello World
Number is 320
[slitt@mydesk slitt]$

#!/usr/bin/perl -w
use strict;
for(my $ss = 1; $ss <= 10; $ss++)
	{
	print "$ss\n";
	}

#!/usr/bin/perl -w
use strict;
my $ss = 1;
while($ss <= 10)
	{
	print "$ss\n";
	$ss++;
	}

#!/usr/bin/perl -w
use strict;
my $ss = 1;
while($ss <= 10)
	{
	print "$ss\n";
	if($ss >= 3)
		{
		last;
		}
	$ss++;
	}
print "Final value is ", $ss, ".\n";

#!/usr/bin/perl -w
use strict;
my @praises = ("fast", "stable", "easy");
foreach my $praise (@praises)
	{
	print "Perl is ", $praise, "\n";
	}

[slitt@mydesk slitt]$ ./test.pl
Perl is fast
Perl is stable
Perl is easy
[slitt@mydesk slitt]$

#!/usr/bin/perl -w
use strict;
for(my $number = 1; $number <= 6; $number++)
	{
	print $number, " :";
	if($number > 5)
		{
		print "The number is greater than 5\n";
		}
	elsif($number > 3)
		{
		print "The number is greater than 3 but less than 6\n";
		}
	elsif($number == 3)
		{
		print "The number is equal to 3\n";
		}
	else
		{
		print "The number is less than 3\n";
		}
	}

[slitt@mydesk slitt]$ ./test.pl
1 :The number is less than 3
2 :The number is less than 3
3 :The number is equal to 3
4 :The number is greater than 3 but less than 6
5 :The number is greater than 3 but less than 6
6 :The number is greater than 5
[slitt@mydesk slitt]$

#!/usr/bin/perl -w
use strict;
for(my $number = 1; $number <= 6; $number++)
	{
	print $number, " :";
	print "<=>", $number <=> 3, "\n";
	}

[slitt@mydesk slitt]$ ./test.pl
1 :<=>-1
2 :<=>-1
3 :<=>0
4 :<=>1
5 :<=>1
6 :<=>1
[slitt@mydesk slitt]$

#!/usr/bin/perl -w
use strict;
my @books = ("Cujo", "Carrie", "Christine");
foreach my $book (@books)
	{
	print $book, "\n";
	}

#!/usr/bin/perl -w
use strict;
my @books = ("Cujo", "Carrie", "Christine");
my $subscript = 0;
print "Subscript of last element is ", $#books, "\n";
while($subscript <= $#books)
	{
	print $subscript, ": ", $books[$subscript], "\n";
	$subscript++;
	}

#!/usr/bin/perl -w
use strict;
my @books = ("Cujo", "Carrie", "Christine");
my $saying = "To be or not to be, that is the question";
my $bookstring = join(", ", @books);
print $bookstring, "\n";
my @sayingarray = split(/ /, $saying);
foreach my $element (@sayingarray)
	{
	print $element, "\n";
	}

[slitt@mydesk slitt]$ ./test.pl
Cujo, Carrie, Christine
To
be
or
not
to
be,
that
is
the
question
[slitt@mydesk slitt]$

#!/usr/bin/perl -w
use strict;
my @books = ("Cujo", "Carrie", "Christine");
print $books[1], "\n"

[slitt@mydesk slitt]$ ./test.pl
Carrie
[slitt@mydesk slitt]$ 

#!/usr/bin/perl -w
use strict;
my @books = ("Cujo", "Carrie", "Christine");
$books[10] = "Firestarter";
$books[2] = "The Stand";
my $ss = 0;
foreach my $book (@books)
	{
	print $ss, ": ", $book, "\n" if defined($book);
	$ss++;
	}
print "The last element has subscript ", $#books, "\n";

[slitt@mydesk slitt]$ ./test.pl
0: Cujo
1: Carrie
2: The Stand
10: Firestarter
The last element has subscript 10
[slitt@mydesk slitt]$

#!/usr/bin/perl -w
use strict;
my $outputfile;
open($outputfile, ">outfile.txt") || die "Could not open for output\n";
my @books = ("Cujo", "Carrie", "Christine");
foreach my $book (@books)
	{
	print $outputfile $book, "\n";
	}
close($outputfile);

#!/usr/bin/perl -w
use strict;
my $inputfile;
open($inputfile, "<infile.txt") || die "Could not open for input\n";
while(<$inputfile>)
	{
	my $line = $_;
	chomp($line);
	print $line, "\n";
	}
close($inputfile);

#!/usr/bin/perl -w
use strict;
my $inputfile;
open($inputfile, "<infile.txt") || die "Could not open for input\n";
my @lines = <$inputfile>;
close($inputfile);
foreach my $line (@lines)
	{
	chomp($line);
	print $line, "\n";
	}

#!/usr/bin/perl -w
use strict;
my %person = (
	'fname'=>'John',
	'lname'=>'Smith',
	'job'=>'Perl Developer'
	);
print "First name:      ", $person{'fname'}, "\n";
print "Last  name:      ", $person{'lname'}, "\n";
print "Job:             ", $person{'job'}, "\n";

[slitt@mydesk slitt]$ ./test.pl
First name:      John
Last  name:      Smith
Job:             Perl Developer
[slitt@mydesk slitt]$ 

#!/usr/bin/perl -w
use strict;
my %person = (
	'fname'=>'Zev',
	'lname'=>'Smith',
	'job'=>'Perl Developer'
	);
my @keys = keys %person;
foreach my $key (@keys)
	{
	print $key, ": ", $person{$key}, "\n";
	}

[slitt@mydesk slitt]$ ./test.pl
lname: Smith
fname: Zev
job: Perl Developer
[slitt@mydesk slitt]$

#!/usr/bin/perl -w
use strict;
my %numbers = (
	'one'=>1,
	'two'=>2,
	'three'=>3
	);

$numbers{'four'} = 4;
delete($numbers{'two'});

foreach my $key (sort {$numbers{$a} <=> $numbers{$b}} keys %numbers)
	{
	print $key, ": ", $numbers{$key}, "\n";
	}

[slitt@mydesk slitt]$ ./test.pl
one: 1
three: 3
four: 4
[slitt@mydesk slitt]$

#!/usr/bin/perl -w
use strict;

package Me;

sub new
	{
	my($type) = $_[0];
	my($self) = {};
	$self->{'name'} = 'Bill Brown';

	### Make a reference to an empty array of jobs
	$self->{'jobs'} = [];

	### Now make each element of array referenced by
	### $self->{'jobs'} a REFERENCE to a hash!
	$self->{'jobs'}->[0]={'ystart'=>'1998','yend'=>'1999','desc'=>'Bus driver'};
	$self->{'jobs'}->[1]={'ystart'=>'1999','yend'=>'1999','desc'=>'Bus mechanic'};
	$self->{'jobs'}->[2]={'ystart'=>'1999','yend'=>'2001','desc'=>'Software Developer'};

	bless($self, $type);
	return($self);
	}

### showResume is coded to show off the -> operator. In real
### life you'd probably use a foreach loop, but the following
### while(1) loop better demonstrates nested -> operators.
sub showResume
	{
	my($self)=$_[0];
	print "Resume of " . $self->{'name'} . "\n\n";
	print "Start\tEnd\tDescription\n";
	my $ss = 0;

	# Loop through array referenced by $self->{'jobs'},
	# and for each subscript, print the value corresponding
	# to the hash key. In other words, print every field of
	# every record of the jobs array
	while (1)
		{
		last unless defined $self->{'jobs'}->[$ss];
		print "$self->{'jobs'}->[$ss]->{'ystart'}\t";
		print "$self->{'jobs'}->[$ss]->{'yend'}\t";
		print "$self->{'jobs'}->[$ss]->{'desc'}\n";
		$ss++;
		}
	}

package Main;

my $me = Me->new();
$me->showResume();
print "\nFirst job was $me->{'jobs'}->[0]->{'desc'}.\n";

sub printHello()
	{
	### code
	### return value if any

sub biggest($$)
	{
	$a = shift;              ### arg0
	$b = shift;              ### arg1
	### code
	### return value if any
	}

sub biggest($$)
	{
	$a = shift;
	$b = shift;
	if($a >= $b)
		{
		return $a;
		}
	else
		{
		return $b;
		}
	}

my $wwii = 1941;
my $gulfWar = 1990;
my $bigger = biggest($wwii, $gulfwar);
### $bigger now contains 1990.

%globals;
# ...
# set globals
# ...

# now print globals
&printGlobals(\%globals);

sub printGlobals
   {
   # copy of argument precludes extra-scope change
   my(%globals) = %{$_[0]};
   print "Current Dir: $globals{'currentdir'}\n";
   print "Program Dir: $globals{'programdir'}\n";
   print "Version    : $globals{'programver'}\n";
   print "Accesslevel: $globals{'accesslevel'}\n";
   }

#!/usr/bin/perl -w
use strict;

package Person;

sub new($$)
	{
	my($type) = shift;         #arg0
	my($self) = {};
	$self->{'name'} = shift;   #arg1
	bless($self, $type);
	return($self);
	}

sub setAge($$)
	{
	my $self = shift;          #arg0
	$self->{'age'} = $_[1];
	}

sub getAge($)
	{
	my $self = shift;          #arg0
	return $self->{'age'};
	}

sub getName($)
	{
	my $self = shift;          #arg0
	return $self->{'name'};
	}

package Main;
use Person;

my $me = Person->new('Steve Litt');
$me->setAge(16);     ### Yeah, right
print $me->getName(), " is ", $me->getAge, " years old\n";