by A while back I decided [Learning to Code|:node/1192] in Ruby would be a good idea and it was suggested that I blog about the process. I got off to a good start, I made my declaration and I posted my first blog entry. I then found some online resources for learning ruby (I must say, [‘Why’s (Poignant) Guide to Ruby’|http://poignantguide.net] is odd yet strangely entertaining), installed ruby on my linux desktop at work and played around with irb for a bit while working through Why’s poignant guide. Feeling flush with excitement and buoyed by a strong sense of accomplishment (perhaps I exaggerate a bit) I thought I should write another blog post explaining why I chose ruby over other possible languages. I set about writing a fairly long blog post about what I wanted from a language and how well I thought different languages fit the bill. I was just about ready to submit, when an errant mouse click sent all of my work to a virtual /dev/null…. My bubble burst, I left work to pick up my son.
In the time since my first post, I haven’t become a Ruby guru, but I have made some progress. I’ve purchased a couple excellent Ruby books and I have actually written a useful script(!).
I spent about 4 hours at a book store going through their collection of books on Ruby. I took notes about what I liked and didn’t like, compared quality of the indexes, looked at presentation style, etc. As with most of my projects, I was pretty systematic about it. I ended up with two phenomenal books: [Programming Ruby: The Pragmatic Programmer’s Guide|http://www.pragmaticprogrammer.com/titles/ruby/index.html] and [Ruby Cookbook|http://www.oreilly.com/catalog/rubyckbk/].
Now, even with ruby installed, ready access to irb and two great books, I was finding it difficult to get over the hurdle of writing my first Ruby script that wasn’t “Hello, World!”
Work has been nuts for a couple months now and, until recently, I just kept falling back to what was quick and comfortable – my rudimentary shell scripting skills. We have been enduring (still are) a billing system conversion that hasn’t been going smoothly. What finally pushed me to write something in Ruby was a visit from our, obviously frustrated and looking stressed, controller. The poor guy had been pulling his hair out over this conversion and had just come to the realization that the new vendor had not pulled out years worth of credit history related to accounts that had been sent to collections. By this time the plug had been pulled on the old system (we were paying a monthly fee and just didn’t want to keep paying for two systems in parallel) and all I had left were database dump files. I could see this was a good opportunity for me to get my feet wet with Ruby as I couldn’t see how I would quickly hack a shell script together.
Given my neophyte status as a Ruby programmer, I was quite surprised how easily the script came together. I think the hardest part was getting my head around object oriented concepts and the new syntax. Once I started to understand the “Ruby way” I started to really enjoy working with the language. Here are a couple of my favorite discoveries thus far:
!Iterator methods
Its great to be able to loop through an array or hash without having to find the length of the array and then increment or decrement a counter within a for or while loop. I liked being able to do something like this:
hash.value.each do |variable|
end
!Creating new classes to store information rather than trying to create nested data structures
In my shell scripting, I had never built an in memory data structure of any complexity. I had seen a perl programmer friend build a nested data structure in Perl and it looked a little daunting. Rather than attempt what I had seen done in Perl, I learned about creating classes. I ended up creating a class to hold all the data for each account I was processing and then stuffed each object into a hash using the account number as the key. The great thing about doing this vs stuffing an array into each hash value is that it made it easy for me to reference the particular account attribute I needed by name rather than it’s position in the array. As a result I was able to do this:
# Iterate through the results_list to see who should be included in the collections report
results_list.values.each do |acct|
# if there is no ‘write off balance’ then skip to the next value in the results_list
next if acct.ar_amount.nil?
if acct.rw_amount.nil? or acct.ar_index < acct.rw_index
amount_owing = ( acct.ar_amount.to_f * -1 )
date = acct.ar_date.to_i
if ( date > cutoff_date ) and ( amount_owing > collect_threshold )
open(collections_report_file, ‘a’) do |outfile|
outfile.puts “#{acct.accountnum} #{date} #{amount_owing}”
end
end
end
end
FYI, looking at this now, I can see that the way I went about writing to the file was not the most efficient. I really shouldn’t have continually opened and closed the file on each pass through the loop. I could have opened the file outside the loop and closed it once the loop exited. Oh well, it worked.
I also could have used an array for storing my account objects because I ended up just iterating through each object and didn’t make use of the hash key. When I created the hash I thought I would be making queries for specific account numbers, but it didn’t end up working that way. I guess this is what re-factoring is all about 🙂
!I’m over the hump!
What a relief! I’m over the hump! This seemed like a big first step – like the first time I rolled over a log on my mountain bike. Now that I have some confidence in my ability to build something useful in a reasonable time frame, I know it will be easier to reach for Ruby the next time a challenge arises.