The Daily Parker

Politics, Weather, Photography, and the Dog

Joel Spolsky's 12 rules to better software

My project manager sent around this link to Joel Spolsky's rules for software management:

I've come up with my own, highly irresponsible, sloppy test to rate the quality of a software team. The great part about it is that it takes about 3 minutes. The neat thing about The Joel Test is that it's easy to get a quick yes or no to each question. You don't have to figure out lines-of-code-per-day or average-bugs-per-inflection-point.

I totally agree with Spolsky's list. I have never been on a project that scored better than 7 until now (which scores 9, IMO, but we're moving toward 11), and only one, ever, has answered "yes" to #8 (quiet working conditions).

Window vs. Aisle

I promised earlier to discuss the joys and sorrows of traveling for business. I had some time this morning in the airplane to do so.

Every week, I fly back and forth between Boston and Chicago. This morning I caught the bleary-eyed special leaving Chicago before 7, and I still missed my 11:30 Scrum. Between that, having to get out of bed slightly before 5am, and a general feeling of lethargy that no amount of coffee can cure, not to mention the lost billable hours, I'm going to start returning to Boston on Sunday nights.

Neither Anne nor I is thrilled with the arrangement. But then, we're not ecstatic about the 100% travel to begin with. The compromise is for me to be home no less than 48 hours a week, and for her to come out to Boston every so often.

A funny thing happened to Anne recently. She used to be an Aisle Person. She's becoming a Window Person, possibly because I have been one for the 30 years I've been flying.

Aisle People don't really like to fly. It's a means to an end. I'm here, I need to go there, this requires sitting in an aluminum tube for several hours; best to sit in the asile to minimize the aluminum-tube time.

I, on the other hand, always take a window seat. The very first time I got in an airplane, before I could even spell my name, I think my nose was pressed against the window for four hours. I've never gotten over how cool it is to look down 10 km (6 mi) and see...everything.

As I write this, we're over Lake St. Clair, just passing into Ontario. I can see that Lake St. Clair has two distinct currents, one direct from Lake Huron, which is dark green, and the other from the marshes on the Canadian side, which is muddy brown. The two flow in parallel down the Detroit River almost to the Renaissance Center, where turbulence from Belle Isle finally mingles them in swirling eddies of what I can only assume are heavily-polluted mud.

Ten minutes more and we're over the great swirling sandbar jutting out into Lake Erie right in the middle of the Canadian shore. I can actually see the sand flowing past it, lengthening it, creating a huge sandy beach upstream and a hazard to navigation downstream. Just a few minutes past that and we're over Buffalo, N.Y. There's Niagara Falls, identifiable from the cloud of mist hanging over it, and Toronto, barely discernable through the morning haze. Next, over Western New York and the Finger Lakes, deep valleys scooped out only a few thousand years ago by the southern edges of the massive ice sheets that dug out the Great Lakes. Finally, depending on our approach, I'll either get a terrific view of Nashua, N.H., from about 2,000 m (6,000 ft), or we'll get up close and personal with downtown Boston.

This is why I always get the window seat. And Anne, who finds herself flying a lot more than before we met, has started to agree.

Photo: Cape Ann, Mass., on downwind to Logan on today's flight.

Predictable software

We spent two hours yesterday debugging some code that kept firing early. It wasn't clear to anyone, including the people who wrote it, why this happened. We patched it with the C# equivalent of duck tape, but really, it still doesn't work right.

This incident shows how important it is to know what your code is supposed to do, and not to accept the code if it doesn't. Many tools exist to help—most notably, unit-testing tools like NUnit—but they have trouble with the specific problem that we encountered: events fired from black-box controls.

I will have more to say about this later.

The Midnight Special

Before nodding off to bed tonight, on a whim I searched Google for a funny story I remembered hearing on WFMT-Chicago's Midnight Special many years ago.

The New Year's Eve Midnight Special always ran long, and always played a bit called "Moose Turd Pie." Thanks to Google, I finally found out where it came from: U. Utah Phillips, who even has a link to the bit on his site.

This is what the Internet is all about.

Corporate insecurity

Anne brought to my attention the security practices at a medium-sized company in Chicago that make security nearly impossible: the company's IT department assigns Windows domain passwords to the users. In a recent communication, IT said this practice made the domain more secure.

It actually made me mad to hear about this practice. They're not only wrong, they're wrong in a particularly ignorant and incompetent manner, and someday they're going to have a significant security incident.

Secure log-ins serve two distinct purposes: authentication and authorization. Authentication means that the log-in procedure should guarantee that the person providing the log-in credentials is who she claims to be. Authorization means that the successfully logged-in person has access to the data he needs access to, and no more.

Most people only equate log-in screens with the latter. In many organizations I've worked with, people share passwords all the time, thinking that the password controls what they can do. It's often then impossible to figure out who did what with which data. Within a company that has Sarbanes-Oxley reporting requirements, this kind of sloppiness may actually violate criminal law in some cases.

Your bank knows about authentication. It's why you have a PIN (personal information number) for your cash card. It's also why sites like the IRS Website ask for hard-to-know information, like your previous year's adjusted gross income, before they let you do anything. Some people at your bank and at the IRS are authorized to see your information, too, but when they look at it, there's a record that they are looking.

IT administrators never actually need your password, because their authorization far exceeds yours. Plus, it's usually important for IT departments to know who did what to each computer. When you have the keys to the kingdom, you come under greater scrutiny.

For these reasons, the only person who should know a log-in password is the person who chose it. Any password that the person did not, herself, choose, is no better than a password that a "malicious user" has cracked or stolen.

Now look at what the company Anne mentioned is doing. The IT department has a list of passwords, which can be stolen. Also, the IT department can log in to any employee's workstation as that employee (which is, I think their goal). Once in, they can send email under the employee's identity, rummage through confidential information (for example on a law partner's computer, where the lawyer has a legal obligation to keep the information private, even from other people in her firm), etc.

No doubt the IT department would claim they need this kind of access to ensure employees aren't using computers for personal work, or storing copyrighted materials on work computers. But since the password list exists, even if compromising material were found on the employee's machine—which, by the way, the IT people have the ability to find under their own login credentials—now there is a legitimate claim that the employee had no knowledge of the problem, because there is no way to show conclusively that only the employee could have put it there. (Had IT put it there under their own credentials, this would be easily determined by checking the security information on the computer.)

This isn't the only idiocy perpetrated by this particular IT department, but it's the one most contributing to their lack of security. If there were a professional organization of computer people, these guys would be thrown out.

Framework classes, again

I mentioned Friday that I've completely refactored the section of the Inner Drive Extensible Architecture™—the Idea™—that handles quantitative functions. (I've also decided to make some SDK documentation available.) The actual design of the IMeasurable classes—Length, Speed and the like—bears more discussion.

What I have, essentially, is a collection of .NET structs that implement IMeasurable, one for each kind of thing you want to measure. The old design had a single struct called Numeric that could represent any kind of measurement at all. The change means that the measurement type is now enforced by the compiler rather than the run-time engine, because instead of this:

Numeric meters = new Numeric(10d, new Meter());
Numeric pounds = new Numeric(10d, new Pound());
Numeric compilesFine = meters.Add(pounds);

> IncompatibleUnitException thrown

You get this:

Length meters = new Length(10d, new Meter());
Mass pounds = new Mass(10d, typeof(Pound));

Length wontCompile = pounds.Add(meters);

> Compiler error: no overload of Mass.Add takes Length as a parameter

One thought I had, though, was: why not make each of the units a measureable type to further constrain the design? So you would have this instead:

Pound pounds = new Pound(10);
Gram grams = new Gram(10, MetricExponent.Kilo);

Pound pounds = pounds + grams;

Simply: that would require either dozens of nearly-identical structs, or I would have had to use classes instead. Remember that a struct can't inherit from anything except System.ValueType. So each struct either has to contain all the relevant code (about 1200 lines of it for each of my IMeasurable classes, including documentation), or it has to compose most of its functionality from other, static objects—which is actually quite difficult in this context.

Structs are small very fast, and immutable, which makes them the best choice for small, fast, immutable things like measurements. I'd rather represent measurements with structs than objects, but I'd also like to avoid writing and unit-testing dozens of nearly-identical classes. So I compromised: representing each type of measurement with its own struct (so there are now only 8 of them), and allow the abstract Unit class to define how the individual units interact.

Check out the Quantitative SDK and let me know what you think.

Web hype: or, Party like it's 1997

Usability guru Jakob Nielsen has a new column today reminiscing about the hype of 1997 because it's back in vogue:

The fads and big deals that get the press coverage are not important for running a workhorse website. To serve your customers, it's far better to emphasize simplicity and quality than to chase buzzwords.
There is endless coverage of a few atypical stories in the trade press, mainstream media, and even on specialized Internet-focused websites. Once again, it's worth remembering: your site is different from the ones in big stories. Focus on fixing the basics to get a simple and communicative website. Simple steps don't get hyped, but they drive much more business value for the average site than the issues that everyone writes about.

He includes a sidebar about the fads of 1997 and how they're doing today.

New Inner Drive demo, completely refactored

In January, I wrote about framework classes I was working on, and how I wanted to simplify the Inner Drive Extensible Architecture™. I followed up in February with a conundrum concerning how to model the problem. It turned out to be tricky, and time-consuming, and considering I wrote most of it at The Peddler's Daughter in Nashua, N.H., there was a lot of Smithwick's Ale[1] involved.

But today, at last, I've got a new demo.

The demo page has a lengthy explanation of how the new version works, and includes a bunch of source code showing how simple the stuff is to use and to extend. I still have a little polishing to do, but I'll probably be putting the full SDK documentation for the IDEA™ up on the Inner Drive website later this month.

I think this is some of the coolest stuff I've ever written.

[1] I would have linked to the official Diageo site, but it's so annoyingly badly written—it whisks you away to a page requiring your birthdate and it tries to cookie you—that on principle I won't have that as the primary link to this product.

Southern New Hampshire: Logan or Manchester?

About a month ago, I promised to write about traveling for business. I only now have a little time to do so.

One question I get from many who live near my client (in Merrimack, N.H.) is, why do I fly into Boston Logan instead of Manchester? Simply put, it's faster and cheaper.

Faster, because the trip from my home to O'Hare takes about 30 minutes, while the trip to Midway would take closer to 90. That is significantly greater than the difference between travel times to Logan (60 minutes) and Manchester (20).

Cheaper, for many reasons. Chicago (O'Hare) to Boston is served by four or more major carriers; Chicago (Midway) to Manchester by only one. Consequently, it's often, but not always, cheaper to fly to Boston. Next week, for example, my fare on American is $134; this week it's $168. Compare with Southwest's minimum for any round-trip, which seems to be $198. Even when my fares are higher at more popular times, like at the end of April ($313), they're also higher into Manchester.

Finally, Logan gives me more options, should weather or airline management affect the flight schedule. American has 8 non-stop flights daily in each direction; Southwest only has 3.

So, Logan it is.