Hardware Upgrades for Developers

A little while ago I noticed my MacBook was becoming a little laggy. Opening applications seemed to have gotten slower, and switching between applications was often the cause of several seconds of waiting. Furthermore whenever my backup program starting doing it’s thing the machine would start swapping and everything would become extremely sluggish. Given that this was all breaking up my workflow I decided that I needed to upgrade.

Initially I looked at buying a new 13” MacBook Pro, but for the extra expense the only place where it had a clear advantage over my current 13” Aluminium Unibody MacBook was in the battery life, which wouldn’t solve my performance issues.

That led me to think about solid-state hard drives. Many people have become strong proponents of them over the last few years as they have matured as a product. I also wondered how an SSD would fare against a simple RAM upgrade in terms of seeing better performance in day-to-day use, so I decided to document the results of each step of the upgrade so other people could use the information to make choices for themselves.

The original hardware:

Late 2008 13” Aluminium Unibody Macbook (Model: MacBook5,1)

2Ghz Core 2 Duo
2Gb DDR3 PC8500 RAM
1066Mhz front-side bus
120Gb 5400RPM HDD

The upgrade options:

6GB of DDR3 PC8500 RAM in 2 DIMMS: 1x 2GB, 1x 4GB

Note: while I did all the tests with the full 6GB of RAM, I ended up taking out the 2GB DIMM and just going for 4GB total. This is because 6GB of RAM in this machine is unsupported and was causing issues when the computer went to sleep.

50GB OCZ Vertex 2 SSD

This is an insanely fast drive even by SSD standards, but it was primarily chosen for it’s controller. The Sandforce controller in this drive implements on-drive garbage collection that helps minimize performance degradation due to OS X’s lack of TRIM support.

Testing methodology:

I can’t pretend to be an expert on statistics, so I basically approached the problem of benchmarking the upgrades the same way I would when profiling a software system. I wrote a series of automated benchmarks (the complete code for which can be found here: http://gist.github.com/603332) and then I did a series of runs of the tests. After each run the machine was restarted. The test suite was run 4 times for each separate part of the upgrade process. The tests involved were as follows:

SQLite3 Torture Test: Create a new SQLite database, create a new table called ‘books’ with one varchar(256) field and one text field, then write 10,000 rows containing approximately 715Mb of unique data to the database. Fetch all this data back out of the database.
Rails Test: Create a blank Rails 2.3.5 application, create 6 basic scaffolds, migrate the database and then run the generated test suite.
Ruby Unit Tests: Run the test suite for ruby-tmdb
Ruby 1.9 Compilation Test: Compile Ruby 1.9 from source
Application Launch Test: Launch a number of popular application using open -a "application" and then quit them.

Results:

In order to make the results easier to understand the next chart shows each benchmark as a percentage when using the original setup as a baseline:

Conclusion:

From the charts it’s fairly obvious that a lot of my development-specific tasks are actually CPU bound, however the actions that bind these tasks together (like opening, closing and switching between application, etc…) are definitely sped up by the extra RAM and the SSD.

After spending a week or so with the upgraded machine I consider both the upgrades money well spent. I haven’t seen any noticeable lag when launching applications or changing between open applications, no matter how heavily I am loading the machine. Bootup and shutdown are also so fast now that it’s almost as quick to do a reboot as it used to be to put the machine to sleep and then wake it up again. Wake ups from sleep are now instantaneous.

Upgrading to an SSD is something I think most developers should look at these days, the difference is certainly very noticeable for the day-to-day parts of our job, even if it doesn’t have a significant effect on things like compilation time.