Wednesday, November 11, 2009

GParted Live - A Bootable GParted CD

  When it comes to Linux based disk partitioning tools, GParted (Gnome Partition Editor) is hard to beat. It has a simple and straightforward user interface that reduces managing hard disk partitions to little more than a series of intuitive mouse clicks.

  As a self-confessed distro-whore, I download and install at least a couple of different Linux distributions a month, and being able to easily manage the task of deleting, creating, and modifying disk partitions is important. I keep one or two partitions available on my system just to try out different Linux distros, and use GParted to manage those partitions.

  I often use GParted while already booted into Linux to resize an existing partition, or add a new one. However, there are a number of circumstances where it is far easier to manage disk partitions without being booted into an OS. Some examples: When preparing a previously Windows-only system for dual boot, installing a second (or third or fourth) distro on an existing system, or when preparing a LiveCD based distro for a hard disk based install.

  Almost all modern distros contain some sort of partitioning tool as part of the installation process, but I often find these built in tools to be confusing to use. I am always afraid I am going to accidentally delete or overwrite an important existing partition while trying to set up a new partition during the install process.

  GParted Live gives me the ability to boot the computer completely outside of any OS already installed on the system and prepare any partitions I might need before doing any installation. That way I maintain complete control over the partitioning process and (hopefully!) avoid the possibility doing something stupid like deleting partitions I wanted to preserve.

  GParted Live is available as an ISO from the GParted Sourceforge site. After downloading the CD image and checking the MD5Sum, burning the image to a CD is a quick process, since the ISO is under 125MB. It easily fits on a 170MB mini CD as well.

  The GParted Live CD boots in less than two minutes directly into GParted, and you can immediately begin managing hard disk partitions. The Live CD uses the popular Debian distribution for booting, and Fluxbox as the windows manager. Also included are a simple terminal, an application to capture screen shots, and a tool for changing the screen resolution.

  I highly recommend GParted Live to anyone who has frequent need for a partition manager, or just wants to exercise a little more control over the partitioning process during an OS install.

One final note: It is recommended to do a whole disk or partition image backup before you use GParted (or any disk partitioning tool) to resize or move disk partitions.


Tuesday, November 10, 2009

Wordle - A Java Based "Word Cloud" Generator

  "What is a word cloud?", you may ask. Simply put, a word cloud is a visualization of word frequency in a given text as a weighted list. The more often the word appears in the given text, the larger the word appears in the cloud.

  Wordle is a nifty tool that allows anyone to easily create word clouds. Available at, Wordle can be used to create custom word clouds that are limited only by your imagination!

  The Wordle website provides a variety of methods for providing the text to be "wordled". The text can be pasted from the clipboard, referenced as an Atom or RSS feed, or linked from a user tag list.

  The resulting Wordle is created completely client-side (on your browser) using an imbedded Java applet. A series of drop-down menus allow an amazing amount of customization to be applied to the word cloud. The font, color, layout, and even number of words displayed are all editable.

  One down side of Wordle is that there isn't an easy way to save a Wordle creation as an image. Java doesn't have any provision for saving images. Images can either be saved as screenshots, or saved as a PDF through the use of a PDF printer driver like CutePDF Writer (Windows) or cups-pdf (Linux).

  Head on over to the Wordle website and give it a try. I'm positive you will soon be addicted!


Monday, October 26, 2009

Calling a Perl Script from a web page using JavaScript

Ever wanted to include some dynamic data on your web page, but didn't want to (or restrictions didn't allow you to) code the entire page server-side? There is actually a pretty straightforward way to accomplish this, by making the Perl script return valid JavaScript and then calling the Perl script as if it were JavaScript. Confused? I was too until I developed a working example of how it works.

For this example, I will combine the random quotation Perl script I outlined in a previous post with cowsay, also outlined in a previous post on this blog. The Perl script will call the random quotation script, pipe it through cowsay, then return the output in JavaScript to be executed by the browser.

First, the Perl code; I'll call it "":

use strict;
my $line;

# Get a random quotation from
# using, then pipe the output through
# the cowsay program, limiting the output to 30 columns
my $cowsay = `perl | cowsay -W 30`;

# Substitute all occurrences of the backslash ("\")
# with the HTML escape code ("\")
$cowsay =~ s/\\/\/g;

# Substitute all occurrences of the space (" ")
# with the HTML escape code (" ")
$cowsay =~ s/ / /g;

# Split the resulting cowsay text into individual lines
my @cowsay = split(/\n/, $cowsay);

# Declare the Internet Media (MIME) type  - The browser
# REQUIRES this to be declared; without it this example
print "Content-type: text/html\n\n";

# Using CSS, declare a style for our DIV tag, setting the
# font to bold courier, with the size of the font being
# 83% of the normal size.  This will permit us to utilize
# all 30 columns of the cowsay text in the narrow sidebar. 
print "document.write(\"<style>\\n\");\n";
print "document.write(\"  \#cowsay\\n\");\n";
print "document.write(\"  {\\n\");\n";
print "document.write(\"    font-family:courier;\\n\");\n";
print "document.write(\"    font-weight:bold;\\n\");\n";
print "document.write(\"    font-size:83%;\\n\");\n";
print "document.write(\"  }\\n\");\n";
print "document.write(\"</style>\\n\");\n";

# Create the cowsay DIV tag, and output the multiple lines
# of the cowsay text, separating each line with an HTML
# break, then close the DIV tag.
print "document.write(\"<div id=\'cowsay\'>\\n\");\n";
foreach $line (@cowsay)
  print "document.write(\"  $line\\n\");\n";
  print "document.write(\"  <br />\\n\");\n";
print "document.write(\"</div>\\n\");\n";
As you can see, all the output from the Perl script is in JavaScript, allowing the code to be executed client-side by the browser.

Now all that we need to do is to call the script from the web page, using the following code:
<script type="text/javascript" src=""> 
Of course, you would substitute your domain for the one listed above.

This is by no means the limit of what could be done utilizing this method. As long as the output is in JavaScript, the sky is the limit!

The Perl source for is available here. In order for function properly, it does require that cowsay and (and it's dependent Perl modules) be installed on your server.


Wednesday, October 21, 2009

Using Perl's LWP::UserAgent and HTML::Form Modules to Extract Data From a Web Page

I wanted a script that would display a random quotation each time I logged into my server from the command line. I suppose I could have used Linux's fortune program, but thats been done before, and besides, I wanted something different.

Here's how I used two modules from libwww-perl (LWP::UserAgent and HTML::Form) to extract random quotations from The libwww-perl collection is a set of Perl modules which provides a simple and consistent application programming interface to the World-Wide Web. The main focus of the library is to provide classes and functions that allow you to write WWW clients.

With amazingly little code, a perl script can be be written that retrieves the HTML returned when a web page is requested, just like a browser. This is accomplished thru the use of perl's LMP::UserAgent, a perl module that can be used to dispatch web requests.

In my case, I also needed to fill out an HTML form on a web page, click a Submit button, and extract specific data from the returned page. Again, very easy using another Perl module, HTML::Form.

In the following example, I hope to show how easy it can be to extract specific data from a web page using just these two Perl modules.

The two Perl modules used in this example are not installed by default. By far the easiest way to install them is by using your distro's package manager to install the libwww-perl package. That way you will get not only the two modules needed for this particular example, but the entire library of Perl www related modules. If you end up doing a lot of web related Perl programming, you will find uses for a lot more of the modules in the libwww-perl collection, so you might as well just install them all now.

I am going to break the script into four units and explain the function of each unit. This should allow anyone reading this post to get a pretty good understanding of how the script works.

use strict; 
use LWP::UserAgent; 
use HTML::Form; 
my ($quote_count,$return_count,$user_agent,$response,@forms, 
# Store the web form's checkbox names in an array  
@checkbox_values = ("mgm","motivate","classic","coles", 
# If the number of quotes to display is passed as a  
# command line parameter, store it in $quote_count,  
# otherwise set $quote_count to 1 
if (@ARGV) {$quote_count = $ARGV[0]}  
else {$quote_count = 1}  
#'s form has a minimum number of 4 
# and a maximum of 15 quotes.  If the number of requested  
# quotes is less than 4 or greater than 15, set the number 
# of returned quotes within those limits 
$return_count = $quote_count;  
if ($quote_count < 4) {$return_count = 4}  
if ($quote_count > 15) {$return_count = 15} 
# Create the UserAgent object 
$user_agent = LWP::UserAgent->new;
The beginning section lists the Perl modules used by the program (LWP::UserAgent and HTML::Form), declares all the variables, sets the number of quotes to be displayed (also checks if number is passed from the command line), and creates an instance of the UserAgent object.

# Retrieve the form from the webpage and store the form  
# in an HTML::Form hash 
$response = $user_agent->get("");  
@forms = HTML::Form->parse($response);  
# Clear the array that the modified form will be "pushed"  
# into, ignore the first form (it's not the one we want) 
# and store the form hash in an array (@inputs) 
$form = shift(@forms);  
$form = shift(@forms);  
@inputs = $form->inputs; 
This section retrieves the form from the web page and stores the form data in an array that can be modified.

# Parse the array containing the form data, entering the  
# number of quotes to request, checking all the checkboxes, 
# and filling out the outgoing form to be returned to the 
# web page's php program that processes the form 
for (my $i=0 ; $i<=$#inputs ; $i++)  
  $inp = $inputs[$i]; 
  $type = $inp->type; 
  if ($type eq "option") # Set the quote count  
  if ($type eq "checkbox") # Check the checkboxes 
    $check_value = shift(@checkbox_values); 
  $value = $inp->value; 
  $name = $inp->name; 
  if ($type ne "submit") {push(@form_out,$name,$value)}  
# Send the completed form to the php script that processes 
# the web form, and store the HTML that comes back in a  
# string called $page 
$response = $user_agent->post('',\@form_out); 
$page = $response->as_string;
Now the form data is modified and "submitted" on the web page

# Parse the HTML stored in $page, extracting the quotations 
# formatting the text, and displaying the requested number 
# of quotes 
$display_count = 0; 
# Look for a quote in the HTML 
while ($page =~ m/<dt class=\"quote\">(.*?)<\/dd>/gs) 
  $quote = $1;  
  if ($quote =~ m/\.html">(.*?)<\/a>/) # Extract the quote 
    $quote_string = $1; 
    # Replace any HTML break statements with Newlines 
    $quote_string =~ s/<br>/\n/gs;  
  if ($quote =~ m/<b>(.*?)<\/b>/) # Extract the author 
    $author = $1; 
    # If the author is imbedded in a link, remove the link HTML 
    if ($author =~ m/\/">(.*?)$/)  
      $author = $1; 
      $author =~ s/<\/a>//;  
    if ($display_count <= $quote_count)  
    {print $quote_string." - ".$author."\n\n"}  
The final section extracts the quotes from the HTML of the page that was returned when the "Sumbit" button was pressed and displays the quotes.

The entire Perl script is available here, if you would like to simply download the script.

Special thanks to Vivian's Tech Blog for the code that permitted me to display the code in the shaded boxes!


Sunday, October 11, 2009

cowsay - A Configurable Speaking/Thinking Cow

cowsay is a silly little command line text filter that displays a cow saying (or thinking) whatever text you feed it.  For example, each time I log into my server via ssh I am greeted by a friendly cow who gives me a random quote.

cowsay has a number of options that change how the text is displayed and the appearance of the cow (dead, greedy, paranoid, etc.).  There is also a library of "cowfiles" - alternate pictures that can be displayed in place of the cow.

Some of the options available:

The -n option turns off word wrap. If it is specified, the given message will not be word wrapped.

The  -W specifies roughly (where the message should be wrapped.  The default is equivalent to -W 40 i.e. wrap words at or before the 40th column.

There  are  several  provided modes which change the appearance of the cow depending on its particular emotional/physical state.
The -b option initiates Borg mode;
       -d causes the cow to appear dead;
       -g invokes greedy mode;
       -p causes a state of paranoia to come over the cow;
       -s makes the cow appear thoroughly stoned;
       -t yields a tired cow;
       -w is somewhat the opposite of -t, and initiates wired mode;
       -y brings on the cow's youthful appearance.
The -f option  specifies  a particular cow picture file (``cowfile'') to use.
The -l option lists all the cowfiles available

Making the cow say what you want is easy: cowsay moo displays a cow saying "moo".  You can also "pipe" the text to be displayed, like this: echo moo | cowsay .  To display a dragon saying the content of a text file called cowtext, enter cat ~/cowtext | cowsay -f dragon

Installing cowsay

If cowsay isn't already installed in your distribution, installing cowsay is a snap.  Almost all distros include cowsay in their repositories, so its a simple matter of installing via your distro's package manager. (apt/Synaptic, yum, pacman, YasT, etc.)

In the event you can't find a cowsay package for your flavor of Linux, you can download the source tarball from and build cowsay from source.

Cowsay Homepage:


Saturday, October 10, 2009

Where Wizards Stay Up Late - The Origins of the Internet

While perusing the computer books at my local library I came across a book entitled Where Wizards Stay Up Late - The Origins of the Internet, by Katie Hafner & Matthew Lyon

It looked interesting, so I checked it out.

What a fascinating read. I couldn't put the book down. I ended up reading the entire book in one sitting.

From early meetings discussing the need to link distant computers together, all the way through the development of HTML and Mosaic (the first browser) this book details not only the technologies that were developed, but also the people and organizations that made it all happen.

It is written so even a person with no background in the underlying hardware, software, and protocols involved with the internet can read it and understand, but yet someone with a basic understanding of those concepts isn't put off.

This book is a really good read, and anyone with even the slightest interest in how the internet as we know it came to be should read it.


Friday, October 9, 2009

Beginner's Linux Command Cheat Sheet

  As a new (or experienced) Linux user, ever wish you had a handy cheat sheet filled with the most commonly used terminal commands for things like file operations, process management, permissions, ssh, searching, system information, compression and networking?

  Now you can, thanks to Jacob Peddicord and FOSSwire.  Designed as a reference to assist both new and seasoned Linux users remember the syntax for common cli commands, the Unix/Linux Command Cheat Sheet is downloadable in PDF format in english as well as a variety of other languages.