Most people are astonished to discover that my experience as an open source software user dates back 20 years. My first encounter with source code distribution and communal software development happened back in 1984, when I became a journeyman systems programmer in the world of VM/CMS, IBM’s elegant mainframe operating system. Although a lesser-know sibling to MVS, VM found a niche in the timesharing world as a delivery platform for a myriad of collaboration applications that revolutionized the process of big business.

This IBM model had much in common with today’s open source model. The distributions were available as both source and object code, meaning one could choose to install the software as packaged or work through the arduous task of building customized systems. The development community was encouraged to submit fixes and enhancements back to the sponsor for integration into future distributions. Special interest groups filled the gaps to conceive and promote new application extensions and system management capabilities. Interchangeable components became available from new companies eager to provide solutions.

But there was one catch: IBM ran the show. It took some years, but eventually IBM quit shipping their source code, likely in response to up and comers like Microsoft and Novell who took the software industry down the ethical and legal paths to protect closely guarded secrets. The pendulum had once again swung away from community and was swiftly headed for capitalism.

In the corporate world of big profits most familiar to me—Big Oil and Big Banking—funding gushed forth to bloat unbridled IT budgets. We all watched in amazement as blank checks were issued to IT organizations to splurge on Business Process Reengineering projects run by questionable managers that produced little or no business value, justified because they were “in the budget.” Of course this all abruptly ended—right about the time the world ceased to fear Y2K and the economy began to spin hopelessly out of control. The world of grand IT spending died an inconvenient death.
In response, the pendulum starting to swing back, signaling a culture change. Discussion forums replaced industry conferences. Listening to peers replaced listening to vendors. Borrowing software replaced borrowing money to pay for software. Paying attention to shared licensing replaced paying huge licensing fees.

Getting software for free replaced getting signoff for enterprise licensing agreements. Funny, the community of 2004 started to look a whole lot like that of 1984.
Even today, the evolution continues. The industry is meandering down a path where we will watch as both existing and new ideas in the form of open source make their way into the public domain. The plethora of solutions available for systems development and infrastructure will be joined by a breath of solutions in the office, collaboration, and entertainment space, and will eventually include industry vertical markets.

Advocates of open source are adopters, not consumers. Moving away from procurement means first thinking about the process for the long term. But success as an adopter will not come easy.
This latest chapter of open source history is still in the making, and decision makers patient enough to float with the tide will learn how to craft a definition of success for the organizations they represent. What follows are a few suggestions that might help:

Make legacy applications a non-issue. If pricy, proprietary legacy applications exist in your company, find a means to eliminate them. The process will very likely take years – but having a plan will certainly move the project along faster than doing nothing. Remember that nothing makes your controller happier than not spending money.

Watch for critical movements. Linux on the server was the first major success, and the desktop can’t be far behind. Once Microsoft’s stranglehold on corporate collaboration is breached, the ramifications will have staggering impact on the industry. Tangible penetration into areas of proprietary influence—ERP, CRM,and so on—remains minimal, but victory is inevitable. Expect new players to emerge to drastically change the solution provider landscape. Think back to 1984 and how many people had heard of Bill Gates and Larry Ellison.

Create component architectures. Start building with basic components, and build over time. Create and follow a plan for rollout. If success happens quickly, accelerate the plan or add more components. If it comes too slowly, slow the adoption rate to avoid disrupting operational and user comfort.

Kill the proportional cost model forever. Get out from under the thumb of proprietary solution vendors that use the “charge by” model for users, seats, cpus, etc. Significantly reduce the delta-cost increases to get to 10x-, 100x-, 1000x-sized infrastructures, with no loss of service or functionality.

Beware the vendor FUD. Of course traditional vendors will tell you countless reasons open source is bad. But don’t forget their biggest - and obviously unspoken - fear: loss of revenue and collapse of their existence. Be careful not to ignore all of their objections, since some might actually make sense, but remember to come to your own conclusions, unburden by their marketing machines.

Build toward a model for utility computing. Components that can be freely added at low cost become commodities. Be able to scale gracefully: add components that enable manageable, incremental improvements, but avoid giant leaps of potentially disruptive infrastructure change. Tread lightly: remember that “grid” means many things to many people.

Don’t forget the systems management. Take care to weave proactive & reactive capabilities for systems and operational management into the expanding infrastructure –and do so early and often. Adding these after the fact will inflict great pain required to retool existing deployments.

Create success targets. Make use of open source at every reasonable opportunity for your core business. Success stories already abound – this is no longer science fiction. Find and nurture the experts of the open source generation, for they will be the enablers of success.

Accept the new realities of Open Source. Live the mantra that proliferation of open source will only continue to accelerate. As more people are trained and exposed, the evolution process will continue to feed on itself. One notable hurdle: choosing how and where to get your product support may be tricky—and in the short term, costly.

Take note of the evolving business model. No industry can survive for long by giving away its product. Expecting that the free-to-acquire, pay-for-support model will survive many more years makes as much sense as long-distance fees in the days of VOIP.

Eventually, someone will create a better model that optimizes customer costs relative to vendor revenues, and we’ll all be the better for it.

Dave McCandless is an Open Source advocate and the Director of IT for HedgeStreet, Inc. Before joining HedgeStreet, he was chief information officer for Fortel Inc. Previously, McCandless held key positions at Bell Telephone Laboratories, Oracle and Bank of America. He holds a M.S. degree in computer science from the University of Wisconsin.