The book covers all of the standard programming language basics: strings, classes, arrays, loops, etc. Additionally there are three chapters on more advanced subjects in Ruby: Marshal, Threads, and Dynamic Programming. Ruby on Rails is also quickly introduced in a chapter at the end of the book.

Each chapter includes a Digging Deeper section at the end that goes into more detail, warns about corner cases, or introduces an advanced usage. As someone who already knows Ruby these were the most interesting to read. They are placed inside of their own section to let someone who is just trying to learn Ruby know that they can safely be skipped.

No Starch Press is the publisher behind several fun programming books like Land of Lisp, Learn You a Haskell for Great Good, and the iconic Manga guides. When I picked up The Book of Ruby I wasn’t expecting to encounter the second coming of Why’s (Poignant) Guide to Ruby, but that’s what I was hoping for. Unfortunately, The Book of Ruby does not share any characteristics with that fun intro to programming Ruby and instead reads like an average technical book… dryly. On the positive side, I did find the author’s writing to be clear and easy to follow.

The book contains many examples but they are as contrived as possible. I understand that examples should be as simple as possible so that the reader can easily follow along but there is also a need to make the examples do interesting things to make the book more engaging.

Further, Collingbourne does not make an attempt to explain how Ruby is actually used “in the wild”. This is something that another Ruby author, Russ Olsen, does really well. Ruby has a lot of features so it is important to understand how Ruby programmers actually use Ruby. For instance, even though class variables are available, Ruby programmers try to never use them. This is something I would have liked to know when learning Ruby. However, instead of sharing these tidbits of information from his many years of Ruby experience, Collingbourne stays neutral and presents all of the information without including his opinions.

The one opinion that Collingbourne did share, is that he does not believe code style conventions are very important. This is something I can respect, and actually envy. In my own programming, I consider the time I spend to reformat my code to make it “look pretty” to be a waste. However, I still do it because it drives me crazy not to. If I could flip a switch inside my brain that would cause me to not care about code style anymore I absolutely would.

Overall, I feel like if this had been the first Ruby book I had picked up I would not have fallen in love with Ruby like I did. I am disappointed with No Starch Press for not upholding their unique style. The Book of Ruby does not differentiate itself enough to recommend over the other Ruby titles that are out there.

Compiling

To compile LibTorrent I needed to install the libsigc++-2.0-dev package. To compile RTorrent I needed to install libcurl4-openssl-dev. Both can be installed via apt-get:

sudo apt-get install libsigc++-2.0-dev libcurl4-openssl-dev

Updating .rtorrent.rc

The New Ratio Syntax

This actually has been documented to some extent on the RTorrentRatioHandling wiki page. Unfortunately “The basics” make little sense to me. Here is what I did:

Remove my old schedule command to stop torrents when they reach a certain ratio:

schedule = ratio,60,60,"stop_on_ratio=100"

And replace it with:

# Enable the default ratio group.
ratio.enable=
 
# Change the limits
ratio.min.set=100
#ratio.max.set=300
#ratio.upload.set=20M

My desired behavior is for RTorrent to close a torrent when its ratio reaches 1.0 which is why I am only setting ratio.min.set.

I am extremely curious why the developer decided to make the configuration command to enable ratios ratio.enable=. The equals sign on the end of the line makes the option feel very incomplete and does not make sense.

Deprecated on_* commands

All of the on_* commands are now deprecated.¹ This includes on_start, on_stop, on_finished, and on_erase. I use an on_finished command to move finished torrents to a separate directory which had to be changed.

# deprecated on_finished command
# on_finished = move_complete,"d.set_directory=~/torrents/finished/ ;execute=mv,-u,$d.get_base_path=,~/torrents/finished/"
 
# Equivalent on_finished for rtorrent > 0.8.4
system.method.set_key = event.download.finished,move_complete,"d.set_directory=~/torrents/finished/ ;execute=mv,-u,$d.get_base_path=,~/torrents/finished/"

DTach

On a whim I decided to switch to running RTorrent with dtach instead of inside GNU Screen. My hope is that dtach will perform a little better. Unfortunately when I opened RTorrent with dtach my arrow keys changed my download threshold instead of navigating the list of torrents. A fix that I found is to specify TERM=linux when launching dtach.²

env TERM=linux dtach -c /tmp/rtorrent.dtach rtorrent

Once again I find it why this works to be a mystery but no explanation was given.

Rant

I have a lot of respect for the creator of RTorrent/LibTorrent. He has created an excellent Bittorrent client and backend that I have been happily been using for a couple years. However, I think it is very poor form that he released new updates that change the configuration interface without properly documenting the upgrade path on the website. This was frustrating enough that I tried to update the LibTorrent trac but public accounts are not allowed, blocking my attempt to help.

This year I once again participated in the RailsRumble competition with the goal to build a Rails app in 48 hours. My amazing teammates Arya Asemanfar, Gary Tsang, and Alex Le and I worked together tirelessly to build an application for tracking grocery purchases. The result is Grocery Tracker.

Grocery Tracker

The objective of Grocery Tracker is to make it really easy to visualize how much you are spending on groceries and how your buying habits are changing. For me, it is interesting to see what percent of my grocery purchases are going towards “Snacks & Candy” as well as my historical spending in that category. Grocery Tracker allows me to quickly answer questions like “Am I spending less on snacks now than I was 3 months ago?”.

Start Tracking!

To signup, click “Get Started” on the homepage. Fill out the (poorly styled) registration form to create an account and you will be automatically logged in.

When you login for the first time we create two sample grocery lists for you. The first one has all the ingredients to make a wicked sandwich and the second one is blank. Click on the blank list and play around with entering new items to the list.

After you have entered some data click the “Reports” tab at the top to view graphs of your purchases. The first graph on the reports dashboard is a graph of total spending over time and the smaller graphs beneath display a breakdown of spending by category. The default view is to view a breakdown by day. You may find it more useful to break down your purchases by week, month, and eventually year. To do so, click the respective links in the top right of the page.

iPhone Integration

Grocery Tracker has a minimal iPhone interface for viewing your grocery lists from your phone. This is ideal for reviewing your grocery lists when shopping at the grocery store. We hope to build out the iPhone functionality more in the future.

Alpha, Beta, Gamma?

Keep in mind when using Grocery Tracker that it was developed entirely in 48 hours. Once the deadline passed we were no longer allowed to make changes. There are a few known bugs in the software that we want desperately to fix but are barred from doing so by the rules of the competition. In particular, logging in and out of the application is really rough and you should anticipate strange behavior to crop up.

// place Hello World! on the 'write' buffer
set write, "Hello World!"

Internally, the interpreter is just passing the second parameter, “Hello World!”, to the puts method in Ruby. This makes it difficult to use traditional test/unit assertions to check that the simplesem instruction is working.

I eventually found two solutions for this. The first, suggested by David Stevenson at Pivotal Labs, is to use mocha to check that puts was called on the object.

require 'test/unit'
require 'rubygems'
require 'mocha'
 
class SimpleSemParserTest < Test::Unit::TestCase
 
  def test_set_stmt_write
    parser = SimpleSemParser.new
    parser.expects(:puts).with("Hello World!")
    parser.parse('set write, "Hello World!"').execute
  end
 
end

This solution is fine for most situations; Mocha will throw an exception if puts is not called. However in my case, it was unsuitable because puts was not being called on the SimpleSemParser object but instead on a Treetop syntax node that I did not easily have access to within the unit test.

I knew that if I could capture the output from the puts method into a variable I would be able write the test using a standard assert_equal. After some googling I discovered that this functionality is built into the ZenTest gem. After rewriting the test looked like this.

require 'test/zentest_assertions'
 
class SimpleSemParserTest < Test::Unit::TestCase
 
  def test_set_stmt_write
    out, err = util_capture do 
      parser = SimpleSemParser.new
      parser.parse('set write, "Hello World!"').execute
    end
 
    assert_equal "Hello World!\n", out.string
  end
 
end

This works great. However, should we decided that we do not want to use an external gem, with a little effort we can bypass ZenTest and implement util_capture ourselves.

require 'stringio'
 
module Kernel
 
  def capture_stdout
    out = StringIO.new
    $stdout = out
    yield
    return out
  ensure
    $stdout = STDOUT
  end
 
end

Done! We extended the Kernel module with a method called capture_stdout¹. capture_stdout works by redirecting $stdout to an instance of StringIO. StringIO has all of the IO methods, but acts on a string instead of a file. After changing $stdout we yield to let the caller generate output. Once the yield is finished, we return the StringIO instance and add an ensure to guarantee that $stdout is reset to its default value. Adding capture_stdout to the Kernel module has the effect of giving capture_stdout a global scope so that it can be used anywhere.

With the exception that we that we renamed the method to capture_stdout, and are not returning $stderr, the unit test has not changed from the ZenTest version.

class SimpleSemParserTest < Test::Unit::TestCase
 
  def test_set_stmt_write
    out = capture_stdout do 
      parser = SimpleSemParser.new
      parser.parse('set write, "Hello World!"').execute
    end
 
    assert_equal "Hello World!\n", out.string
  end
 
end

We end with a clean, very readable way to test Ruby methods that generate output without using any libraries.

Today, I finally wrote a basic bash script that automates updating each of the repositories. Sometimes it is surprising how simple an automated solution turns out to be.

Since SIMPLESEM is a made up language that was created just for our textbook, there was no way for me to execute the SIMPLESEM programs that I was writing for the homework assignments. This was annoying because SIMPLESEM is a low level language which makes it hard to notice mistakes. Of course, it is very easy to make a mistake any time you are programming but it is even harder to catch those mistakes if you are working at close to assembly level.

As a fun exercise I implemented an interpreter for SIMPLESEM using Ruby and published it as a RubyGem. Fortunately, I choose to use Nathan Sobo’s Treetop gem to aide in the development. Using Treetop, I wrote a parsing expression grammar to parse SIMPLESEM commands. This resulted in my SIMPLESEM interpreter being a lot more flexible than I had originally anticipated. After I familiarized myself with the basics of writing Treetop grammars I found it very easy to make changes to my grammar definitions to add language features one by one.

Installing the SIMPLESEM interpreter should be easy if you are on Linux or OS X, and possible if you are on Windows. The program is packaged as a rubygem. *nix folks should have rubygems packaged with their system. Windows users should visit the RubyGems page to get running. Once you are setup with RubyGems, install the simplesem gem from Gemcutter:

$ sudo gem install simplesem --source http://gemcutter.org

The gem installs a command called simplesem. To test it out download this sample SIMPLESEM program that prints “hello world!” five times. Run it by passing the name of the file as an argument to the command.

$ simplesem hello-world.txt
hello world!
hello world!
hello world!
hello world!
hello world!

You can view other sample SIMPLESEM programs here. To learn more about SIMPLESEM or the interpreter check out the README.

This jumped out at me while browsing the Apple Store today. The two 13″ Macbooks are practically identical on the inside. The new aluminum version’s hard drive is 40GB larger and it contains the newer DDR3 memory. However they have the same video card and the same CPU. These changes may seem of consequence, but with the falling price of memory components Apple is likely paying the same price or less for the DDR3 memory and 160GB hard drive than they were for the corresponding parts in the white Macbook a year ago. Making the internal enhancements essentially a free upgrade for Apple.

All that remains is the case. Which means buyers are paying $300 for the upgrade from plastic to aluminum. That unibody case is nice but that is outrageous! It is easy to see where Apple’s high profit margins are. And I thought it was bad when they put a $150 premium on the black macbook casing two years ago.

About four years after the education system made the switch to Java from C++, the whole software industry started complaining about the degrading quality of the Computer Science graduates in the US; which is a topic I explored recently. Ultimately, schools have made the switch away from C++, and they are unlikely to go back, nor do I think they should. Instead, what I want to discuss is why did we have to replace C++ with Java? I can see that at the time, it may have seemed the obvious choice, but looking around the language landscape now there are several choices that I think are better suited for the task. Namely, Python.

Java > Python How???

First, I want to really think about what advantage does learning programming with Java have over using a modern scripting language like Python? Python equally hides the things that make programming in C++ laborious and has many of the nice features that the JVM provides like garbage collection, unicode strings, and threads. The difference is Java is miserable for web programming (Java EE) and equally overly complex for building GUIs (Swing). As a scripting language, Python is far easier to pick and learn.

What CS students would lose from switching from Java to Python

• Static Typing – The difference between an Integer and a Float is harder to understand when you do not have to declare variable types.
• Compilation – In my opinion this is not a big deal. They are still going to learn how to debug runtime errors which is where the substance is. Advanced IDEs like Eclipse are making dealing with compiler errors almost a thing of the past in Java. Additionally, the upper division compilers class will still be there to teach them the ins and outs of compilers.
• Performance – This is a moot point. I only put it down because it is what most people think of first but very rarely do the projects assigned in a classroom require serious computation. I would also wager that even the ones that do can be solved in a satisfactory manor with Python. If anything it will force students to be more creative about their solutions instead of just relying on brute force.

What CS students will gain from switching from Java to Python

• Dynamic Typing – There are tradeoffs to both approaches but as nearly everyone who programs dynamically typed language for a while finds out that the type safety provided by static typing is unnecessary and more often gets in your way than it helps you (ex. Casting).
• Interpretation – Becoming familiar with interpretation is just as important as compilation. Interpretation opens several doors for you when programming and is becoming more common. In addition it gives you helpful tools like an interactive console.

Overall, there is no big loss in Computer Science concepts when moving from Java to Python like there was when we moved away from C++. You trade static typing for dynamic typing and compilation for interpretation but everything else is just about the same and you gain Python’s simplicity.

One of the real problems with Java is that many students do not like to use it when programming for fun. Since the majority of students only become competent in Java, they only code they write is for their homework assignments. These are type A CS students. There is a second, type B, group of CS students. Type B students pick up another language like PHP, Python, Ruby, Clojure, etc. and are ones who spend time coding and creating cool things outside of their schoolwork. These students find programming on the side to be the most enriching and also the most educational. Employers often cite type B students, the self starters, as the ones they are most interested in hiring. If the only programming a student does while attending school is for their class projects, it is more than likely that they will continue this practice once leaving school, only writing code for their job. By making the switch away from Java in education, more type B CS students would emerge from American universities; enormously benefiting the software industry.

My resolutions for 2009:

1. Take on fewer projects. I have a tendency of getting involved in just about everything. Too often I eagerly say “Yes” to a for-fun project, contract, or job without really thinking about whether I have the necessary amount of time to devote to the project to make it a success. For a few months I need to instantiate a “project-freeze” until I can bring some closure to the myriad of things currently clogging up my to-do list.

2. Look at where I am spending my time and decide what is truly important. Stop spending my time on the things I think are important but really aren’t. I just finished reading the book Predictably Irrational by Dan Ariely. The eighth chapter is titled “Keeping Doors Open: Why Options Distract Us from Our Main Objective”. In the chapter Ariely explains how people have this irrational behavior to keep as many options available to them as we can. Even though this behavior diverts our energy and commitment away from the doors that should be left open and that we are better off when we close as many doors as we can and focus on the ones that are the most valuable. For most people, including myself, deciding which doors are the most beneficial is a not easy because, as Ariely states, some doors are tied to my dreams or contain the promise of leading to a better career. Therefore I need to be rigid in closing doors if I really want to focus on what is important.

3. Get better at finishing what I start. Since I have been starting too many projects in the last year and getting involved with too many things, I have fallen into a really bad spell of not finishing many of the various projects that I start. By spreading myself too thin I have become ineffective as a programmer. But I believe that if I am able to stick to my first two resolutions, then finishing the things I start will follow.

4. Exercise with Wii Fit on a regular basis for the entire year. I am not overweight or out of shape so when I say that I need to exercise it is not to lose weight. Instead I want to see how my body will improve if I do exercise regularly. And I say exercise with Wii Fit because that is the only method of exercise that is convenient enough (I don’t have to leave my apartment) for me to do it for a prolonged period.

Since July I have been using an application called RescueTime to track my computer usage habits. It records how much time I spend using each application and visiting websites. This information is useful for me to monitor how much time I am blowing on Twitter and how much of my 8+ hour work day (when I was working) I was actually spending on programming.

One of the features of RescueTime is that it lets me set efficiency values between -2 and +2 for my Apps. So for example, I marked TextMate as being +2 efficiency, Adium and Skype as -1 efficiency, and Facebook as -2 efficiency. Then RescueTime aggregates all of my usage data, and generates an overall Efficiency Score based on the efficiency values I assigned. If my overall efficiency score is above 0 than I have been productive, if it is below 0 than I have been generally unproductive.

So far I have assigned all of my “most used” applications and websites and efficiency value…except for my email client, MailPlane. When it comes to rating the efficiency of my time spent writing and reading emails I am conflicted. While email is necessary to getting many things done, it is a lot of time not spent working towards my main objective which is programming.

Writing emails is what particularly kills me as it consumes far more time than reading emails does. Writing good emails that provide actual value is difficult and I can easily spend 20 minutes writing and rewording an important email. If the amount of email I dealt with was low this would obviously be less of an issue but I estimate that I send an average of 40 emails every week, half of them being during the weekend.

I know that this amount of email writing is nothing compared to what many people deal with but for a college student who writes code on the side, writing 40 emails every week is a significant time sink. According to RescueTime, I have spent 110 hours using my email client since RescueTime started monitoring on July 21st. Making it my most popular application (Adium is second, followed by TextMate).

So the problem I am left with is, how do I rate the efficiency of a necessary evil? I can not stop writing email because then I would not be fulfilling my other responsibilities, like my role as ACM President at UCI. If I give MailPlane an efficiency rating of +1 than time spent writing emails is going to boost my overall efficiency score so that even if I’m not writing any code RescueTime is still going to tell me I have been efficiently using my time. If I rate it negatively and give MailPlane a rating of -1 than I am never going to be able to dig myself out from negative territory on the overall efficiency scale. I already have Adium, VLC, and Facebook bringing me down enough as it is.

In the end, I feel that 0 is the most appropriate efficiency rating for a necessary evil. Thus it does not hurt you to be doing it but it does not help you either. I think a good solution would be for RescueTime to add a goal type where I can specify that on any given day, my goal is to use TextMate for longer than I use MailPlane. RescueTime deals in tags and categories so really it would be to use things tagged “dev” for longer than things in the “Comm (Email)” category but it is the same principle. That way I can challenge myself to spend more time writing code than emailing without having all my other activities interfere.