Path: utzoo!utgpu!jarvis.csri.toronto.edu!rutgers!apple!bloom-beacon!gatech!gt-eedsp!baud
From: baud@gt-eedsp.gatech.edu (Kurt Baudendistel)
Newsgroups: comp.lang.c++
Subject: boosting libg++ (was Re: g++ vs. cfront 2.0 in the Real World)
Message-ID: <318@gt-eedsp.gatech.edu>
Date: 13 Jul 89 01:39:32 GMT
References: <799@redsox.bsw.com> <6590194@hplsla.HP.COM>
Reply-To: baud@gt-eedsp.UUCP (Kurt Baudendistel)
Organization: Georgia Institute of Technology
Lines: 87

In article <6590194@hplsla.HP.COM> jima@hplsla.HP.COM (Jim Adcock) writes:
>Does a conforming C++ compiler have to provide streams?  complex numbers?
>Standard C libraries? -- Kind of hard to do anything without these.

Jim has hit the proverbial nail on the head. What exactly are the standard
parts of the g++ library and how do restrictions on them mesh with the
stated goals of the GNU project?

For ``closed'' software products such as compilers and editors, the FSF
distributes useful tools to the masses free of charge, making their lives
easier in the process. I call these ``closed'' products, because they
are used without ``additions'' being applied to them. This is important
because in this case, the copyleft is not forced on products produced
by programmers using these products.

If the FSF can pick up some donations of money or programmers time for 
product extensions, support, or bug location for these ``closed'' products,
that's great. The organization appears to welcome and appreciate the
effort, and all users of the products benefit accordingly.

For ``open'' software products, however, things are not so straight-
forward. ``Open'' products such as libc or libg++ are useful (almost
exclusively) as items to be included as part of the whole system
and extended. It is for this reason that they propogate the copyleft
to anything they are used with.  This is detrimental to their use 
for several reasons:

1. A user who would like to use canned library facilities, such as
   complex classes or printf, just like he uses canned compiler 
   facilities, such as floating point multiplication,
   is not allowed to. The user is constrained by the copyleft
   in how he can use such library facilities.

   But how useful is the compiler without library facilities?
   Most programmers think that printf is part of the C language.
   And it is, in a sense, because of its standardization of i/o.

   This is a shame for C++ since its usefulness lies in its extensibility.
   If ``extended'' C++ was provided, such as via a standard vector
   and matrix manipulation class, people would like to use it.

2. A user who would like to develop new library facilities cannot
   justify releasing them to FSF. If he releases them, he cannot use
   them except under penalty of copyleft.

   This is a shame, because we should want to motivate such people to
   contribute to libg++ and make it better for all of us.

This prompts two questions.

1. Could libg++ be distributed in a ``binary'' form so that those
   who wish to use libg++ without modification can escape the 
   copyleft? This would seem to be pretty easy. 
   
   Inclusion of header files such as ``stdio.h'' 
   do not force a copyleft on a program, so why should ``complex.h''
   or ``matrix.h''? 

2. Or, even better in my opinion, could the copyleft be modified
   somehow so that use of libg++ would exempted from it if either

   a. the user did not extend libg++ in a substantial manner, or

   b. the user provided the FSF with rights to classes developed to
      work with libg++.

   This would be harder to write into the copyleft, but would really
   motivate people to develop classes. If people are producing a lot
   of free software, isn't that better than people producing not a 
   lot of free software?

I recognize that this may seem to fly in the face of the spirit of the
copyleft, but lets be realistic. If we are going to present ``free''
tools to people (such as gcc) and then present some more powerful tools
(such as g++) but throttle the usefulness of these new tools (by
restricting the usefulness of libg++ via the copyleft), are we really
working above board? 

I don't see the point of letting g++ be used without restrictions (as
of the copyleft) but restricting use of libg++ (with the copyleft).

what do you think?
kurt
-- 
Kurt Baudendistel --- GRA
Georgia Tech, School of Electrical Engineering, Atlanta, GA  30332
internet: baud@eedsp.gatech.edu         uucp: gatech!gt-eedsp!baud