I’m moving due to frustration with the constraints about the type of data I can post. WordPress won’t allow you to post iframes, embedded Flash, or Javascript, which I can understand from a security standpoint. However, I’d really like to be able to post Youtube videos via the new iframe method that makes them directly viewable on an iPad (I love my iPad).

http://www.youtube.com/watch?v=l3ib5eEEOqk

The script I used to put data into the database can be found here: http://gist.github.com/532669

UrDoinItRite will eventually become a full fledged RPG engine based on Gosu. At the moment, it’s just a hacked together proof of concept that I slapped together in a few hours. Expect updates soon.

Also, check out the Lighthouse page.

http://github.com/actsasbuffoon/AutoPong

I’ve been away for a long while, and I’ve been quite busy. I’ve changed jobs (I’m the lead developer for a Ruby based startup now), and I’ve written a whole lot of code. I’ll spare you the boring details, but I’m going to try to post more often.

I had an entertaining afternoon yesterday, and I threw together a few projects which I’ll post here shortly. Stay tuned!

Ruby can plug into other programs on Windows using OLE (Object linking & embedding), which allows it to send messages to other programs. For instance, here’s the Ruby code needed to open an instance of Microsoft Word, have it open every .doc file in a folder, and then close them:

require 'win32ole'
word = WIN32OLE.new "word.application"
Dir.glob("my_documents/*.doc").each do |doc|
  word.Documents.Add doc
  word.ActiveDocument.Close
end
word.Quit

And that’s all there is to it!

You may have noticed that I called all of the OLE methods with a capitalized first letter. In some cases, the name of an OLE method may conflict with the name of a regular Ruby method. For instance, if an OLE enabled program has a method named “send” then instead of calling the OLE method, you’d actually end up calling Ruby’s default send method that all objects have. You can avoid the problem by calling OLE methods with capitalized letters, which will never conflict with Ruby’s built in methods.

Ruby as the Ultimate Glue Language

There are lots of other things you can do with OLE, including controlling any MS Office application, most web browsers, and a whole slew of other programs. As you can imagine, it’s very powerful stuff to be able to script these programs from Ruby.

However, even the best OLE enabled programs tend to leave me wanting to be able to do something that the designers didn’t account for. That’s where AutoItX3 comes in.

AutoItX3 is a programming language that was made specifically to automate Windows. You can find it here: http://www.autoitscript.com/autoit3/index.shtml

If you need to automate something, it’s usually best to use the OLE interface when possible. AutoItX3 is a generalized tool, but a program’s OLE interface was created with that program in mind. However, when the OLE interface leaves you in need of more functionality, AutoItX3 can usually take care of whatever you need.

Where AutoItX3 Went Wrong

(And why it doesn’t matter)

Now, you may have noticed a problem with AutoItX3; it’s syntax looks like Visual Basic! I don’t know about you, but I stopped programming in Basic a long time ago, and I’d rather not start again. AutoItX3 has static variable typing, a lack of blocks, and all sorts of other things that make us love Ruby so.

Fortunately, the people who made AutoItX3 were not only bright enough to make this awesome tool, they also gave it a great OLE interface. In other words, we can use the methods from AutoItX3, but control the logic with Ruby. You get virtually all the power of AutoItX3, but only a tiny learning curve.

Keyboard Control to Major Tom

Have you ever wanted to make Ruby take control of your keyboard? Perhaps to log into some website that doesn’t support cookies or something? Here’s how it goes in AutoItX3 (Via Ruby):

require 'win32ole'
ai = WIN32OLE.new("AutoItX3.Control")
1.upto(10) do |i|
  ai.Send "#{i}{ENTER}"
end

This script will print 1 through 10, pressing the Enter key after each number. AutoItX3 handles special keys through a set of escapes which are placed between {}. A full listing of escapes can be found here: http://www.autoitscript.com/autoit3/docs/appendix/SendKeys.htm

There are also some shorthand escapes that don’t require curly brackets. For instance ^ is short for CTRL, so:

ai.Send "^c"

would type CTRL+C (AKA: the shortcut for the Copy command).

Three Blind Mice

Of course, it can also control your mouse:

ai.MouseClick("left", 50, 75)

The above code would perform a left-click at 50 pixels from the left of your screen by 75 pixels from the top. AutoItX3 can even automate your scrollwheel:

ai.MouseWheel("down", 10)

This will make your mouse scroll down 10 “clicks”. AutoItX3 can also drag, drop, and do just about anything else you can legally do with a mouse in most states.

Where Art Thou, Notepad?

AutoItX3 can also wait for a specific window to open before moving on. Consider the following code:

require 'win32ole'

ai = WIN32OLE.new("AutoItX3.Control")

ai.WinWaitActive("Untitled - Notepad")
ai.Send("Chunky bacon!")

This program would run, wait until the active window is named “Untitled – Notepad”, and then type out a message. This is great for handling popups.

The More Things Change…

Now let’s say you’re using AutoItX3, but you’ve run into a nasty problem. A program you’re automating has some step that takes a long time. It’s difficult to get AutoItX3 to know when the program has finished processing, because it doesn’t give any kind of programatic feedback.

You could compensate by building a set delay into your program, but you’re wasting time after the other program finishes processing. Even more severe, if the other program processes longer than expected, you’re program could resume processing before the other program is ready. When that happens, your program is probably going to eat flaming death.

Fortunately, AutoItX3 can deal with this. So long as something changes on the screen when the other program finishes processing, you can use AutoItX3′s PixelChecksum method to spot changes:

old_screen_checksum = ai.PixelChecksum(100, 100, 200, 200)

until ai.PixelChecksum(100, 100, 200, 200) != old_screen_checksum do
  sleep 0.1
end

The code above would take a 100 by 100 pixel checksum of the screen, and check 10 times per second to see if that area of the screen has changed.

There are many other things that AutoItX3 can do.  The documentation is quite decent, and the new abilities it gives Ruby are divine. Try it out and I’m sure you’ll be impressed.

foo ||= “bar”

First, we have the ||= operator. The ||= operator only assigns a value to the variable if the variable is nil. Let’s consider the following two programs.

This first program isn’t using ||=.

foo = nil
foo = "bar" if foo.nil?
puts foo                      #Returns "bar"
foo = "baz" if foo.nil?
puts foo                      #Returns "bar"

Now let’s see how it would look using ||=

foo = nil
foo ||= "bar"
puts foo                      #Returns "bar"
foo ||= "baz"
puts foo                      #Returns "bar"

In both programs line 2 causes “bar” to be assigned to foo, since foo is nil. On line 4 “baz” is not assigned, because foo is no longer nil. Both versions work the same way, but version two has the benefit of having one less conditional statement to read. In my opinion, it’s cleaner and easier to read.

foo = bar || baz

Next, we have this little beauty. It’s so simple, but so wonderfully useful, especially when using hashes as method arguments. Basically, a lot of programmers think || is only useful in conditional statements, but there are many other places where it can be useful. Consider the following program:

foo = "Chunky"
bar = nil
puts foo || bar  #Returns "Chunky"
foo = nil
bar = "bacon!"
puts foo || bar  #Returns "bacon!"
foo = "Chunky"
bar = "bacon!"
puts foo || bar  #Returns "Chunky"

A lot of programmers think it’s a little weird seeing || operators outside of a conditional statement, but they do exactly what you’d expect in this context. Line three essentially says “puts ‘Chunky’ or nil”. The || operator returns whichever argument is not false, so it returns “Chunky” and discards nil.

Then line six does the opposite.  The “foo” variable is now nil, but “bar” has a value. The || operator returns “bacon!” and discards nil.

Line nine has two valid values, so || returns the first one and discards the second.

This can really make life easier when passing hashes as method arguments. Consider the following bit of code:

def my_method(foo = {:bar => "Chunky"})
  @instance_var = foo[:bar]
end

puts my_method({:baz => "bacon!"})       #Returns nil

What’s wrong with this code? Well, the programmer wanted the “foo” hash to have a default key/value pair of {:bar => “Chunky”}, but something went wrong. The method was provided with an arguement, and the default value was dropped. However, the argument hash didn’t define a “:bar” key, so there’s no value associated with it.

Fortunately this example is just trying to print the value to the console. Had it been trying to multiply it by something then we’d have ended up with an exception instead!

Of course, the program could use a cumbersome conditional statement to get around this:

def my_method(foo = {})
  foo[:bar] = "Chunky" if foo[:bar].nil?
  @instance_var = foo[:bar]
end

puts my_method({:baz => "bacon!"})

But that’s more bothersome than it needs to be. Let’s see how it would look using ||.

def my_method(foo = {})
  @instance_var = foo[:bar] || "Chunky"
end

puts my_method({:baz => "bacon!"})

Once again, I think that’s a lot easier on the eyes. We’ve done away with another conditional statement and replaced with something more Ruby-like.

Plus, as Diego Scataglini points out, methods that take a single hash as an argument perform considerably faster than methods that take more than a few regular variables, especially if you’re using default assignments.

Commatose is an extremely simple gem (The whole thing is only 4Kb, and that’s only because I write 10 lines of documentation for every line of code). It allows you to quickly and easily separate your numbers with commas (Or any other arbitrary separator).

Commatose has some useful internationalization options, such as the ability to use something other than commas as a separator, changing the number of digits between separators and separating the numbers after a decimal point.

You can see the RubyForge page here: http://rubyforge.org/projects/commatose/

Consider this extremely simple script:

Extracted from commatose.rb

class Fixnum
  def to_sc(delimiter = ",", numbers_per_section = 3)
    self.to_s.gsub(/(\d)(?=\d{#{numbers_per_section}}+(\.\d*)?$)/, '\1' + delimiter)
  end
end

class Bignum
  def to_sc(delimiter = ",", numbers_per_section = 3)
    self.to_s.gsub(/(\d)(?=\d{#{numbers_per_section}}+(\.\d*)?$)/, '\1' + delimiter)
  end
end

class Float
  def to_sc(delimiter = ",", numbers_per_section = 3, after_decimal = false)
    if after_decimal then
      self.to_s.gsub(/(\d)(?=\d{#{numbers_per_section}}+(\.\d*)?$)/, '\1' + delimiter)
    else
      self.to_s.split(".")[0].gsub(/(\d)(?=\d{#{numbers_per_section}}+(\.\d*)?$)/, '\1' + delimiter) + "." + self.to_s.split(".")[1]
    end
  end
end

This script extends the Fixnum, Bignum and Float classes with a new method called “to_sc”. The method converts the number to a string and inserts commas (or some other arbitrary separator).

The code itself isn’t important, so don’t worry if you can’t follow it. What we’re concerned about is turning this into a gem.

Documenting your gem with RDoc

So, first thing’s first. Every gem needs some decent documentation. If you’ve never worked with RDoc before, then you may be surprised by how easy this next step will be.

RDoc extracts comments from your code and creates really nice looking HTML documentation. You don’t even have to worry about writing the HTML. RDoc will create it for you using a very simple markup language.

Here’s my documented Fixnum class:

Extracted from commatose.rb

#= Commatose
#Commatose makes it easy to insert commas into your Fixnums, Bignums and Floats. See below for more information.
class Fixnum
  #Converts the number to a string and splits it by commas.
  #
  #Example:
  #	1234567.to_sc
  #	>1,234,567
  #
  #You can change the delimiter by giving a string as an argument.
  #
  #Example:
  #  1234567.to_sc("_")
  #  >1_234_567
  #
  #Commatose can also change the number of digits between seperators.
  #
  #Example:
  #1234567.to_sc(",", 2)
  #  >1,23,45,67
  def to_sc(delimiter = ",", numbers_per_section = 3)
    self.to_s.gsub(/(\d)(?=\d{#{numbers_per_section}}+(\.\d*)?$)/, '\1' + delimiter)
  end
end

As you can see, I’ve put some useful comments into the class. RDoc will read those comments and create valid HTML from them. I’ve put a tab between the hash mark and the bits that I want to show up as code in the documentation. That’s because any comments that are directly next to the hash mark will be put inside paragraph tags, and anything with a tab before it will be placed inside <code> and <pre> tags.

At the very top of the code, I wrote “= Commatose”. The equal sign will puts the “Commatose” into H1 tags. Two equal signs would be an H2, and so on and so forth.

Take a look at the RDoc I ended up with to see how this looks:

http://commatose.rubyforge.org/rdoc/classes/Fixnum.html

I also included a README to give a more general explanation of the entire gem. Here’s an excerpt from the README:

Extracted from README (No file extension)

= Commatose Documentation

Commatose makes it easy to insert commas into your numbers. It extends the Fixnum, Bignum and Float classes with a new method called "to_sc". The method name is short for "To string with comma". Using Commatose couldn't be easier. Let's take a look at a few examples.

== Fixnums

Commatose can convert fixnums like so:

  require 'commatose'
  puts "Example 1"
  num = 1234567
  puts "The number in this example is a #{num.class}."
  puts "Before:\t#{num}"
  puts "After:\t#{num.to_sc}"

The code above returns:

  Example 1
  The number in this example is a Fixnum.
  Before:	1234567
  After:	1,234,567

  {Learn more}[link:/classes/Fixnum.html]

== Bignums

Commatose can also convert bignums:

  require 'commatose'
  puts "Example 2"
  num = 1234567890
  puts "The number in this example is a #{num.class}."
  puts "Before:\t#{num}"
  puts "After:\t#{num.to_sc}"

The code above returns:

  Example 2
  The number in this example is a Bignum.
  Before:	1234567890
  After:	1,234,567,890

  {Learn more}[link:/classes/Bignum.html]

As you can see, the syntax is exactly the same, except this isn’t a Ruby script so there’s no need to put comment symbols in front of each line. I still used an equal sign for H1 tags, two equal signs for H2 tags, and a tab to denote code. You’ll also notice that I added links to the classes that the examples refer to.

Take a look at the finished README:

http://commatose.rubyforge.org/rdoc/

Writing a Gemspec

Okay, now the only thing we have left is to write a gemspec. The gemspec is what tells Gems how to create and package your code. Let’s take a look at the gemspec I wrote:

Extracted from commatose.gemspec

spec = Gem::Specification.new do |s|
  s.name = "Commatose"
  s.version = "0.0.1"
  s.author = "Acts as Buffoon (A.K.A. Michael Tomer)"
  s.email = ""
  s.homepage = "http://actsasbuffoon.wordpress.com"
  s.platform = Gem::Platform::RUBY
  s.summary = "Commatose makes it easy to split your numbers by commas."
  s.files = ["commatose.rb", "README"]
  s.has_rdoc = true
  s.extra_rdoc_files = ['README']
  s.require_path = '.'
  s.rdoc_options << '--main' << 'README'
  s.rubyforge_project = 'Commatose'
end

The gemspec itself is pretty straightforward. I specify that I want the gem to be known as “Commatose”, the version is 0.0.1, etc.

Under files, you specify the files that you want to have packaged. Of course, this is Ruby, so you can use Dir.glob, or some other command to grab lots of files.

“extra_rdoc_files” tells Gems to parse the given files with RDoc. Normally it would only look at .rb and .rbw files.

Additionally, I specify that the require path should be whatever folder Commatose is installed in. If you don’t specify an include path with your scripts in it, then requiring the gem won’t do anything!

Last, I set the main RDoc file to be README.

Okay, now it’s time to build the gem. Open a terminal and go to the folder where your gemspec is. Now type: “gem build commatose.gemspec”, substituting commatose with whatever your gemspec is named.

To install the gem just type: “sudo gem install commatose –local”, once again, substituting commatose with whatever your gem is called.

Uploading your gem to RubyForge

If you’d like to submit your gem to Rubyforge then you’ll need an account, of course. On the Rubyforge website, select “My Page” from the navigation menu. Now click the “Register Project” link. Once you submit your request you’ll get an e-mail telling you that it could be up to 72 hours before you find out if your project has been approved. Fortunately, it only took an hour or two to get Commatose approved.

Once you’re approved, go to your new project page and click the “Files” tab. Click the “Create a new release” link, and fill out the information. It may take a few hours before your gem is fully propagated to all of the gem servers. Once it is, you should be able to find your gem by opening a terminal and typing “gem search Commatose –remote”, with the name of your gem instead of Commatose.

Creating a project page on RubyForge

Next, you’ll want to make sure that you have a project page set up. Projects without a project page have always been a pet peeve of mine.

First, you’ll want to write a basic web page. Nothing fancy, just enough so people understand what your gem does and whether or not it meets their needs. Here’s the one I set up for Commatose: http://commatose.rubyforge.org/

In order to upload the page, you’ll need access to some kind of SCP tool. If you’re on Linux, Unix, or OS X, then you should be all set. If you’re on Windows, then you’ll need to download PSCP.

Assuming your HTML file is named “index.html”, your project is named “my_spiffy_project”, and your Rubyforge login name is “johndoe”; you’ll need to open a terminal and type: “scp index.html johndoe@rubyforge.org:/var/www/gforge-projects/my_spiffy_project/”. If you’re on Windows, then replace “scp” with “pscp”.

You’ll be asked for a password, which is whatever password you use to login to Rubyforge.

Additionally, you may want to upload your RDoc files so people can browse them without downloading the gem. Assuming your RDoc files are in a folder named rdoc, type “scp -r rdoc johndoe@rubyforge.org:/var/www/gforge-projects/my_spiffy_project/rdoc/”. The -r argument makes scp recursively upload all of the files inside the folder, otherwise it will complain that it can only upload regular files.

And that’s it! You have a gem on Rubyforge which can be downloaded via RubyGems. You’ve got some awesome RDoc documentation and a project page with extra information.

Don’t worry if you don’t know how to program in Ruby. The whole point of this article is to prove that Ruby is easy, so you’re the person who needs to read this article the most!

Also, don’t worry if you don’t perfectly understand how the code works. These examples aren’t meant to teach you how to program in Ruby, they’re supposed to get you excited enough to go out and learn!

I’m going to present 3 Ruby scripts, and we’ll examine how they work and what they do. Despite the fact that these scripts are short and simple, scripts just like these have saved me many hours at the office.

Example 1

“Example1.rb” is the Ruby script itself.

example1.rb

File.open("example1.txt", "r") do |file|
  puts file.read.gsub("Dave", "Phil")
end

Even if you don’t know how to program in Ruby yet, take a look at the script and see if you can get some idea of what it does.

Take a look at: File.open(“example1.txt”, “r”)

You probably guessed that it’s trying to read a file called “example1.txt”. If so, you get a biscuit! Let’s take a look at example1.txt to see if that can help us understand what the script is doing.

example1.txt

In the event of an emergency please contact Dave. Dave will log in and fix the problem.

You can contact Dave at: Dave@megacorp.net

It’s a simple text document with some contact information.

Now let’s look at: puts file.read.gsub(“Dave”, “Phil”)

In Ruby, “puts” means “print this to the screen and hit enter at the end”. So Ruby is printing something.

“file.read” seems pretty self explanitory. Ruby is reading the file that we gave it.

“Gsub” stands for “global substitution”. So, Ruby is reading the document and substituting “Dave” with “Phil”. Then it’s printing the result of that to the screen. Let’s what happens when we run the script.

In the event of an emergency please contact Phil. Phil will log in and fix the problem.

You can contact Phil at: Phil@megacorp.net

As you can see, it’s pretty easy to open a file and manipulate the contents with Ruby. Let’s try another example.

Example 2

example2.rb

data_to_sort = []
File.open("example2.txt", "r") do |file|
  file.each_line { |line| data_to_sort.push(line.strip) }
end

puts data_to_sort.sort.uniq

example2.txt

Tom     555-7816
Al      555-9382
Carol   555-4662
Jim     555-1164
Alice   555-4427
Steve   555-7418
Carl    555-1345
Angela  555-3466
Carol   555-4662
Michael 555-8852
Jim     555-1164
Carol   555-4662
Al      555-9382
Carol   555-4662

So, we can immediately see that the Ruby script is reading a file named “example2.txt”.

“Example2.txt” is a list of phone numbers. If you look at the list carefully, you’ll notice that it’s very disorganized. Some people are even listed more than once! Remember kids, friends don’t let friends drink and create contact lists.

There’s also a line that says “data_to_sort = []“. That line lets Ruby know that I want it to remember some information. Specifically, I want to store some information in an array, which is an organized collection of data.

Now look at “file.each_line { |line| data_to_sort.push(line.strip) }”.

Clearly it’s doing something for each line in the file.  So “data_to_sort” is the array I made earlier. “Data_to_array.push(line.strip)” means “push this information into the array”. If you’re curious about line.strip, it’s not there because the line was young and it needed the money.

Each line has a newline character at the end. A newline character is the thing that makes the text drop down a line. There’s no point in storing those newline characters in the array, so strip chops them off (along with any unneccessary spaces at the beginning or end of the line). I like to think of the strip command as the Lizzie Borden of Ruby.

Then we have “puts data_to_sort.sort.uniq”. The purpose of this one might seem clear if you read it aloud to yourself. Seriously, just say it aloud.

Did you do it?

Well, did you?

Really? You did? Ha! You’re so gullible.

Anyway, as we discussed previously, “puts” makes Ruby print something to the screen. We’re telling it to print “data_to_sort.sort.uniq”. “Data_to_sort” contains each line from the file, so when we say “data_to_sort.sort”, we’re sorting the data. Pretty easy, right?

Then we have the “.uniq” hanging out at the end. As you probably guessed, it tells the array to get rid of any non-unique entries. So, here’s what our program outputs:

Al      555-9382
Alice   555-4427
Angela  555-3466
Carl    555-1345
Carol   555-4662
Jim     555-1164
Michael 555-8852
Steve   555-7418
Tom     555-7816

So our program sorted the data and removed the duplicate entries. Not bad for 5 lines of code!

Example 3

example3.rb

File.open("example3.txt", "r") do |file|
  file.each_line {|line| puts line if line =~ /\ba/i}
end

example3.txt

5/13/1978  - Al Pachino had an omelet for breakfast.
9/28/1981  - Archeologists discovered that all Egyptian hieroglyphic writings are actually advertisements for Apple's iPod.
10/2/1983  - Buffoon was born.
1/4/1984   - The U.S. government successfully sent 3 astronauts to Venus, but then realized that they were supposed to go to Mars instead. The dejected astronauts returned home in awkward silence. A massive government conspiracy ensued.
7/3/1987   - The entry for 8/10/1991 was revealed to be false.
11/23/1988 - The greatest scientists and religious leaders of the world finally ended a centuries old dispute and agreed that indeed, Lucky Charms are magically delicious.
3/17/1989  - I invented YouTube and became a billionaire.
8/10/1991  - The entry for 7/3/1987 was revealed to be true.
2/24/1993  - Matz conceived of Ruby (According to Wikipedia).
9/13/1996  - It was discovered that heart disease is not caused by fatty foods and a sedentary lifestyle, but is in fact the result of one Wilber Arbuckle of Spokane, Washington. Mr. Arbuckle promptly apologized and promised not to do it again.

This program is really short. Just 3 lines of code, and we already know what 2 of them do. The one line we aren’t familiar with is “file.each_line {|line| puts line if line =~ /\ba/i}”.

Once again, we’re clearly doing something with each line of the file. That leaves us with “puts line if line =~ /\ba/i”.

So, we’re telling Ruby to print the line to the screen if “line =~ /\ba/i”. Ruby is using what’s called a regular expression here. A regular expression is pretty much like any other expression, but it’s been infused with Metamucil.

No, actually a regular expression is a type of pattern. I’m sure you’ve searched for text in a document before, but what if you’re not sure what text you’re looking for? What if you’re looking for any year between 1921 and 1926? Normally you’d have to run 5 individual searches, but with regular expressions you can search for “/192[1-6]/”. Regular expressions are really powerful, and their uses go WAY beyond the simple examples I’ve given here.

However, the regular expression I used in the program is “/\ba/i”. In Regular Expression-ville, “\b” means the beginning or end of a word. So, “\ba” means find me the beginning or end of a word followed by the letter a. The “i” at the end of the regular expression tells it to ignore casing on letters, so it treats “a” and “A” as the same letter.

So, we’re telling Ruby to print a line from the file if the line has a word that starts with the letter “a”, regardless of case. Let’s see the output:

5/13/1978  - Al Pachino has an omelet for breakfast.
9/28/1981  - Archeologists discover that all Egyptian hieroglyphic writings are actually advertisements for Apple's iPod.
1/4/1984   - The U.S. government successfully sends 3 astronauts to Venus, but then realizes that they were supposed to go to Mars instead. The dejected astronauts return home in awkward silence. A massive government conspiracy ensues.
11/23/1988 - The greatest scientists and religious leaders of the world finally end a centuries old dispute and agree that indeed, Lucky Charms are magically delicious.
3/17/1989  - I invent YouTube and become a billionaire.
2/24/1993  - Matz conceives of Ruby (According to Wikipedia).
9/13/1996  - It is discovered that heart disease is not caused by fatty foods and a sedentary lifestyle, but is in fact the result of one Wilber Arbuckle of Spokane, Washington. Mr. Arbuckle promptly apologized and promised not to do it again.

After seeing these three examples, I think you’ll have to admit that it doesn’t take long to get useful results out of Ruby. You will literally, within minutes of starting to learn Ruby, be able to create useful scripts that can save you a lot of time. You will also become a multi-billionaire. Seriously.

Of course, these examples barely scratch the surface of what Ruby is capable of. In Ruby it’s ridiculously easy to create graphical applications, databases and websites. You can even use Ruby to make video games.

If you’re on the fence about learning to program, or learning Ruby, I strongly encourage you to go for it. If you don’t, I’ll hurt you. Seriously, I track the IP address of everyone who comes to my site. If I find out that you didn’t go and program a whole heap of Ruby scripts after reading this post, I will personally come to your house and ring the doorbell before running away while tittering like a schoolgirl the entire time.