Re: Error compiling templates

[craig at jcb-sc dot com]

>As I am not an expert I could not prove that the above IS A BUG.  But as all
>other compilers (Sun, HP, Microsoft) can compile our code, we would have to
>DROP our support for Linux or gnu compiled binaries.  I am personally a fan
>of Linux/Gnu, but this definitely shows how they are NOT for commercial use
>(anybody cares?).

If you are paying for support, then you can ask whoever you are paying
to investigate the bug for you.

If you are not paying for support, then you are not making commercial
use of GNU/Linux or whatever.  So, indeed, for *you*, that software
is not for commercial use, even though you might be making a profit
off of it for the time being.

So many people pay for support that several companies are making decent
profits from it.  They're usually the people whose bugs get the most
attention -- once it's clear that they are bugs, not just differences
among compilers.  That's because the companies (or individuals) offering
support see to it that the bug fixes get into the original GNU source
code, for future releases.

If you intend to make money off of free software, you should be prepared
to pay for support, or acquire the necessary expertise to support it
yourself.  (If you do the latter, and become known as someone who is an
expert, your bug reports will get much more attention than they do now, so
self-support *is* an option.)

In that sense, free software is just like proprietary software, except
you have the option of acquiring expertise by examining the products
itself.

As far as trying to make sure any GNU product always behaves exactly
as does any other similar proprietary product -- to the extent we've
tried to do that, we've thrown our volunteer resources down a black
hole.  I.e. it's a waste of time.  So we've learned to pretty much
ignore the complaint that "some other compiler(s) accepted this code"
as evidence of a bug in GCC.

One incentive for those other compiler companies is to make their
compilers compile legacy code without modification, for benchmark
purposes.  On the GNU side, at least some of us would prefer GCC
(or, in many specific cases I know about, the g77 component)
rejects constructs that, while perhaps present in legacy code, represent
either outright bugs or likely sources of future bugs.  In that comparison,
GNU cares more about its end users and robust *overall* products -- vendors
of other compilers care most about "closing the deal", i.e. the non-
technical marketing guy who has to sell the product in a benchmarking
situation, who they'd rather not have to say to the prospect, "your code
is broken here, let's fix it and then try again".

It's your choice which kinds of mentality you wish to reward, bring into
your shop, and force your customers to accept (with or without their
knowledge).

But, if you're not paying anyone to support your support of GNU/Linux,
then few people will care that you decide to drop that support...except
perhaps for your customers, who might decide to take their business
elsewhere.

So I suggest you re-examine what you call your "support" for GNU/Linux.
>From your post, I'd have to conclude it really isn't "support" in the
usual sense -- you want to profit by claiming you offer it when talking
to your customers, but won't follow through by actually supporting it
internally (by purchasing support contracts on the appropriate components,
such as g++, or acquiring the appropriate expertise to determine whether
your C++ code contains a bug).

Even aside from the issue of avoiding lawsuits, it's usually wise to not
lie to customers.

        tq vm, (burley)