As time goes on, I’ve been able to do a little bit of both and I’ve developed a strong preference for pair programming over code reviews.

With code reviews, you get one or more other persons to review the code you just wrote and feel ready is to be checked in, deployed, or whatever the next step is. These reviews can be very formal or just as simple as a line-by-line walk through the code. The goal is to find any bugs or fixes before the code gets to the next step. This is very analogous to the writer/editor/publisher workflow (kind of like this blog entry). Writer writes the article, editor proofreads, and the article gets published. Programmer writes the code, other developers review the code, and the code gets deployed. It almost seems like the idea of code reviews came out of software methodologies like the Waterfall model. Everything is very sequential and done in distinct stages.

In pair programming, the focus is on developing “good” code the first time around. We do this by having more than one pair of eyes on the working code as it is being written. One person is the “driver” who is writing the code and the other is the guide or observer who is verifying the code being written and thinking of potential improvements. The developers switch roles whenever it makes sense which in many cases causes one developer to immediate use or have to work with the code that was written by their partner. It places emphasis on the idea that two heads are better than one.

Two things come to my mind when I think about pair programming and code reviews. First, code reviews seem to be a just-in-the-nick-of-time fix for finding bugs in code before it goes out the door. The initial development effort as already been completed and now we are evaluating the work. And realistic, this is code we’re looking at. Everyone has their opinion as how things should be structured, design philosophies, coding styles, etc. Many times code review sessions end up focusing on higher level concepts like those previously listed and not on the code itself. These kind of debates are related to decisions that should have been made prior to writing this code. Why are we asking ourselves why we did this this way now after we’ve already spent time and effort to write code for it? And the people part of the code review are not neccessarily the people that will be working with that piece of code.

That brings me to my second thought which is this is all reminiscent of Scrum pigs and chickens.

In code reviews, people sit down to review someone’s code. Everyone has an opinion but not everyone is going to be working with the code on a daily basis. At the time, everyone seems to be involved in the process but there is no vested interest. They are just looking at some code and asking themselves “does this code look good and is it correct?”. It’s a very passive standpoint. On the other hand, pair programmers are completely invested (committed?) in the task at hand. They immediately are using the code they are writing together and collobarating their thoughts on design, code layout, etc. Both programmers are taking on an active role and are emotionally invested in the task at hand because they are attacking the same problem together.

Most of the cons of pair programming can be attributed to developer social/ego issues. And they are not specific to pair programming. Going down the list of drawbacks listed on Wikipedia:

• Developer egos: Experienced developers may find it tedious to tutor a less experienced developer in a paired environment.
• Developer intimidation: A less experienced developer may feel intimidated pairing with a more experienced developer which may result in less participation.
• Developer work preference: Some engineers prefer to work alone, and may find the paired environment cumbersome.
• Tutoring cost: Experienced developers working alone may be capable of producing code that is clean and accurate at the outset, and the additional theoretical gain from pairing might not be worth the cost of an additional developer. This is especially true when producing more trivial parts of the system.
• Potential conflict: Differences in coding style may result in conflict, and personality conflicts can result in one or both developers feeling awkward or uncomfortable.
• Chat sessions: Sometimes employees might talk together too much, straying excessively into off-topic subjects, such as major news events, personal problems, etc.
• Annoying personal habits: Sometimes people can find each other much more annoying when working up close than at separate workstations.

Developer egos, intimidation, work preference, and tutoring costs are things that should be checked at the door. As an experience developer, you should look for opportunities to help your fellow developers to learn and improve their skills. As a more junior developer, the opportunity to take chances and try to prove yourself is one of the best ways to learn and develop better skills. I don’t know about other people but collaborative work environments seem to be a plus. Being able to discuss your ideas openly is one of the best ways to make what you’re building better than it is. As for potential conflicts, chat sessions, and annoying personal habits, these have more to do with personalities and mannerism in the work place. All of this can happen in code reviews as well but the point is being self-aware and respectful of your coworkers is just as important as writing awesome code.

While I’m not against code reviews, I feel that pair programming is better suited to improve both code and team quality.

This, of course, ended up causing me problems. After installing Subclipse and attempting to pull up any SVN history, I get an error dialog box that states:
“Unable to load default SVN client”

Confused, I RTFM and saw that “Subclipse 1.4.x requires Subversion 1.5.0 version of JavaHL/SVNKit”

Seeing the SVN I was running was in fact not 1.5,

  theo@notedpath~ $ svn --version
svn, version 1.4.4 (r25188)
   compiled Nov 25 2007, 08:20:33

I went here, downloaded and installed Subversion 1.5, restarted Eclipse and things are looking good now.

Stupid shiny new things.

This is about me wanting to track the flight status of my parent’s airline that just came in from Cali. Of course I could go to the American Airlines website, which by the way is at aa.com, but that seemed like a lot of work when Google is my default homepage. So I thought I would just type in the flight information and hope Google would give me a direct link to the flight status page.

Google’s response surprised me with the following:

Wow. Thanks, Google!

pats-macbook-pro:~ pat$ sudo gem update

Updating installed gems

Updating RedCloth

Building native extensions.  This could take a while...

ERROR:  While executing gem ... (Gem::Installer::ExtensionBuildError)

    ERROR: Failed to build gem native extension./System/Library/Frameworks/Ruby.framework/Versions/1.8/usr/bin/ruby extconf.rb update

can't find header files for ruby.

Gem files will remain installed in /Library/Ruby/Gems/1.8/gems/RedCloth-4.0.3 for inspection.

Results logged to /Library/Ruby/Gems/1.8/gems/RedCloth-4.0.3/ext/redcloth_scan/gem_make.out

But then I ran into a strange error I had never seen before. gem update would fail when trying to build native extension. It’s been awhile since I setup a rails development environment so a-googlin’ I went.

Turns out the ruby headers don’t come installed with the base ruby install with Mac OS X. These can been found on Mac OS X Install Disc 2 by installing the XCode Tools.

Once installed, all was well!

But now, I want an online solution. I want a service where I can “set it and forget it” to back up any or all the files on my multiple computers. My first stop was at Mozy.com. I downloaded their Mac installer, which had the BETA description next to the download link.

The install and setting up it to start backing up some files was easy. The free 2 gigs for MozyHome is great. But when I really got into customizing what I wanted to back up, I was disappointed. I could not easily place rules to ignore certain files and folders. It was all or nothing. Also, Mozy takes the term “backup” very literally. If you delete the file off your local machine, Mozy will delete the file from their backup servers in 30 days. It is not intended to be used as a file repository. You can’t easily share your backup files either.

This could power SCRUM retrospectives!

The upgrade process:

1. Login machine
2. Execute the command “sudo do-release-upgrade”
3. Answer a few “Do you want to keep this older file or use this new file?” questions.
4. Done!

File this one under “That was easy.”

It’s interesting to see how Google Earth/Maps’s popularity has allowed KML to become the international standard. It will be even more interesting to see how quickly the standard is adopted by many of the geo-visualization products out there. While I don’t think it will be “the HTML of geographic content“, I do think this standardization will open up the market for new products that build/support KML, pushing KML to its limits as we have done with HTML.

Anyways, going through their Getting Started documentation took about 10 minutes. All of the apps are hosted at the appspot.com domain but from the Admin console, it looks like you can have your use your Google Apps domain which is pretty cool.

Check out what I got so far at: http://notes.appspot.com

Open up Terminal

>> defaults write com.apple.finder AppleShowAllFiles TRUE
>> killall Finder

Replace TRUE with FALSE to hide them again.

It’s been almost a year since this tech talk and I still really haven’t seen large adoption of git. However after some painful experiences with Subversion, maybe it’s time to take a closer look at git. git sounds great in theory and design, but in practice I’m not yet convinced there is much value add.For example, the point that a truly distributed system allows you to make commits when you are unwired since the commits only go to your local repository, in my opinion, isn’t much value add. I am never really away from a wireless point or ethernet cord when I intend to code. The internet is just too much of a valuable resource for me to be disconnected when I’m coding, whether it be googling an obscure exception or reading online documentation.

The design of git is kind of reminiscent of what maven2 did for the build process and dependency management, with the idea of local repositories and selecting with distribution repositories you trust to pull down your dependencies.

I like the idea of the network of trust. I think that’s where the big win for git is. If I know a coworker is working on a piece of code and won’t be done until the end of the week, I know not to “trust” their branch until they tell me it’s ready.

git seems to encourage more communication between developers, which is great if the teams are practicing Agile software development. The idea of “Individuals and interactions over processes and tools” really needs to be instilled into the developers for git to work though. With so many branches around, there needs to be more communication between developers as to what features or branches are ready to be merged into the next release branch.

I guess only time will tell if git will be accepted by the masses.

We all thought it would be a showcase of startups around the DC talking about the cool things they are doing. To our surprise it was more of a job fair than a social gathering. However, they had free pizza so I can’t complain too much. Still, it’s refreshing to see there is a startup community in the DC area, where it seems like everyone and their uncle work for the government. Clearspring and Freewebs were both there. I tried out making a widget on Clearspring’s platform and making a web site using Freewebs a while back. Both are very cool companies.

Although the DC area is more of a Government Valley, I wish there were more venues that allow startups and hackers get together around the area.

There are certain known algorithms that have become popular when implementing caches. Given that caches have a finite size (either you run out of space or memory), the cache algorithms are used to manage the cache. These algorithms determine things like how long an item remains in the cache and what gets booted out of the cache when it reaches its maximum size. Wikipedia describes the most efficient caching algorithm “would be to always discard the information that will not be needed for the longest time in the future”. You need to take a look at the data you want to cache before deciding on a caching strategy. Do you need to support random access (the access to the data is uniformly distributed) or sequential access ( you’re interested in large chunks of data at a time)? Is certain data accessed more often that other pieces of data?

Here’s a couple common algorithms:

• Least Recently Used (LRU) – the items that haven’t been accessed the longest get the boot first. This is implemented by keeping a timestamp for all items in the cache. Check out this simple LRU implementation.
• Least Frequently Used (LFU) – the items that are sitting in the cache but have been accessed the least are booted out first. This is implemented by a counter to see how often an item is accessed.
• First In First Out (FIFO) – the item that first entered the cache is the first to go when it gets full. This can be easily implemented by a queue.

Of course, there are projects like EHCache and OSCache out there that have addressed this issue.

OSCache provides a FIFO and a LRU implementation of a cache.

In addition to FIFO and LRU, EHCache provides a LFU implementation of a cache.

Thinking about how these algorithms work, it is easy to see that there are certain cases where using one over the other provides a great advantage. For example in the case of LRU, which seems to be the widely accepted and most used caching algorithm, this cache works great when the majority of the hits come to a very concentrated group of items. This way, most hits, if not all, are retrieved from the cache. However, if there is a large scan of all the data, once the cache reaches its max size LRU will just remove items out on every hit. If the cache can hold a max of 50 items and you have 100 records, as you iterate over the 100 records, the cache will empty out the first 50 records to put in the second half of the records, resulting in lots of add/removing to the cache and 0 cache hits. Algorithms that prevent this from happening, like LFU, are known as scan-resistant.

I was interested in finding if there was some middle ground that gave me the best of both worlds LRU and LFU. It turns out there is.

The algorithm is known as Adaptive Replacement Cache (ARC). It gives you the benefits of LRU as well does a balancing act to prevent data scans from polluting the cache. It does by keeping track of two lists, one for recently references items and another or frequently referenced items. If you read about it, it’s a pretty cool algorithm.

I was excited when I came across this algorithm because I thought it would make such a fine addition as an open source project. And then I discovered it was patented. Apparently, PostgreSQL already went through this exercise and deemed it safer to not use it.

So, now I’m thinking I need a new idea for a project.

The article is pretty much a summary of a survey done by an IT staffing firm. It states that entry-level, 20-something year old employees are the most difficult to manage because they have high expectations from their employer. High expectations like good salaries, bonuses/rewards, and an office. Some pointy-haired boss mentioned in the article said “the problem between employers and the younger generation just entering the workforce can be traced back to the employees’ upbringing or an easier way of life for children in the United States today.”

With condescending statements like that, why would I want to work for you? This sounds like a classic “When I was your age”-ism that creates a crappy work environment.

I’m in the IT industry, I’m a 20-something year old, and I guess you could still consider me “entry-level”. I’m not disillusioned about my place in the industry. I don’t expect you to give me the title of CTO of a Fortune 500 company. I don’t need a secretary and a personal assistant. I do however expect to be paid accordingly to the value I bring the company. Why wouldn’t someone want to be rewarded if they do outstanding work? Not having a reward doesn’t stop me from doing outstanding work. You need to find employees that hold themselves to a higher standard than you do. I personally don’t care for offices but it’s clear that having an door that shuts allows developers to be more production due to less distractions.

Just because I may be an entry-level employee, that doesn’t mean I bring any less value to the employer. What qualifies an employer to treat an entry-level employee as a second-class employee? In the IT industry, where experience seems to be king, I have struggled to understand why that is. Experience is fine and dandy but it only takes you only so far. Raw talent should be valued more. Between 3 rock star 20-something year olds and 3 mediocre experienced 40+ year olds, I will bet on the rock stars every single time.

It sounds to me that it’s not the young IT workers that are disillusioned but it’s the employers. They want rock stars employees without providing any incentive.

Pretty cool technology.

It took me awhile to get setup after rebuilding my slice (I am hosted by SliceHost). Most of the time was spent having to google the commands I had to run and figuring out missing apache modules since this is all new to me. It’s been a good learning experience though

But after 4 hours, I’ve setup the following

• 256mb Ubuntu slice
• apache2
• mysql
• subversion
• php
• ruby/rails

Next steps are to get Java and Tomcat installed, as well as a sample Rails app up and running.

Start at TiECon, May 13, 2006.