Here’s a common question: “Should we be using Linux?”

I have a standard answer: “I have no idea.”

As described last week, vendor/product decisions are social beasts, best addressed through the When/Who/How/Why/What formula. Determine when you have to make the decision, who should be involved, and how you’re going to make it. If everyone commits to “How” — that is, to the process you’ll employ in making the decision — then you’ll be able to reach consensus on why it’s important and what the organization should do.

“How” — the decision process itself — is the real work of the formula and this week’s subject. Since Linux triggered this discussion, our focus will be on platform-layer decisions. Application-layer decisions are similar, although with much heavier involvement on the part of the end-user community. It’s a seven-step process.

Step 1: List about five candidate products and vendors. It should be a diverse list, including both mainstream and wild-card candidates. (Avoid the popular practice of creating a rigged list so you can just go through the motions.)

Step 2: Determine the important features. In the platform layer, this mostly translates to applications and services. Make this list generic (“directory service”) rather than product-specific (“NDS”). Include price as a feature.

Step 3: Establish integration requirements. For database servers, you may specify ODBC compliance. For servers you may require compatibility with your data center management system. Just as new employees must be able to fit into the team, so products must be able to fit into the network.

Step 4: Specify vendor requirements. List what matters to you, not the vendor’s internal characteristics. Availability of experts and third-party enhancements matters. The potential for a product becoming an orphan matters. Quality of support matters as well. And, there’s the vendor’s announced plans for the product. The vendor’s financial strength and the product’s market presence may lead to something that matters to you but they themselves don’t.

Step 5: Establish scoring criteria. For example: When listing key applications and services you used generic terms. If support for specific applications and products matter, give higher scores to products that provide it. Built-in services may rate higher scores than third-party solutions. And so on. The key: Know how you’ll score features, integration requirements, and vendor characteristics before you do any research, not after.

Step 6: Blend requirements into a single list and assign weightings to each item. Use a three-point scale: 3 is a deal-breaker, 2 is important, 1 is useful. If the group is small, assign the weightings through group consensus. If it’s a big group, consensus is too unwieldy so you’ll just have to vote on it: Give everyone involved a fixed number of 3s, 2s and 1s to vote with and tabulate the results.

Step 7: Gather data. Read product comparisons, talk to the vendors, issue a request for proposal if you must — and use it to score the products.

Step 8: Pick the winner. Remember, though, this scoring system isn’t precise. If the top product scores 132 and the next in line scores 128, they have tied. Also remember, vendors have been known to exaggerate, so run a pilot with the top scoring candidate (or the top two if they’re close) before making a final decision.

Now … how does Linux fit into this process?

Very nicely, if you handled Step 4 properly. With an open-source product, support is entirely through third-parties (something true of many traditional products as well), the product evolves by duplicating successful innovations of commercial competitors, and the personal commitment of its advocates is part of the question of potential orphan-hood, but the vendor issues that matter to you are the same.

Product and vendor decisions easily become emotional issues. The way to combat this is for everyone involved to attach their emotions to the selection process instead. Do it by the numbers and you’ll make a good decision. Most important of all, it will be a decision everyone can support.

I’m jealous of political pundits. They get to write about global warming, economic protectionism, and cloning (for example) without any particular expertise in the relevant disciplines, influencing public policy in the process.

Not me. All I get to write about is how to run IS. My writing about Zippergate, for instance, would be about as classy as the Hollywood actors who make political speeches during the Academy Awards (although that may be preferable to the current practice of thanking everyone in the telephone directory).

That’s why I’m so thankful for Department of Justice vs. Microsoft. It lets me comment on a major issue of public policy without straying from my purported area of expertise. Here’s my comment: As of this writing, Microsoft seems to be counting on one of three legal possibilities: Either 1) It isn’t really a monopoly because even though it is right now it won’t be forever so that makes everything OK; 2) the antitrust laws are a bad idea so don’t enforce them; or 3) even if it’s found guilty, the penalty won’t hurt very much. The “consumers haven’t been hurt” argument is, of course, irrelevant grandstanding – the question is one of using its monopoly for competitive advantage, not one of price-gouging.

The biggest impact of this trial, of course, is all the free publicity it’s given Linux. Ain’t irony grand?

Last week’s column presented a simple formula for predicting the success and failure of new technologies and technology products, using past products as examples. This week we’ll apply it to the current technology scene, starting with Linux.

The formula, you’ll recall, was customers/affordability/disruption – a successful new product must do something worthwhile for the customers (the people making the buying decision, as opposed to the consumers, who use the product); it must be affordable; and it must not disrupt the current environment. (Disruption, by the way, is a big reason companies like Microsoft, which dictate the architecture in particular environments, have the incumbent’s huge advantage.) Let’s start predicting!

Linux (as a server) – Main customers: Webmasters and underfunded system administrators. Benefit: Runs reliably and fast. Affordability: Free, or nearly so. Disruption: As a Web server or file-and-print server, it integrates invisibly into the network (unless Microsoft can make it disruptive through proprietary server-side innovations like Active Server Pages). Score: Perfect – Linux is a winner.

Linux (on the desktop) – Main customers: End-users. Benefit: Fast, less-crash-prone PC. Affordability: Free except for the (not overwhelming but not trivial) time needed to learn it. Disruption: The office suites for Linux don’t reliably read and write the Microsoft Office file formats – that is, there’s a significant delay before the Linux suites catch up to each new Office release, and even then they’re glitchy. Score: Iffy.

Personal Digital Assistants (PDAs) – Main customers: End-users. Benefits: Lightweight, carries around essential information, IS doesn’t get to say what users can and can’t do with it. Affordability: Very. Disruption: Unless an installation goes south, they’re invisible to IS. Score: Perfect – PDAs are a winner.

XML – Main customers: IS developers. Benefits: Universal, awesomely adaptable file format. Affordability: Open standard, learnable without needing tensor calculus. Disruption: A complicated question. As meta data (think data dictionary on steroids) there’s no significant installed base to disrupt. As an office-suite file format, either Microsoft’s XML tags will do the job for everyone or it won’t get off the ground. As a replacement for HTML it’s highly disruptive until it’s built into the browser. Then it’s nondisruptive. Score: Very High – XML has enough different applications that it’s bound to succeed in at least some of them.

Java – Main customers: IS developers. Benefits: Nicely designed object-oriented language, automatic garbage collection, possibly portable (the jury’s out on this one). Affordability: As affordable as any other programming language. Disruption: A complicated issue. For established developers it’s disruptive – having some of a product in Java and the rest in a compiled language is messy, and probably won’t happen. For new developers it’s non-disruptive, except for the performance issues compared to any compiled language. Score: Adequate – Java will become just another programming language.

Well, there you have it. Like a good math text, you now have a formula and examples. Go forth and prognosticate.