Steve Smith's Blog

Search Trends October 2008

ssmith — Wed, 08 Oct 2008 02:30:31 GMT

PDC is fast approaching and Cloud Computing is the theme - and all the rage for everyone else in the Industry media. Amazon recently announced they'll be extending their compute cloud to support Windows and real databases. Here's a look at some recent trends in the tech industry, using Google Trends.

Daylight Savings Time

The topic of DST is likely of at least marginal interest to most software developers, as working with DateTime constructs is a frequent requirement for us (and often a source of frustration). I wanted to confirm when it was this year and that led to the rest of these trend searches (I once missed a flight due to a change in the date of DST that my alarm clock's auto adjustment failed to pick up). FYI: Daylight Savings Time in 2008 will Fall Back the first Sunday in November.

Interesting (and expected) that twice a year folks become interested in this topic. Note that the main regions who care are US, Canada, Australia, and the UK. Most of the world doesn't observe DST. And contrary to what I thought I knew, Ben Franklin didn't invent DST and it only started in the early 1900s (according to the Source Of All Knowledge: Wikipedia).

Cloud Computing

If I were a betting man, I'd bet on cloud computing to be a big upcoming trend in the next several years. It first hit the search term scene a little over a year ago, and it's gone up rather drastically since then. I'd look for it to peak in November this year after PDC and then to plateau or rise gently after that.

Amazon's S3 and EC2 services have been around for a while - let's see how Microsoft compares thus far.

Amazon Cloud vs. Microsoft Cloud

I'd say Microsoft is going to catch and surpass Amazon by PDC time.

Looking at another Microsoft event and announcement, let's see how Silverlight is doing in terms of interest.

Silverlight

Silverlight is still going strong. I predict it will go up steadily once Silverlight 2 is released, slated for later this year and most likely at PDC, I would say.

So what about hosting? Is anyone looking for cloud hosting solutions? Compared to what? Let's look at two comparably small sets of terms.

Cloud vs. Ruby Hosting

Cloud hosting didn't exist as a trend before 2008 Q3 and now it's nearly as popular a search term as ruby hosting. Clearly Ruby Hosting isn't all that popular, but just how does it compare to say ASP.NET and PHP?

Ruby vs. ASP.NET vs. PHP Hosting

Clearly the trends for all three of these are heading downward, as I think the hosting marketplace has largely shaken out and become somewhat commoditized. With sites like GoDaddy offering cheap hosting along with about a million easy to use web publishing and blogging platforms, the need for hosting is obviously in decline.

So what else is new? What about ASP.NET? Remember when it was Atlas? And what about this new jQuery thing that's not really new but is now going to ship with Visual Studio?

Atlas vs. ASP.NET AJAX

... and jQuery

How about data access technologies? Would it surprise you to learn that NHibernate has been a search trend since late 2004, with greater popularity than either LINQ to SQL or Entity Framework's high water mark since 2006 (that is, NH's 2006 and later popularity exceeds the best the others have ever achieved). I doubt this reflects adoption, but it's interesting nonetheless. Perhaps it reflects people searching for documentation...

NHibernate vs. LINQ to SQL vs. Entity Framework

How is interest in ASP.NET MVC coming along, with its hopeful release some time in 2008 as well?

ASP.NET MVC

Lastly, in the self-fulfilling prophecy department, how many people have been looking for a recession, since about a year ago? It certainly appears the popularity of a recession has gone up dramatically in the last 12 months.

Recession

Look up bailout as well, though the graph isn't terribly interesting since it's almost asymptotic... Fun times in the financial industry. Now back to more regularly scheduled geekdom.

Reducing SQL Lookup Tables and Function Properties in NHibernate

ssmith — Mon, 06 Oct 2008 15:17:15 GMT

One of the points made in Jeffrey's agile development boot camp last week that struck a chord with me was that many database-centric designs have lookup tables that aren't really just data. That is, tables that hold values such as statuses that, if modified, can easily break existing code or won't function as expected without the addition of code. We have a lot of these in our codebase, and we've been struggling with the questions of how to address these values in our system. Do we use Enums? If so, do we try and keep the enums in sync with the database values? If not, do we want to use magic numbers/strings to refer to these codes? It's a real PITA to work with these things and really the only reason they're in the database at all is so we have some referential integrity locking down the allowable values of the status column(s).

You can avoid this problem if you push the status logic into objects and don't rely on the database to implement referential integrity for you. Create a Status class that has all of the logic necessary for rendering a status code in a variety of ways (for instance a short code, a long name, and a description, all of which are difficult to implement on Enums without attributes or other extension approaches). Have your primary class reference the status via composition (e.g. a property). Then, in your persistence layer, you can store just the short code value (or integer key) of the class, but without the requirement that there be a lookup table involved. If referential integrity is of great importance, a constraint can easily be applied to the database. The constraint would then be updated with the build at the same time as new values are added to the Status class. The status can also be used similarly to an Enum assuming it has some static properties representing its value instances, like so:

   1: public class WorkOrderStatus

   2: {

   3:     public static readonly WorkOrderStatus Assigned = new WorkOrderStatus(

   4:         "ASD", "Assigned", "Assigned", 2, true);

5:

   6:     public static readonly WorkOrderStatus Cancelled = new WorkOrderStatus(

   7:         "CAN", "Cancelled", "Cancelled", 5, false);

8:

   9:     public static readonly WorkOrderStatus Complete = new WorkOrderStatus(

  10:         "CMP", "Complete", "Complete", 4, false);

  11: ...

  12: }

NHibernate can map this status directly if you create a WorkOrderStatusType class that inherits from NHibernate.Type.PrimitiveType and overrides its methods. The mapping then is simply:

   1: <class name="WorkOrder">

   2: <property name="Status"

   3:     type="WorkOrderStatusType, Infrastructure"

   4:     not-null="true" />

   5: ...

   6: </class>

One very common pattern I've noticed as software evolves is the migration from simple boolean state codes on objects to multi-value states and eventually to the need for some kind of an event log. In the example above, perhaps originally we started with a WorkOrderStatus that was simply a boolean with states for Complete and Incomplete, and it has since moved on to include the states listed above (and several others). Now the customer wants to know when the status changed, and by whom, so they can track the WorkOrder through its workflow.

Typically this requires a bunch of changes in the database and some application logic to get the current status from the event log as the most recent one. Further, the WorkOrder might expose dates for LastUpdated and CompletedDate which should be tied to this same event log, though prior to adding the event log they were set in application code when these state transformations occurred. This is an example wherein NHibernate's support for functions can be very helpful (see also this post by Ayende). Assuming there is an Event table which has columns for BeginStatus and EndStatus as well was a DateTime column, date properties for the WorkOrder could be mapped like so:

   1: <class name="WorkOrder">

   2: <property name="LastAssignedDate" formula="(

   3: select max(e.DateTime)

   4: from Event e

   5: where (e.WorkOrderId = Id)

   6: and (e.EndStatus = 'ASD'))"/>

   7: <property name="LastUpdatedDate" formula="(

   8: select max(e.DateTime)

   9: from Event e

  10: where (e.WorkOrderId = Id))"/>

  11: ...

  12: </class>

The nice thing about this approach is that there are fewer tables in the database that are dedicated to mere lookup data. In this case, we've eliminated the need for a WorkOrderStatus table that might have had columns like ID, Name, Description, ShortCode, SortBy, and perhaps other properties. Keeping the database more streamlined makes it easier to comprehend and easier to change, and keeping this logic in our classes rather than in the database makes our code easier to change and easier to test. If the raw SQL in the mapping file is a red flag for you, replace them with SQL Functions (which Ayende covers in his post).

Installing VisualSVN Subversion

ssmith — Fri, 03 Oct 2008 20:47:20 GMT

Wrapping up HeadSpring's Agile Boot Camp class this week, we're installing VisualSVN Server locally. Running the setup is just a matter of hitting Next three times - it's very simple. Running the visual server window yields this opening screen:

Next, right click on VisualSVN Server and select Properties:

These are basically the same settings you had available from the installer. Assuming these settings are fine, the next step is to create a user. Go back to the main screen and right click on Users, Create User.

Once a user is created, the next step is to create a repository. Be sure to check the box to set up the default structure.

At this point, the server end of things is done. If you want to set up a working folder on your local machine to point to this, go to a folder (like C:\working\) and assuming you already have TortoiseSVN installed, right click and select in the folder and select SVN Checkout:

Configure the URL and local directory:

Once this is done, you can also see at any time how the folder is mapped to its subversion location by looking at the folder's properties.

At this point you're ready to create your initial sub folders and work on your project.

Too easy. And oh by the way this also just installed Apache Server, so if you've ever wanted to do that but weren't sure how difficult it would be - you just did it.

If you're moving an existing project into this working folder and you want to add it to source control, you're best off using VisualSVN from within Visual Studio to do so. Open the solution in Visual Studio, and then assuming you have VisualSVN client installed, you should be able to right click on the solution and select Add to Subversion.

If you don't see that option on the solution, you'll want to delete the .svn folder from the working folder and then go through the process, stating that you'll set the working folder manually.

Now right click on the folder in Windows Explorer and SVN Commit. Your code is now in a local copy of subversion. Note that you can use this to version any files! If you want to version your word documents or graphic files you're editing or anything you like, this will let you do it. Just be sure you're backing up your hard drive, since this isn't a substitute for backing up your disk. But it will give you local revision history so you can undo changes to any document.

Monty Hall Envelope Puzzle

ssmith — Fri, 26 Sep 2008 15:20:30 GMT

So, recently I wrote about my introduction to the Monty Hall problem and its solution. However, in the course of thinking about this problem, I came up with a related one that is pretty tricky as well, and builds on the insight gained from the Monty Hall problem. That is, given three random chances to win a prize, if you pick one and another is revealed as a non-winner, you are better off switching with the remaining chance you didn't originally pick than sticking with the original selection (with 1/3 - 2/3 odds). With this in mind, consider the following problem.

Steve's Monty Hall Envelope Puzzle

I take 3 plain envelopes and put a $100 bill inside one of them, seal them, and give one to you, one to Bob, and one to Carrie, at random. Then I randomly ask one of you to open an envelope - for the sake of argument let's say I choose Carrie. Carrie opens her envelope to reveal that it is empty. Now I offer you the choice to trade envelopes with Bob - should you trade?

And now I ask Bob the exact same question. Should he trade?

Analysis

If the logic of the original Monty Hall problem holds, then you had a 1/3 chance of choosing the right envelope to begin with, meaning that the set of Bob/Carrie envelopes had a 2/3 chance, and therefore with Carrie eliminated you should switch with Bob because his envelope now has a 2/3 chance while yours has retained its 1/3 chance. Clear so far, I hope. You naturally want to trade.

However, Bob sees the exact same odds from his point of view!

Bob had a 1/3 chance at the outset, and saw you and Carrie as having a combined 2/3 chance, and with Carrie removed, that leaves you with a 2/3 chance to his 1/3. Bob definitely wants to trade with you as well!

The question is, how can it be in both of your best interests to trade? How can you both now have a 2/3 chance (relative to the other one)? And what is the actual likelihood that either of you is now holding the $100 in your envelope?

Favorite Developer Books

ssmith — Fri, 26 Sep 2008 13:59:11 GMT

I've written a few posts recently about various books, and recently while interviewing a candidate for Nimble Software Professionals it occurred to me that for an experienced developer (e.g. not a new grad out of college), asking what their favorite (or most recently read) programming book is could tell a lot about them as a developer. If their favorite book is something like Expert Programming in 21 Hours (not a real title) that paints a very different picture than if their favorite book is Design Patterns or a similarly respected title.

Of course, flipping the question around, I started to think about what I would list among my own favorites, and naturally that seemed like a reasonable blog post, so here goes. Anyone interested in a wider poll of favorites should check out this StackOverflow thread (and this one).

Steve's Top 2 For Developers

Working Effectively with Legacy Code (Robert C. Martin Series)

ISBN: 0131177052
ISBN-13: 9780131177055

In the #1 spot is Feathers' book, which I read early this year. This book is now required reading for all of my developers. I really wish I had read it about four years ago when it was first published (and sooner than that if he'd written it sooner) as it fundamentally changed my approach to developing flexible and maintainable software. I've reviewed it elsewhere more completely, but it's good. The title stinks, though - don't let that throw you.

Code Complete: A Practical Handbook of Software Construction

ISBN: 0735619670
ISBN-13: 9780735619678

A classic. Should be a companion text in intro to programming courses around the country, I think. This book will help you to write better code at the method level and below. It's low level but extremely practical and while you may not agree with or adopt 100% of the practices it recommends, you'll be a better programmer for having read McConnel's analysis and then made an informed choice about how you do things.

Note that I don't really care what language you're writing in - these two books are just fantastic for any software developer.

Steve's Top 2 For Project Managers

Lean Software Development: An Agile Toolkit (Agile Software Development Series)

ISBN: 0321150783
ISBN-13: 9780321150783

I've written a few blog posts based on this book recently, and I have a few more notes that will turn into future blog posts. I think this book has given me more blog fodder than any other I've read recently. I still need to write a full review, but it's definitely worth a read if you're interested in improving the overall productivity of your development team.

Peopleware: Productive Projects and Teams (Second Edition)

ISBN: 0932633439
ISBN-13: 9780932633439

Another classic title, this one is great for technical managers of all sorts who want to have productive teams. If your organization is one in which people say (or believe) they like working early in the morning / late at night / on weekends because "it's the only time they can get real work done" then you really should read (and act on) this book.

Reading Now or in the Queue

Domain-Driven Design: Tackling Complexity in the Heart of Software

ISBN: 0321125215
ISBN-13: 9780321125217

I'm in the process of reading Evans' book, which I've previously skimmed. I suspect I'm going to read this one more than once, as it has a lot of interesting concepts that one needs to practice in order to master. There's a Yahoo group dedicated to DDD that I'm lurking on as well.

The Art of Agile Development

ISBN: 0596527675
ISBN-13: 9780596527679

I'm about halfway through this one - it's a larger book than Lean Software Development and covers some of the same ground. I'm not finding it quite as compelling, but it's got its share of gems.

Head First Design Patterns (Head First)

ISBN: 0596007124
ISBN-13: 9780596007126

I've read chapters of this from others' copies of the book and it's a very approachable and entertaining book (which says a lot given what's out there). It's on my list to give a full reading to when I get a chance.

The Pragmatic Programmer: From Journeyman to Master

ISBN: 020161622X
ISBN-13: 9780201616224

Also on my list. I don't have much to say about it beyond that I've heard it's great and I should read it.

Worth Mentioning

Refactoring and Design Patterns are both on my shelf (having been read first!) and are certainly worth mentioning. I think Feathers' book is much more important than either of these as it did a much better job of bringing it all together and helping me to "get" why some of these techniques were useful, and in which situations. Another one I read early on in University of Chicago's introduction to programming course is Abelson/Sussman's Structure and Interpretation of Computer Programs, which is another classic. I need to pick up the 2nd edition of this and add it to my reading list. Scheme is a fun language, and thinking about programming in a LISPy/Scheme-y way is very different from typical OO/C style languages. Tends to be very jarring for me, but especially with lambda functions and related new features in C#, revisiting some of these functional language features should prove educational and helpful.

So... that's my list for now. It's certain to change over time as I find a new favorite, and it's possible that I've completely left out some that really should be on my list. As for you, do you agree? Do you have your own favorite? Which books have had the greatest impact on you, and what book would you be most proud of reading if asked the question in an interview?

Probability Puzzle Answered

ssmith — Thu, 25 Sep 2008 17:55:51 GMT

In a recent post, I described a Probability Puzzle that is actually known as the Monty Hall Problem. This is a fairly famous problem and has a long write-up on Wikipedia that is definitely worth reading to get a good understanding of the problem. Almost everyone fails to answer this problem correctly the first attempt, because it seems obvious that there is one prize behind one of the remaining two doors, and there is nothing constraining which door we might pick (the 2nd time), so it should be a fresh decision with a 50/50 chance of success.

In fact, the way to look at this problem is in reverse. With the initial choice of one door out of three, the odds of success were clearly 1/3. Said another way, the likelihood that a wrong choice was made was 2/3. Still another way to look at this is that the breakdown in odds is 1/3 assigned to the set of doors chosen (1 door) and 2/3 assigned to the set of doors not chosen (2 doors). When it is revealed that one of the unchosen doors is not the winner, this changes nothing about the likelihood that the door you originally picked is correct! Your set still only has 1/3 and the unchosen set (which now has only 1 door in it) still has a 2/3 chance of being correct. Thus, you definitely should switch doors, as it doubles the odds of winning the prize!

This result can easily be demonstrated with a bit of code, run a suitable number of times. Pick a number from 0 to 2 to be the door with the prize. Pick a number from 0 to 2 to be the contestant's selection. Initial chance of success is 1 in 3. Now pick one of the other two doors and reveal it, but only if it is not the prize. You'll find that it is the prize 1/3 of the time - these get thrown out as the problem has defined that a goat must be revealed. Now look at the number of times the contestant has the right door compared to the number of times the unselected door is correct, and you'll see quite clearly that it's twice as likely the unchosen door has the prize.

I have one more post on this subject for tomorrow, which twists this a little bit further. I suggest reading the full Wikipedia writeup before diving into that one.

Strategy Pattern With Ninject

ssmith — Thu, 25 Sep 2008 04:54:17 GMT

This is a follow-up to my post about avoiding dependencies with design patterns. It left off with something like this as a Cart object that uses the Strategy pattern to avoid a direct dependency on SMTP emails.

   1: public class Cart

   2: {

   3:     private ISendEmail emailProvider;

   4:     //public Cart()

   5:     //{

   6:     //    emailProvider = new LiveSmtpMailer();

   7:     //}

8:

   9:     public Cart(ISendEmail emailProvider)

  10:     {

  11:         this.emailProvider = emailProvider;

  12:     }

13:

  14:     public void Checkout()

  15:     {

  16:         // Do some other stuff

17:

  18:         this.emailProvider.SendMail("someuser@domain.com", "store@acme.com",

  19:                         "Order Confirmation", "Your Order Was Received.");

  20:     }

  21: }

Note that I've commented out the default constructor - I'll explain why in a moment.

The next logical step in this series is to avoid the requirement of hard-coding in the class its default behavior of using a LiveSmtpMailer() instance to send email. We want to be able to manage these default implementations centrally, either via a class or some kind of configuration file. Tools that provide this functionality are collectively referred to as Inversion-of-Control containers, or IoC containers. Ninject is one such tool.

Download Ninject, build it if necessary, and add a reference to Ninject.Core to get started. With this in place, we can do the necessary plumbing work to have Ninject instantiate our Cart class for us, rather than using the new keyword ourselves directly. Avoiding the new keyword is a necessary consequence of most IoC containers, as far as I can tell. To tell Ninject what to do when it finds it needs an ISendEmail interface implementation, you can create something like the following:

   1: public class CustomModule : StandardModule

   2: {

   3:     public override void Load()

   4:     {

   5:         Bind<ISendEmail>().To<ConsoleTestMailer>();

   6:     }

   7: }

The ConsoleTestMailer is a new one I wrote for this example. It's listed here:

   1: public class ConsoleTestMailer : ISendEmail

   2: {

   3:     public void SendMail(string To, string From, string Subject, string Body)

   4:     {

   5:         Console.WriteLine("To: " + To);

   6:         Console.WriteLine("From: " + From);

   7:         Console.WriteLine("Subject: " + Subject);

   8:         Console.WriteLine("Body: " + Body);

   9:     }

  10: }

All it does is dump the email information to the console.

Now we're ready to write the Main() method of our console application:

   1: class Program

   2: {

   3:     static void Main(string[] args)

   4:     {

   5:         CustomModule module = new CustomModule();

   6:         IKernel kernel = new StandardKernel(module);

7:

   8:         Cart myCart = kernel.Get<Cart>();

   9:         myCart.Checkout();

  10:     }

  11: }

And that's it. The magic happens on line 8. If you leave the default constructor with the hardcoded implementation, then that's what is used. Removing it and leaving only a constructor expecting an ISendEmail implementation allows Ninject to manage this dependency injection, and lets you manage it across your entire application from one location.

Probability Puzzle

ssmith — Wed, 24 Sep 2008 17:19:13 GMT

I was recently introduced to the following puzzle by another developer (from Vertigo, in fact). This is actually a fairly well-known problem and you'll find write-ups about it on Wikipedia and elsewhere, but I'll omit links to those sources from this post to prevent some temptation to just click and see the answer (I'll post everything in a follow-up).

The Scenario

Imagine you are on a game show in which a great prize is hidden behind one of three doors. Behind one door lies a brand new car. Behind each of the other two, a goat. The host of the show has explained this to you, and asks you to select a door. You choose one and inform the host of your decision. He smiles and says "Let's see what you didn't win" and opens up one of the other doors, revealing a goat! Then he looks at you and says, "The car is still behind one of these two doors. If you'd like, I'll let you change your mind and switch which door you've selected. What do you say?"

Should you switch doors?

Is it in your best interest to switch doors, or does it matter? When commenting, if you already know this problem, please avoid posting any spoilers or links to write-ups. I'll publish a follow-up with all of that tomorrow.

Review - Murach ASP.NET 3.5 Programming with VB

ssmith — Tue, 23 Sep 2008 19:57:33 GMT

I have a copy of Murach's ASP.NET 3.5 Web Programming with VB 2008 (book web site) that I received over the summer and have been meaning to write a short review. So here goes. First of all, I love the "Murach format" for books, especially for "how-to" books which as it happens tend to be what they publish. Specifically, they lay out their books such that typically the left-hand page is providing some explanatory text, while the right page has the corresponding figures, source code, etc. The result is that you pretty much always have everything you need in front of you, unlike 99% of the technical books out there in which you're always have to flip pages or read through multi-page code listings in order to figure out what line of code or figure the author is referencing.

Another thing I really liked about this book is that if you're a professor, trainer, instructor, etc. you can get courseware that integrates with the book (thanks, Mark Dunn, for this tip). This is HUGE because normally it's quite a bit of effort and/or expense to get decent courseware put together (and kept up to date). What's more, the Murach stuff, for the most part, is pretty good! I know that doesn't sound like a glowing endorsement, but I've used a handful of third party course curricula and I can tell you that many do not meet this bar.

I used the book and its associated training materials (obtained from the publisher) to teach a class last week that went quite well, and I'll be teaching a second class to the same group of students soon, using the same materials. The class was in C#, but as luck would have it there is also a Murach's ASP.NET 3.5 Web Programming with C# 2008 (book web site) title that isn't actually in print yet but which had code samples and courseware available. So, even though I didn't have the pressed trees version of the book, I was able to use it for the C#-specific course.

The book has 29 chapters and includes coverage of the basics of web programming on up through LINQ, IIS, AJAX, and web services. Its approach to all of these is at a basic, introductory level, and it does a very good job of making these technologies very approachable for students who have had limited or no exposure to these subjects. You can pick up either the C# or VB version for about $33 on Amazon at the moment, which seems quite reasonable given that it's just under 1000 pages.

Slack and Constraints and Optimizing Throughput

ssmith — Mon, 22 Sep 2008 16:14:21 GMT

This is my second post that's related to my recent reading of Poppendiecks' Lean Software Development - read the first one here on Delaying Decisions.

A related book (and one thing I loved about Lean Software Development were the many references to other great books, some I'd read, some not) that I've read and recommend is Slack, by Tom DeMarco. It's referenced on page 81 of Lean Software Development, in reference to optimizing for flow as opposed to optimizing for utilization / efficiency.

In both books, the point is made that total throughput and resource efficiency are opposed to one another. To prove this, consider the case where you have a worker who is only 60% utilized on time-critical tasks. When you give this worker a task that takes 15 minutes, you can typically expect that it will get done in 15 minutes, and sometimes a little longer if you just gave them some other work ahead of this batch.

Now, clearly, this worker is not being used efficiently - they're only 60% utilized on critical tasks! So management decides to assign this worker to two people, each of whom now puts their work requests into a queue, and the worker processes them FIFO as they are received. Now the worker is typically 100% utilized and the queue is never empty, with some things sitting in it for several hours during busy periods of the day. That 15 minute task you needed done now is going to take 2 hours, (but at least the worker isn't idle at all). Overall throughput - the total time for a request to get through the system - as plummeted!

Highways, server CPUs, project schedules, and yes employees are all resources that need to have some slack available if they're to be used in the most effective fashion from the point-of-view of productivity. If you measure the flow of widgets shipped or project velocity or server requests served per second and average time to last byte - you'll find that all of these are better when resources have excess capacity than when they are 100% utilized, even though the latter is the most efficient use of those resources.

Clearly 100% efficiency is the enemy of overall system productivity.

Poppendiecks summarize with:

Just as a highway cannot provide acceptable service without some slack in capacity, so you probably are not providing your customers with the highest level of service if you have no slack in your organization.

Highways are being used most efficiently when they are completely gridlocked, if you measure the number of cars using the resource / total area of the highway. Yet clearly from the perspective of an individual vehicle trying to get from point A to point B the highway's throughput is far better when it is underutilized.

On the very next page, they cite the Theory of Constraints, which I've quoted often in my presentations on performance tuning (though I haven't yet read the book - it's on my list). It relates not only to software performance, but to organizational performance as well:

According to the theory of constraints, the best way to optimize an organization is to focus on the throughput of the organization, because this is the key to generating profitable revenue. The way to increase throughput is to look for the current bottleneck that is slowing things down and fix it. Once that is done, find the next bottleneck and fix it. Keep this up and you will have a fast moving value stream.

Find the bottleneck. Eliminate it. Repeat. This is performance tuning, of anything, in a nutshell.