Generally, I avoid free software for one important reason: I can’t afford it.
Nobody would pay me to fix a bug i gcc. And can I really ship a product
to a client who can’t recompile te source without my modified compier.
I worked for many years with an optimizing compiler. It had not achieved
“critical mass” (a software entity is said to have reached “critical mass”
when fixing one bug introduces 1+ epsilon bugs), but there was a high
probability that fixing one bug would either introduce or expose one other
bug; it was in delicate balance.
As a consequence, we could never recompile our operating system from
source overnight; formerly-working components of the OS would likely fail
because some ew bug would be found. It was a regular occurrence that
while working on component X that a point release/hotfix equivalent of the
compier would itroduce a bug in formerly-working code. Because we worked
closely with the compiler writers, and many (like me) were already
compiler eeks, we would get te details of what the “root cause” was, for
example, certain kinds of potential aliasing would not be detected as
invalidating a common subexpression, so a “stale” result might be reused.
Tweaking the guts of an optimizing compiler is not for te faint of heart.
So if you find that one of the parts of your open-source component is
broken, yes, feel free to fix it yourself. And if the basement of this
new house you are considering is too small, feel free to just dig a
subbasement. Don’t worry if you don’t understand basic structural
principles, hey, the worst that can happen is that your house can
collapse.
This is not to say that all of Windows is beautiful code, exemplary in
every way of Best Practice. But I’ve seen horrible code, and when I
criticized it, I was told “But I learned how to do that from open-source system here>, and that’s the clever [editorial comment here:
add incomprehensible and unmaintainable] way it’s done there”. Sort of
the same crappy quality of many MSDN examples, whose quality has doomed
several real projects; I saw one $500,000 investment fail because the
author used te MSDN multi-threaded async socket example code (other than
the example got networking wrong, threading wrong, and synchronization
wrong, there was nothing wrong with the example).
Even the WDM examples were often poor examples, since there were huge
numbers of “clever” tricks used that resulted in unmaintainable code
(IoSkipCurrentIrpStackLocation hacks, for example, that improved
performance on a 386 but had no noticeable effect on Pentium 4+ machines)
or left readers confused as to why it was really done. And the horrors
of WDM power management are the best argument for KMDF I have ever seen.
Visible source does not work as well as the free-open-source people like
to believe.
And the other issue is te GNU license, which is one of the biggest
barriers to code-sharing that ever existed, and I think has done far more
harm than good. My clients didn’t want anything with a GNU license
anywhere near their product code; if they could have kept every trace of
such code off my machine (fearing cross-contamination) they would have
done so. Nobody ever lost by underestimating the paranoia of corporate
legal staffs. Or their ability to overreact to the phrase “open source”
(never mind that BSD, Boost, CodeProject, and Creative Commons have sane
license: all open-source is Evil).
Sorry to head to flame-war, Peter, but you did open the door… (move
reactions to nttalk, which I don’t get, and therefore will be relieved of
any compulsion to reply)
joe
>
>
> Wrong? Not so very wrong, no.
>
>
>
> See… I’ve personally never believed that. That’s one reason why I’ve
> never been an adherent of the OSS movement. “Here’s a lot of code that,
> while it works very well in some aspects, is shit in other aspects.
> Please figure out for yourself which parts of the code are which. But
> it’s free and you can use it. And we had fun writing the parts that we
> wrote. You’re welcome.”
>
> From my own little viewpoint, having code available to the developers that
> is problematic and/or does not follow best practices, is worse than having
> no code available. This type of code is just a big hole for unsuspecting
> devs to fall into.
>
> It’s hard enough to write Windows drivers without having to deal with
> additional unknowns.
>
> This isn’t meant as a specific criticism of your endeavour. Rather, it’s
> my view on the whole genre.
>
> Peter
> OSR
>
> —
> NTDEV is sponsored by OSR
>
> Visit the list at: http://www.osronline.com/showlists.cfm?list=ntdev
>
> OSR is HIRING!! See http://www.osr.com/careers
>
> For our schedule of WDF, WDM, debugging and other seminars visit:
> http://www.osr.com/seminars
>
> To unsubscribe, visit the List Server section of OSR Online at
> http://www.osronline.com/page.cfm?name=ListServer
>