Calamity Lane - All

Finally! Photos!

2008-02-25T03:46:00Z

My sincerest apologies to all our family and friends who have been waiting for pictures of the new baby! Here are a few to whet your appetite: You can look at the whole batch of 30 photos as a slideshow here.

The Votes are In...

2008-02-13T04:39:00Z

…and his name is…

Benjamin Paul Alexander Budd!

Thanks go out to everyone who participated in our survey. Pics of the most awesome baby in the universe will be available shortly. :)

How to tell when your wife is way cooler than you...

2007-12-03T03:10:00Z

Yes, that's Michelle's actual score. Yes, it makes me sad. (Confused? This may help.)

How to tell you've been spending too much time in front of the computer...

2007-11-30T06:06:00Z

Would you like to name that Budd?

2007-10-01T03:03:00Z

Take the survey: <iframe allowtransparency="true" title="HTML Form" src="http://namethebudd.wufoo.com/embed/nameabudd/" frameborder="0" height="575" style="width:100%;border:none" scrolling="no">Fill out my Wufoo form!</iframe> Powered by Wufoo

How good is your cooking?

2007-09-23T05:54:00Z

Are you this good?

That's right. I made a PBJ sandwich so bad that the jar of peanut butter immolated.

It was actually kind of tasty, afterwards. It's no coincidence that Michelle does most of the cooking.

Pictures of the New House

2007-05-02T03:06:00Z

Our first home. :)

Them what deals with th' Devil...

2007-04-27T04:26:00Z

With my recent spate of GServer problems, I thought I’d post something that, surprisingly, turned out not to be much of a problem at all: turning a Ruby GServer into a Windows service.

First, it helps tremendously if you already have Cygwin installed. If you don’t, you should, as you get lots of UNIX-y command-line goodness (for example, a “Find In Files” functionality (grep) that actually finds stuff in files. Uncanny!)

I’d used Cygwin’s “cygrunsrv” to run Cygwin’s SSH server on Windows, because I love SSH and it seemed like a good idea at the time. I didn’t realize you could use it to create service out of arbitrary programs. With the following command (broken up for readability):

cygrunsrv /
           --install "Bill Gates is Reading My Source Code Service" /
           --path c:/ruby/bin/rubyw.exe /
           --args c:/Projects/source_viewer/source_viewer_server.rb

…you can be running your server under your very own Windows service! (Pardon me while I run and gargle with some bleach.)

Basically, you just need a name, the path to your Ruby executable, and the path to your application, and you’re good to go.

Notice here that I’ve used “rubyw.exe” which is a “windowless” version of Ruby. It does not try to open Window’s crippled console, but runs strictly in the background, which is nice if you want to launch a server from a windows shortcut without distracting little black screens popping up. I have no idea if this helps any, but I figured it couldn’t hurt (famous last words).

One other important thing to be aware of is that Windows does not respond to standard system signals, so you will need to add the following method to your server class (as seen here):

 def trap(signal)
   Kernel::trap(signal){yield} 
   Thread.new{loop{sleep 1}} # Stupid Windows...
 end

This lets you stop the service from services.msc– if you don’t have this, chances are good that the whole thing will hang when you try to stop or restart your service.

There are a number of other (probably better) methods to turn programs into Windows services, but this one was quick, easy and served my needs well.

More GServer Goodness

2007-04-16T00:52:00Z

In a previous posting, I mentioned that you could create a telnet server from a Rails application. After having actually pushed a small GServer-based app into production, I can add a few notes to it:

ACCESSING YOUR SERVER REMOTELY

This one took way too long to figure out. Every example I’ve seen online (even the library documentation) will only let you connect from localhost, which seemed even more exceptionally pointless than the stuff I usually do. Most of the sample code runs along these lines:

require 'gserver'

class SomeNewServer < GServer
...
end

server = SomeNewServer.new 1234
server.start
server.join

…where “1234” is the port used to access the server. With this setup, you simply cannot access the server from another box, period. Change the following line:

server = SomeNewServer.new 1234

…to:

server = SomeNewServer.new 1234, 'myserver.example.com'

…to make your new server accessible to the outside world. You can use an IP address in place of the domain name.

On the one hand, I was able to just guess at this parameter, and Ruby’s Principle of Least Surprise came through for me. It’s more secure, as you don’t have to worry about accidentally exposing a massive security hole on your box during development. On the other hand, it would have been nice to have it clearly listed out somewhere. Here’s hoping that this saves some future googler a guessing game.

Introducing Harley Quin

2007-04-12T02:46:00Z

Well, we finally got a new pet!

It took us a while to get past the grief of Nanako’s passing, but we finally felt ready to get another kitty. We searched petfinder.com and made a list of about 20 cats who were just unbelievably cute! Then, we ran into problems. We couldn’t possibly have 20 cats! All we needed was one, maybe two! So, we tried to cull. But really, how can you cull out the cutest little pair of kitty eyes in the whole world? Much less 20 pairs?!

It just wasn’t working. We had too many options! So, to limit ourselves, we decided to head on down to the Petco on a Saturday afternoon to check out the kitties they had for adoption. Surely that would make everything easier! We’d only have 10 pair of cute little kitty eyes to decide from! Not to mention kitty paws and tails and meows and purrs…oh, dear!

Full of excitement, we drove out, walked through the store to the adoption area, looked inside…and saw dogs. Not cuddly little kitties….yipping puppies! We were a bit disappointed, but I wanted to get some petting action in while we were there. I love to cuddle animals!

Perhaps we were in trouble from that moment. The first couple of dogs were a bit hyper. They were all jumping tongues and squirms of excitement. They were cute, don’t get me wrong, but we wanted a kitty. We were just in there to pet!

The next dog in line was a big black lab mix who did NOT like men. Eric couldn’t get close. The poor puppy! I mean, what could have been done to the poor baby to make him just hate and fear men like that?!

Next one was a black and white dog who was laying there sleeping. I bent down to pet him, and he only looked up at me with these tired friendly eyes and lay right back down. He had the most amazing coat! All soft and thick. He was a cutie! Apparently, he had been playing with the beagle puppy being kept next to him and had been plumb wore out! They told us his name was Jester.

We moved on to the remaing two dogs (the beagle next to Jester was in the process of being adopted) and left the adoption area. But I just couldn’t get Jester’s awesome coat and laid-back attitude out of my head. He had been awesome! And the more I thought about him, the more I wanted to bring him home.

I admit it…I bottom-lipped and sad-eyed Eric into getting him. LOL Of course, we still had to get through the adoption process.

We had attempted to adopt from the Humane Society once before and were turned down rather rudely. They claimed there was too much “in and out” of animals for their liking. They based their decision on the information we listed in one particular section of the application. In this section, we were asked to list the animals we had owned in the previous 10 years, so to establish ourselves as experienced, qualified pet owners, I listed 4 animals:

My cat Whiteface who died of old age at 13 years
Mom’s cat Son who died at the age of 11 after being attacked by coons who got into the yard
Kitty Kat, my mom’s dog who died at 8 or 9 quite suddenly (we never really knew what happened to him)
Eric’s cat Ichabod who had to be given back to his original owner when he moved

I really don’t understand how that qualifies as too much “in and out” of animals. We were very upset and the memory made us anxious about this adoption process through the Friends of Parkville Animal Shelter.

If anyone would like to adopt an animal, PLEASE go through FOPAS! They obviously love the animals they care for! We were so very impressed with how efficient and nice everyone there was! The adoption process, though not a breeze of course, was so refreshingly well-handled! They were inquisitive without being prying. They were concerned without being condescending. I truly urge anyone in the Kansas City area to adopt from them! We’re thinking of getting a kitty next (after summer classes with Harley), and we’ll definitely be getting our kitty from them!

So, we now have a very cute dog who we renamed Harley Quin.

Next exciting episode:

HOW CAN ONE DOG STINK SOOO BAD AND STILL BE SOOO CUTE?!

Harley Quin the Amazing Wonder Dog

2007-04-10T03:33:00Z

Amazing in the sense of not exactly being the brightest bulb on the tree…

…but making up for it with cute!

Multi-line strings in Ruby-- I Love Carriage Returns!

2007-04-10T03:32:00Z

If you’ve ever done any serious development in VB or the old VBScript, you’ve probably done something like this:

strSQL = "SELECT o.* " & _
         "FROM people p " & _
         "INNER JOIN orders o " & _
         "ON o.person_id = p.id " & _
         "WHERE person_id = " & PersonID & ";"

…which is highly readable, but a huge pain to debug, especially when trying to cut-n-paste into the query window. How many of us have learned BkSp-BkSp-BkSp-Down-End-repeat-ad-infinitum? In fact, if you were to take every ‘” & _’ and ’ “’ I’ve ever deleted and stack them up on top of one another, you would probably end up with a stack… well, several inches high. Let’s face it, electrons just aren’t that big.

Fed up with this state of affairs, many of us moved to C# for development, leading to:

strSQL =        "SELECT o.* ";
strSQL = strSQL + "FROM people p ";
strSQL = strSQL + "INNER JOIN orders o ";
strSQL = strSQL + "  ON o.person_id = p.id ";
strSQL = strSQL + "WHERE person_id = " + PersonID.ToString() + ";

In the computer industry, this is called “progress.”

Of course, if you wanted to make debugging simpler, you could stuff the entire string on one line:

strSQL = "SELECT o.* FROM people p INNER JOIN orders o ON o.person_id = p.id WHERE person_id = " + PersonID.ToString() + ";"

…which is a lot easier to cut-n-paste, but a lot less easy to read.

Which is where Ruby comes in. Same query in Ruby:

strSQL = "
    SELECT o.*
      FROM people p
      INNER JOIN orders o ON o.person_id = p.id
      WHERE person_id = #{person_id.to_s};
"

Isn’t it bee-yoo-tee-ful? Readable, functional, and oh so copy-pasteable. Also, it does not require extra punctuation to patch together a simple multi-line query.

There are about 19,000 different ways to define a string in Ruby, but it’s the simple timesavers like this that make the language really shine.

Of course, if you were using Rails, you could just

Person.find(person_id).orders

…which just goes to show how much smarter and more sexually attractive Railers are than everybody else.

NOTE: Originally, I was going to include connection and execution of the query, but that would have blown the VBScript and Ruby examples up an extra four lines of code each. Using recommended practices, it would have bloated the C# code up another 15 lines, plus a stored procedure definition.

The Rails example would still have been only one line. Simplicity ftw!

How to Turn a Rails Application Into a Telnet Server in 30 Lines of Code!

2007-04-10T03:30:00Z

Ruby on Rails is a beautiful thing; simple, fast, and powerful. As they say, it takes the pain out of web development.

I’m fortunate enough to have been able to use Rails at work for a few months now, and the more I learn about the Rails framework and the Ruby language, the more enamored I become of the simplicity, beauty, and zen-like nature of these tools. But you didn’t come here to see me gush with adoration like a schoolgirl at an Elvis concert (I hope), you came to see:

How to Turn a Rails Application Into a Telnet Server in 30 Lines of Code!

Ruby on Rails is a beautiful thing; simple, fast, and powerful. As they say, it takes the pain out of web development.

How to Turn a Rails Application Into a Telnet Server in 30 Lines of Code!

First, some code:

#!/usr/bin/env ruby
require 'config/environment'
require 'gserver'

class TestServer < GServer
  def serve( io )
    begin
      io.puts ">> WELCOME <<"
      loop do
        begin
          telnet_input = io.gets
          break if telnet_input =~ /\Aquit\b/
          io.puts eval(telnet_input)
        rescue Exception
          io.puts "Oops - " + $!
        end
        log "Rec'd " + telnet_input
      end
      io.puts ">> GOODBYE <<"
      io.close
    rescue Exception
      puts "OOPS - " + $!
      raise
    end
  end
end

ts = TestServer.new 1234
ts.start
ts.audit = true
ts.join</code></pre>

<p>This code should work, as is, on just about any Rails application (as far as I’ve been able to tell; it’s worked on the few I’ve tried).</p>

<p>Last night I was tooling around, playing with code. I’d had an idea for some server software I’d like to write, so I mocked up a quick throwaway system in Rails, and started playing around with some of the logic. I liked the results, and I’d already decided I wanted to write the server in Ruby, but the thought of taking all that functionality and porting everything to DBI calls or whatever was handy just made me tired, especially since Rails does all of the tedious database tasks for you.</p>

<p>Fortunately, I’m slowly learning that Ruby is written for lazy programmers, and after a little googling and some educated guesses, I was able to whack the entire Rails app into a script simply by including:</p>

<pre><code>require 'config/environment'</code></pre>

<p>…at the top of a file in the project root. This makes everything available (so far as I’ve been able to tell) to your application.</p>

<p>For a piece-by-piece analysis:</p>

<pre><code>#!/usr/bin/env ruby
require 'config/environment'
    require 'gserver'

class TestServer < GServer
  def serve( io )</code></pre>

<p>This sets the scripting environment, includes the Rails app, and makes the “GServer” class available. GServer is a freebie that comes with Ruby, so there’s no need for gem installs or other libraries. We’re then creating our own class which inherits from GServer, and overriding its “serve” method.</p>

<pre><code>      io.puts ">> WELCOME <<"
      loop do
        telnet_input = io.gets
        break if telnet_input =~ /\Aquit\b/
        io.puts eval(telnet_input)
        log "Rec'd " + telnet_input
      end
      io.puts ">> GOODBYE <<"
      io.close</code></pre>

<p>This is the heart of the server (note that I’ve left out the exception handling for readability). Simply speaking, the serve() method is what handles user connections, and the “io” object lets us do gets and puts across the wire.</p>

<p>When a user connects, we spit out a welcome message, then go into an endless loop that responds to user requests. The following:</p>

<pre><code>telnet_input = io.gets</code></pre>

<p>…grabs whatever line the user types in. This line:</p>

<pre><code>break if telnet_input =~ /\Aquit\b/</code></pre>

<p>…kicks us out of the loop if the user types “quit”. Note that I’m using a regex instead of a static string because io.gets() returns the linefeed that the user types in, and this was an easy way to cheat out the functionality. The “\A” portion of the regex matches the beginning of the string, and the “\b” matches a “word boundary” character, in this case, the linefeed.</p>

<pre><code>        io.puts eval(telnet_input)
        log "Rec'd " + telnet_input</code></pre>

<p>The first line here does an eval() on whatever the user typed in, returning the value back across the wire. This should allow the user to run any command that Ruby (and your Rails app) will accept. The second line spits whatever the user typed in to the console where the server is running.</p>

<pre><code>      io.puts ">> GOODBYE <<"
      io.close

Once the loop is broken, we burp out a fond farewell and cleanly close the connection.

ts = TestServer.new 1234
ts.start
ts.audit = true
ts.join

The rest of the code just sets a few variables and kicks on the service. The “1234” on the creation of the “ts” object sets the listening port. Turning on auditing allows us to see when someone logs on and off from the console (which can be redirected to a log file).

CAVEATS:

This is an extremely simple server. It has no security, no performance optimization, and probably has more holes than a cheesecloth factory. It is very naive, and while it technically allows multiple users to log on, they’ll all share the same class variables. Really, it’s only interesting at this point to show that it can be done.

That having been said, the ease with which it was accomplished is one of the many testaments to Ruby’s power and simplicity. I’ve been programming for many years, coded a number of servers, and this was the first time I’ve ever felt drunk with power after a coding session. “I can do anything!” I bellowed as I reeled around the room, knocking old monitors and dusty programming tomes off the desk. “No one can stop me!” Fortunately, my wife, who is a lot more level-headed than I am, pointed out that she could, indeed, stop me, since it had gone past two in the morning.