There are two bad habits in car drivers that I find quite annoying: not pulling into the intersection and not signaling turns.  The two in combination can dramatically reduce the throughput of an intersection.  Unfortunately, one of those intersections is between our house and the train station.  Most of the time I walk to and from the station, so this does not affect me.  The few times that I am in a car, however, also tend to be the ones that I am in a rush so this winds up being especially annoying.

It also happens to provide a wonderful real life illustration of why performance of web services often sucks as they try to scale.  Back to driving first.  The intersection does not have dedicated left turn lanes. So when a car wants to turn left, it has to wait for an opportunity to do so.  Oncoming cars signaling to turn left (and even right) provide an opportunity for a left turn.  Oncoming cars going straight do not.

Here is what should happen: First, a car that wants to turn left should pull all the way into the middle of the intersection thus making it possible for cars behind it that are trying to go straight or turn right to get by.  Second, oncoming cars that are turning should signal, so that the car that is in the intersection can make its left turn in front of them. In the approximately 30 seconds that the light is green this strategy – based on observation – allows 2 cars to turn left and another 4+ cars to go straight or turn right.   Altogether coming from one direction 6+ cars can clear the intersection.

What actually happens, most of the time, is unfortunately entirely different.  The left turn car does not pull into the intersection thus blocking all cars behind it.   The oncoming cars don’t signal so the left turn car stays put.  As the light turns yellow and oncoming traffic starts to slow down the left turn car finally makes its turn.  Nobody else can go and in the worst case (the left turn car is the first car in line) the throughput of the intersection has been reduced to just 1 car!

Now let’s take a look at wait times.   Even during peak commute times there are never more than 5-6 cars arriving at this intersection per minute.  If drivers pulled into the intersection and signaled reliably, the max wait time at this intersection should be sub 1 minute, which is about the cycle time of the traffic light, with averages below that.  But with the actually observed behavior at peak times it is not uncommon to have 20+ cars waiting at this intersection and I have seen wait times up to 5 minutes!

So much for my rant about bad driving.  What does this mean for designing systems?  Well both “pulling into the intersection” and “signaling a turn” have analogies.  “Pulling into the intersection” is effectively creating a miniature left-turn lane.  The idea behind a left-turn lane is to create a separate queue for items that take longer to process.  This is a good idea in systems design also.  If you are processing items where you know that some items will take a lot more time than others (or have high variability in processing time), then try pushing those into a separate queue.

The proper analogy for “signaling a turn” I think is the sharing of resources.  Without turn signals, the oncoming traffic is essentially locking up one entire side of the intersection.  This is the equivalent of a dedicated circuit in telephony compared to a packet-switched network.  Or a web server busy waiting in multiple threads for the backend to return data to it (and maybe holding many separate database connections).  So as a system scales and performance becomes more important, thinking about which resources can be shared more effectively becomes very important.

Would love to know if others agree with my characterization of the system design analogies.  Also would love to know if anybody else share my frustration with these two bad driving habits!