One reason may be that the ethical arguments of the
Free Software Foundation
are particularly compelling for software developers, who then release Free (and therefore, for the most part, Open Source) Software.
More importantly, I think, is that software developers have realized that software engineering is not a mature field. My understanding of other engineering fields is that there are algorithms known to be effective whose results are provably correct, and that certification in these fields is a means to ensure that these methods are known and used by the certified engineers. Peer review is still important, because it's possible you made a mistake and didn't catch it, but it can generally be accomplished by a relatively small group in substantially less time than it took to produce the design.
None of this is true in software engineering. Academia is still working on proof techniques and has had some success in strictly limited areas; doing this `in reverse' has led to some success in generating effective algorithms for transforming (certain types of, e.g., context-free grammars) specifications (another problem -- 'building does not fall down' can be hard to prove, but can has a relatively straightfoward expansion into rigorous requirements) into software. Peer review not only becomes more important, but more difficult and more time-consuming. Conventional means of obtaining large-scale peer review (publication in a journal) can't pick up the slack for three reasons: first, there simply aren't enough journals for the amount of software produced, even if one ignores size issues; second, the journal will usually finish its peer review in about a year, which is too long for many purposes; and third, most journals aren't interested in actual code, except as illustration.
So what happens when software engineering matures? Free Software won't vanish, but I think there will be less of it: while I expect there to be more than one way to code a provably crash-proof kernel, how many times will somebody bother to prove another one? And the same ethical arguments apply. But what happens to the pragmatic cousin, Open Source? I suspect that will be determined by what happens to the software industry. Certainly, with effective proof techniques, one could imagine independent software auditing houses examining closed source code, certifying it, and sending the binaries out for distribution. How many people will want to see the source if the program never crashes? Commercial software makers are faced with an interesting problem: their product never wears out, so if they sell you one copy of a proved-correct program, why would you ever upgrade?
Well, there are two possibilities, as I see it. First, the feature war will continue, and morph in to the style war, as has happened in almost every other mass-production industry. (That is, very rarely does a single product completely dominate an industry by being 'the best'.) Or, you may see software companies accelerating two trends already in motion: customization/consulting and software rental. A company might ask its software provider for a custom feature, for which the provider charges. Or, the provider might not sell/permanently license their software: you pay a certain amount per period (per user), with the market determining feature expectations and responsiviness to requests. (That is, one provider may be less responsive than another, but charge less to compensate.)
On the other hand, this may happen without mature engineering; Free and Open Source Software continues to get better faster (in my opinion) than the non-Free/closed alternatives, draining the potential out of current business models (licensing the same software over and over again). Already, you see companies making the perspective shift to selling features or services, rather than hardware or software.
for example, Sun takes the position that "software is a feature." In their 1999
annual report, IBM notes that their global services division made 37% of the their total revenue, and is growing three times more quickly than hardware, and twice as fast as software.
So what changes would be unique to software engineering maturing? Once users stop complaining about reliability, what happens? Does the industry's focus shift toward customization? Toward becoming a service, like long distance? Will consumers continue to play the upgrade game, or will computing become more a tool than a status symbol? (Like, for instance, cars -- well, in the US, anyway.)
I'd expect to see an explosion in alternate interfaces and different kinds of applications, because a mature discipline should expand the realm of the feasible. I'd expect cultural changes, with more people putting more trust in computing -- especially if proof techniques extend to security. I expect, if they haven't already by then, that software patents will become much more reasonable: what is and isn't obvious to a trained practioner of the craft (e.g. `one-click' shopping) will be much better defined.
Reality Maintenance Group, Silver City Construction Co., Ltd.