Been thinking about Joel Spolsky's essay where he talks about two corporate strategies: land grabs and slow growth. At the same time, I have been thinking about Crossing the Chasm's model for technology adoption (really industry acceptance (a bell curve, basically)). Some random observations leaking out of these thoughts. Modeling the software development world using these concepts made for an interesting gedanken experiment, with some interesting things falling out of it as my mind wandered from possible to totally improbably =)
The use of open source software has probably moved into the early-majority phase of the adoption curve. The use of OSS is pretty much accepted by >50% of the people and companies developing software, I would suspect, and this is being conservative. Using open source isn't a differentiator, it is a fact for most people now. This is good -- for simple financial reasons, as well as lots of ones of less easily provable nature espoused by more politically motivated individuals (even if I agree with em ;-).
So what effect does this have? We've apparently had a [noisy|quiet] revolution in software development. The revolution is over (who blogged this recently? I want to link to you, but cannot find it! (found (was Matthew Langham) by Scott), is the world different? It's certainly cheaper and easier to provide services and products to people (iow, to put other people's money in your wallet with them happy about it) =)
One thing, particularly fun to think about, is the conceptual land grabs. Maybe I am more observant now than I used to be, maybe it is just clearer now that the waters are settling. Concepts follow the same adoption curve as technology products -- the early conceptual land grabs defined the landscape we have played the drama out on. The earliest land grabs in software were in the universities and research labs. Lexical scoping is something we take for granted, until, as a coworker pointed out to me recently, emacs lisp is dynamically scoped. These are taken as fundamentals now, the way things are, but some dinosaurs still ignore them (sorry, had to jab at the emacs folks ;-).
In the open source revolution early land grabs (by the innovators) were attempted by various people. License space is almost cleanly divided between BSD and GPL derivitives. They grabbed everything they could early, conceptually, and now dominate the thought market in licensing.
Now that open source can go in through the front door (to borrow an analogy from Tim Bray) there is a scramble to figure out how that is going to happen. The most recent conceptual land grab attempt here, that I can think of, is JBoss's grab for the way open source is perceived in the majority (the center of that adoption curve) corporate world. IBM, Sun, Novell, and othes tried the same thing (success or ongoing ? is up to you) pushing Linux, and being the early adopters they are, have simply been using it (not linux, general open source software), and selling it under a different license, for years.
The interesting part is the stuff that is (high-risk high-yield) right now is the big enterprise app space. Operating Systems are (high-risk no-yield), the only way to compete is to pay people to use it, see OpenSolaris (which I am incredibly excited about, for the record).
On the other hand, the success of the revolution, and the almost complete commoditization of big-enterprise-grade-components is pushing a *lot* of software into the realms of open source. Bob McWhirter, for instance, just went way ahead of the curve to find a really interesting niche -- helping companies open source existing products. Cool stuff, and as soon as I grokked it I realized there is a definite need there. I don't know if there is enough market to make a big company of it, but I think there is certainly enough to keep Bob and Ben busy for a while.
So if the revolution is over, what's next? Open source won -- we are all integrators now, tying together lots of [freely|cheaply] available [components|frameworks|libraries] via their exposed API's, instead of implementing from scratch on top of a runtime.