bright@Data-IO.COM (Walter Bright) (07/15/89)
In article <318@gt-eedsp.gatech.edu> baud@gt-eedsp.UUCP (Kurt Baudendistel) writes: >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? Might I suggest to potential developers for GNU a solution to the libg++ problem: Redevelop libg++ from scratch. Explicitly make it *PUBLIC DOMAIN*. This would solve those nasty copyright problems. Leave the code to the compiler and development tools copylefted. Just make sure that the libraries are public domain. Make sure that code stubs inserted by code generators (like YACC) are public domain. I think this will still preserve the spirit of GNU. Copylefting library code simply insures that nobody will use them. It's even worse than when some misguided compiler vendors tried to charge royalties for products compiled by their compilers. This practice was soundly rejected by the marketplace (though every once in a while, somebody tries it again!).
jima@hplsla.HP.COM (Jim Adcock) (07/17/89)
>Might I suggest to potential developers for GNU a solution to the libg++ >problem: > > Redevelop libg++ from scratch. Explicitly make it *PUBLIC DOMAIN*. > This would solve those nasty copyright problems. Or just remove the copyleft from the existing libraries. I keep getting tempted to just rewrite this stuff on my own, but to do so is a bore, and clearly to have to waste my time doing so is destructive to the interests of humanity at large. How much better if Gnu would simply lift these restrictions, and I could spend my free time developing new software to share? >Copylefting library code simply insures that nobody will use them. I wish this were the case. I'm afraid some people get sucked into believing Gnu software is really "free"; becoming mislead by the "FSF" nomiker that they can use Gnu software without restriction. In fact many people on the net have mistated this many times. Example: the number of people who don't understand the use of bison is restricted. >It's even worse than when some misguided compiler vendors tried >to charge royalties for products compiled by their compilers. This practice >was soundly rejected by the marketplace (though every once in a while, >somebody tries it again!). Compiled? Or compiled and linked? It would be nice to know that if one bought a compiler one was automatically allowed to distribute executables produced by that compiler, but I don't know how widely allowed this practice is among compiler vendors. I do know we have to go through a painful process of figuring out how to make sure we're not stepping in someone's licensing restrictions everytime we design a product where I work. As a compiler user, this is a pain in the butt. Using an editor to create source code, or a laser printer to print it, doesn't put copyright restrictions on your work. Why should using a compiler to compile and link it put copyright restrictions on your work? What it seems we need is some clever court or congress to explicetly state that one can use a compiler for a language -- including necessary and standard libraries -- to express oneself without reprisal. God help us if people who wrote editors were allowed to restrict what we could do with our work. Why then do we tolerate compiler vendors placing these restrictions on us?
mccoy@accuvax.nwu.edu (Jim McCoy ) (07/18/89)
In article <6590203@hplsla.HP.COM> jima@hplsla.HP.COM (Jim Adcock) writes: >>Might I suggest to potential developers for GNU a solution to the libg++ >>problem: >> >> Redevelop libg++ from scratch. Explicitly make it *PUBLIC DOMAIN*. >> This would solve those nasty copyright problems. > >Or just remove the copyleft from the existing libraries. I keep getting >tempted to just rewrite this stuff on my own, but to do so is a bore, and >clearly to have to waste my time doing so is destructive to the interests >of humanity at large. How much better if Gnu would simply lift these >restrictions, and I could spend my free time developing new software >to share? > Yes, it probably would be easier, but since you seem to think that PD libraries are vitally need, then please make them and release them. "If you aren't a part of the solution, you are a part of the problem." >>Copylefting library code simply insures that nobody will use them. > >I wish this were the case. I'm afraid some people get sucked into believing >Gnu software is really "free"; becoming mislead by the "FSF" nomiker >that they can use Gnu software without restriction. In fact many people >on the net have mistated this many times. Example: the number of people >who don't understand the use of bison is restricted. > Copylefting library code means that no one will steal them. If you want to steal code, then I think GNU should do everything it can to stop you. Bison, as is stated in the manual, includes a part of the GNU code into the generated file (e.g. you are using GNU code). If you don't RTFM, I have no sympathy for you. >>It's even worse than when some misguided compiler vendors tried >>to charge royalties for products compiled by their compilers. This practice >>was soundly rejected by the marketplace (though every once in a while, >>somebody tries it again!). > >Compiled? Or compiled and linked? It would be nice to know that if one >bought a compiler one was automatically allowed to distribute executables >produced by that compiler, but I don't know how widely allowed this practice >is among compiler vendors. I do know we have to go through a painful process >of figuring out how to make sure we're not stepping in someone's licensing >restrictions everytime we design a product where I work. > >As a compiler user, this is a pain in the butt. Using an editor to create >source code, or a laser printer to print it, doesn't put copyright >restrictions on your work. Why should using a compiler to compile >and link it put copyright restrictions on your work? > Using an editor to create source code does not put the source code for the editor (which is probably copyrighted) into your product. Using a laserprinter to print your source code doesn not include font descriptions into your output (although there is currently contention and accusations concerning reverse-engineered fonts) or printer driver code into your printed source code. Using a compiler to compile your source code does not include compiler source code into your source code. Using bison to generate your compiler includes most of the bison parser into your source code. GNU claims that linking in their libraries is using their code, although this is arguable. If you intend to steal GNU code, then use the bison parser and sell your product. If you want to make c++ libraries that everyone can use for commercially hoarded products, MAKE THEM! Don't look to GNU to cater to your wish list. >What it seems we need is some clever court or congress to explicetly state >that one can use a compiler for a language -- including necessary and standard >libraries -- to express oneself without reprisal. God help us if people who >wrote editors were allowed to restrict what we could do with our work. >Why then do we tolerate compiler vendors placing these restrictions on >us? This is total bullshit! What is "necessary and standard"? Who determines what is "necessary and standard"? What if this "clever court or congress" decides later that the new library that you or your company has just released is so usefull and revolutionary that is is "necessary" for rapid progress? The court protects copyrighted source code. If you want to steal code, don't look to the net for help. Currently people looking at C++ have two usefull options: 1) Pay AT&T lots of money and get cfront 2.0 2) Get the GNU g++ compiler for free and make their own libraries if they are doing comercial development. Perhpas we should worry less about how we can "boost g++ libraries" and how any company that offers a free compiler, but doesn't let you steal their code is some kind of devious crypto-fascist organization. Maybe if people keep whining enough about how the GNU copyleft applies to products linked to their library, someone will get fed up with this political BS and make a library. I am comfortable with the GNU restrictions and will continue to use their products, if you are not, then that check should be made out for AT&T as soon as possible. jim ------------------------------< Jim McCoy >------------------------------------ mccoy@acns.nwu.edu | "...far too many notes for my taste" #include <disclaimer.h> | -Phantom of the Opera "To thine own self be true"
jgrace@bbn.com (Joe Grace) (07/18/89)
In article <2053@dataio.Data-IO.COM> you write: > Redevelop libg++ from scratch. Explicitly make it *PUBLIC DOMAIN*. > This would solve those nasty copyright problems. I'm not sure this approach would really work in general since GNU can take software from *PUBLIC DOMAIN* and incorporate it under their copyleft restrictions. Someone pointed out how FSF seems to have taken some government subsidized code, copylefted it, and taken over maintenance of the code --- thereby killing the code's *PUBLIC DOMAIN* availability and utility. (We're talking hoarding here, folks.) Frankly, I think we need something new like copycorrect where code is treated as public domain except that it cannot be copyrighted, copyleft'ed or in any way copyrestricted. Such code would require a support repository and support network --- since presumably "Free" Software Foundation would find supporting such truly free code distasteful. The key is to avoid having the code or its successive versions become copyrighted, copylefted, or otherwise hoarded by any institution or foundation. = Joe = -- Joe Grace ARPA: jgrace@bbn.com UUCP: {harvard,husc6,decvax,etc.}!bbn!jgrace #include <StandardDisclaimer.h> Joe Grace ARPA: jgrace@bbn.com UUCP: {harvard,husc6,decvax,etc.}!bbn!jgrace #include <StandardDisclaimer.h>
scs@itivax.iti.org (Steve C. Simmons) (07/19/89)
jgrace@bbn.com (Joe Grace) writes: >I'm not sure this approach would really work in general since GNU can >take software from *PUBLIC DOMAIN* and incorporate it under their >copyleft restrictions. Someone pointed out how FSF seems to have >taken some government subsidized code, copylefted it, and taken over >maintenance of the code --- thereby killing the code's *PUBLIC DOMAIN* >availability and utility. (We're talking hoarding here, folks.) You can copyright *a particular instantiation* of public domain anything (not just code). For example, the Beach Boys performance of "Sloop John B" is no less valid just because the song is in the public domain. All the copyright does is protect your ownership of your derivation. As an example closer to our field, many CAD/CAM companies have taken SPICE (a PD CAD program), "improved" it or ported it to their system, and sell it. This in no way removes SPICE from PD, nor does the PD status of the original SPICE restrict their instantiation. When FSF copyrights a PD piece of code, this in no way prevents you from using it *provided you don't get it from FSF*. So if OOPSLIB, g++, etc, were actually PD at some point (and I'm not saying they were) you would be free to take a copy *of the original* and do what you please regardless of copyleft. And government subsidised code is not automaticly PD. I believe NSF (National Science Foundation) subsidised code is, but that's not where g++ or oopslib came from. -- Steve Simmons scs@vax3.iti.org Industrial Technology Institute Ann Arbor, MI. "Velveeta -- the Spam of Cheeses!" -- Uncle Bonsai
morrison@accuvax.nwu.edu (Vance Morrison ) (07/19/89)
After following this discussion of copylefts and listening to a lot of people rant at the evil of the copyleft, it occures to be there is a very simple solution to the problem. First, here are the two views FSF - Any software I create I want to be freely accesible. I don't want them makeing changes and calling it their own. Also I want to make sure that people don't make money off of my work unless they add significant value to it (in which case they are making money off their added value). Software Developer - I want to use the GNU code, but I also want to be able to sell it, otherwise I can't make a living. Both views are reasonable, here is my solution. 1) The software developer designs his code using the GNU libraries. 2) He then compiles his modules into object files. 3) He sells his software but distributes it with a linker and the gnu software libraries and gnu source. 4) Part of the installation process is linking his code to the GNU code. Note that the software developer is now selling HIS software object files and distributing his stuff and the GNU stuff. This is all legal and the software developer keeps his stuff off the copyleft (which is his goal), on the other hand, the GNU stuff gets distributed and since the end user is informed that that part is free, and can be used and distributed for other uses. What do you think? Vance Morrison
oz@yunexus.UUCP (Ozan Yigit) (07/19/89)
In article <42888@bbn.COM> jgrace@porter-square.BBN.COM (Joe Grace) writes: >... Someone pointed out how FSF seems to have >taken some government subsidized code, copylefted it, and taken over >maintenance of the code --- thereby killing the code's *PUBLIC DOMAIN* >availability and utility. (We're talking hoarding here, folks.) This is not factual: something that is released to public domain cannot, IN ITS ORIGINAL FORM, be copyrighted by anyone, but even the slightly modified versions may be copyrighted. FSF has a right to take PD code and enhance/modify and make it NON-PD. We have the right to take the same original PD code, and modify the same way, and keep it PD, or to sell it, or hoarde it as we like. >Frankly, I think we need something new like copycorrect where code is >treated as public domain except that it cannot be copyrighted, >copyleft'ed or in any way copyrestricted. If I remember correctly, that is what MIT copyrights are like these days (X windows?), it is copyright but you can do whatever you like with it, enhance it, sell it, hoarde it (:-) whatever. oz -- They are like the Zen students who, Usenet: oz@nexus.yorku.ca when the master points at the moon, ......!uunet!utai!yunexus!oz continue to stare at his finger.... Bitnet: oz@[yulibra|yuyetti] P. da Silva Phonet: +1 416 736-5257x3976
ark@alice.UUCP (Andrew Koenig) (07/19/89)
In article <2219@itivax.iti.org>, scs@itivax.iti.org (Steve C. Simmons) writes: > And government subsidised code is not automaticly PD. I believe NSF > (National Science Foundation) subsidised code is, but that's not where > g++ or oopslib came from. However, all the OOPS (now called NIH Class Library) source code I've seen has prominent proclamations at the front of each source file to the effect that it is public domain and anyone may use it for any purpose. [I guess we already paid for it...] -- --Andrew Koenig ark@europa.att.com
jacob@gore.com (Jacob Gore) (07/19/89)
/ comp.lang.c++ / jgrace@bbn.com (Joe Grace) / Jul 18, 1989 /
Frankly, I think we need something new like copycorrect where code is
treated as public domain except that it cannot be copyrighted,
copyleft'ed or in any way copyrestricted. ...
The key is to avoid having the code or its successive versions become
copyrighted, copylefted, or otherwise hoarded by any institution or
foundation.
----------
Which is almost the entire purpose for the Copyleft: to keep others from
"appropriating" versions of the code. The other requirement it presents
is: If you benefited from this code, then you should let other people
benefit from yours.
It seems that it's the second part that many people are having such a hard
time accepting.
--
Jacob Gore Jacob@Gore.Com {nucsrl,boulder}!gore!jacobtma@osc.COM (Tim Atkins) (07/19/89)
> >Copylefting library code means that no one will steal them. If you >want to steal code, then I think GNU should do everything it can to >stop you. > The concept of stealing is logically dependent on the concept of ownership. I was under the impression that the notion of ownership of software, particu- larly software in the tools category, was precisely what the FSF wished to fight. Personally, I have no problem with the notion of ownership of ones intellectual product and therefore little sympathy with the goals of FSF. I much prefer to trade a fixed number of dollars for other peoples software than the apparent FSF alternative of abrogating my own future rights for the dubious benefit of using their "free" code. - Tim Atkins
baud@gt-eedsp.gatech.edu (Kurt Baudendistel) (07/19/89)
In article <914@accuvax.nwu.edu> morrison@accuvax.nwu.edu (Vance Morrison ) writes: >After following this discussion of copylefts and listening to a lot of >people rant at the evil of the copyleft, it occures to be there is a >very simple solution to the problem[: distribute your code as object to >be linked with gnu code]. This sounds great, but it won't work for libg++ since this library is and must be distributed in source form. However, we've heard rumors of gnu work on ways to pre-compile header files to promote faster compilation. This is desirable, since in many applications, the parsing of class definitions takes lots of time. But how will this affect the copylefting of libg++? Will we be able to use Vance's scheme for libg++ in pre-compiled form? And when will such a facility be available? kurt -- Kurt Baudendistel --- GRA Georgia Tech, School of Electrical Engineering, Atlanta, GA 30332 internet: baud@eedsp.gatech.edu uucp: gatech!gt-eedsp!baud
scs@itivax.iti.org (Steve C. Simmons) (07/19/89)
I scs@itivax.iti.org (Steve C. Simmons) write: >And government subsidised code is not automaticly PD. I believe NSF >(National Science Foundation) subsidised code is, but that's not where >g++ or oopslib came from. Several people have written to tell me that the default for government subsidised code is public domain. I stand corrected. -- Steve Simmons scs@vax3.iti.org Industrial Technology Institute Ann Arbor, MI. "Velveeta -- the Spam of Cheeses!" -- Uncle Bonsai
seindal@skinfaxe.diku.dk (Rene' Seindal) (07/19/89)
morrison@accuvax.nwu.edu (Vance Morrison ) writes: > Both views are reasonable, here is my solution. > 1) The software developer designs his code using the GNU libraries. > 2) He then compiles his modules into object files. > 3) He sells his software but distributes it with a linker and the > gnu software libraries and gnu source. > 4) Part of the installation process is linking his code to the GNU code. > Note that the software developer is now selling HIS software object > files and distributing his stuff and the GNU stuff. This is all > legal and the software developer keeps his stuff off the copyleft > (which is his goal), on the other hand, the GNU stuff gets distributed > and since the end user is informed that that part is free, and can > be used and distributed for other uses. > What do you think? I think it will make the binaries the customer has linked freely distributable, since they are derived from GNU software (the libraries). The software developer no longer has to make the source code available, but can't prevent customers from redistributing the binaries. That'll harm the profitability of the product. Rene' Seindal (seindal@diku.dk).
jima@hplsla.HP.COM (Jim Adcock) (07/20/89)
I believe a lot of people are mistating a lot of the issues here:
I don't believe one can "trivially" derive a work and place a new copyright on
it. You must substantially derived the work before you can place a new
copyright on it.
In any case, if both PD and slightly different FSF versions of a PD product
are floating around, then the ownership issue, "who derived from who" issues
etc, rapidly develop, and people who work for companies can no longer use
the software. Because software they use must be clearly "in the clear."
I claim the following is a "standard" C++ program:
#include <stream.h>
void main()
{
cout << "Am I in the clear?\n";
};
If I use compilerX to compile this, am I in the clear? Many claim yes --
I claim NO!
If I use compilerX to compile and link this, am I in the clear? Most say
no, and I agree with them.
Even compiling this most trivial, standard C++ example embroils one in
a zillion issues. A .h file is used to include in-line functions. Does
that violate the copy[left/right]? Linking main causes _main to be called.
Is copy[left/right] violated? Running the compiler causes one or more
lines of assembly to be emitted "in source form" from the guts of the
compiler. Is copy[left/right] violated? The compilation contains multi-lines
from the compiler to be emitted to handle "new's." Copyleftright violated?
Multiple lines of stuff from the compiler get emitted to handle initialization.
Copyleftright violated? Or I qoute examples one the net of the kind of code
compi lerX generates for some of these things. Have I violated the
copy[left/right]?
These issues are much more complicated and serious in C++ than C since
C++ compilers include much larger portions of their source in the generated
code in a much larger number of standard circumstances.
How is this different than if I send a copy of my listing to some [hypothetical]
Postscript clone that in the process of generating all those pretty black dots
on white paper makes an intermediate representation that includes the notice:
Copyright 1992 JoeSchmuck Corporation
Did my brilliant new novel that I printed turn into the property of JoeSchmuck?
If I run my code through compilerX in order to turn it into executable dots
on disc, and if as part of that process compilerX generates an intermediate
form claiming:
Copyright 1992 JoeSchmuck Corporation
does my code now belong to JoeSchmuck?
I am not asking to be able to steal FSF code, nor anybody elses code.
I am asking that I be able to use C++ compilers, including the standard,
normal, everyday features of the language, without having compiler vendors
steal *my* code. Said standard features including streams, complex numbers,
new, delete, _main, object initialization protocols, etc.
Further, it does me no good to make PD versions of these things if 1)
they can't be reused between different compilers 2) if JoeSchmuck Corp.
is going to just turn around and slap their copy[left/right] on it also,
clouding the ownership issue again.damon@upba.UUCP (07/20/89)
> When FSF copyrights a PD piece of code, this in no way prevents you from > using it *provided you don't get it from FSF*. So if OOPSLIB, g++, etc, > were actually PD at some point (and I'm not saying they were) you would be > free to take a copy *of the original* and do what you please regardless of > copyleft. Actually, this is not exactly right. Anything that is entered into the public domain is irretrievably in the public domain. If FSF is distributing public domain source verbatim, their copyright is invalid and wil not stand up in court. I don't think it makes any difference if you got the code from them or now. They never had a copyright claim to begin with. The issue for copyright on changes become a complex on. In the case of bug fixes and minor improvements, what they have is probably a derived work and the public domain status should stay the same. They are, however, entitled to a copyright on any major improvements they have made to the code. However, my understanding is that copyright does not apply to whole work, but rather just to their changes. In conclusion, you can't pick up a public domain work and decide that you now hold a copyright on it. After being involved with copyright law in the recent past a few interesting questions have come to mind about FSF copyright restrictions: 1. Have these copyrights been registered with the copyright office? 2. Given that an "unusual" copyright really isn't valid until it's been tested in court, has the FSF ever sued anyone for violation of their restrictions? 3. Is it true that any of their code has been developed with government sponsered monies? You don't need to pay salaries to satisfy this requirement, just use a machine at a university purchased with goverenment money. I don't mean to sound like I am unsympathetic to the FSF views. I support fully their right to determine the restrictions on their own code, but JUST their own code. I don't appreciate them trying to tell me what to do with my code. Without having gone back and reread the GNU license, it seems to me that their restriction on redistribution of source only applies to their libraries. If I compile a program with their compiler, link it with their libraries and sell it, I am only bound to redistribute their library code in source. Damon Scaggs uunet!frith!upba!damon
bright@Data-IO.COM (Walter Bright) (07/20/89)
In article <42888@bbn.COM> jgrace@porter-square.BBN.COM (Joe Grace) writes:
<In article <2053@dataio.Data-IO.COM< you write:
<< Redevelop libg++ from scratch. Explicitly make it *PUBLIC DOMAIN*.
<< This would solve those nasty copyright problems.
<I'm not sure this approach would really work in general since GNU can
<take software from *PUBLIC DOMAIN* and incorporate it under their
<copyleft restrictions. Someone pointed out how FSF seems to have
<taken some government subsidized code, copylefted it, and taken over
<maintenance of the code --- thereby killing the code's *PUBLIC DOMAIN*
<availability and utility.
You can copyright a work derived from a public domain work. However, when
it's copyrighted, you must state on the copyright registration form what
pd work it comes from. Otherwise, you are lying on the form.
Copyrighting a derived work doesn't change the status of the original
work. What you've actually copyrighted are the diffs.
There's nothing stopping *anyone* from reimplementing libg++ from scratch
and making it pd. Neither GNU nor RMS can stop you. The only thing they
can do is not put it on the tape that they send out. The pd version of
the library can be posted on this net.
Why don't I do it? Well, I'm in this business for fun and profit. I sell
source to C and C++ libraries.
Most library routines for C and C++ are pretty obvious and straightforward
to implement. The exceptions are qsort() and the transcendentals. The
transcendentals can be produced fairly easily following the cookbook
approach described by Cody&Waite. qsort() is a *bear* to do. Note: all
magazine versions I've seen suffer serious problems. My friend Joe Huffman
who wrote my qsort() is able to cause most compiler vendors' qsorts to
crash. (He implemented it based on somebody's PhD thesis on qsort!)
If you're doing a project and want to use GNU C but not their library,
you also can buy library source code from any number of vendors (Turbo C,
MSC, Zortech C, etc), port the library, and link with GNU output.beard@ux1 (Patrick C Beard) (07/20/89)
Is anybody else sick of this topic? Couldn't we discuss this more effectively on the GNU newsgroup? Some of us have never, and probably will never consider using GNU products. This topic is for technical discussion of a language that a lot of people are getting excited about. Let's concentrate on getting the word out about the benefits of using the language, and not on the details of whose system is best to use. I for one, am sick of this discussion. ------------------------------------------------------------------------------- - Patrick Beard, Macintosh Programmer (beard@lbl.gov) - - Berkeley Systems, Inc. ".......<dead air>.......Good day!" - Paul Harvey - -------------------------------------------------------------------------------
mgardi@watdcsu.waterloo.edu (M.Gardi - ICR) (07/20/89)
Okay, it is time I asked.....What in blazes is CopyLeft??????????? p. Peter DeVries Mutual Life of Canada (519) 888-2957 c/o mgardi@watdcsu
mhyman@hsfmsh.UUCP (Marco S. Hyman) (07/20/89)
In article <6590206@hplsla.HP.COM> jima@hplsla.HP.COM (Jim Adcock) writes: > How is this different than if I send a copy of my listing to some [hypothetical] > Postscript clone that in the process of generating all those pretty black dots > on white paper makes an intermediate representation that includes the notice: > > Copyright 1992 JoeSchmuck Corporation > > Did my brilliant new novel that I printed turn into the property of JoeSchmuck? One of the rights protected by copyright is the *exclusive* right to all derivative works. In the example above the intermediate representation is a derivative of the original copyrighted work and therefore falls under the rights of the original auther. In the case of including a library header file, however, who is deriving work from whom? I think fair use enters the game about here. Ask your lawyers. --marc -- //Marco S. Hyman //UUCP: ...!sun!sfsun!hsfmsh!mhyman //Domain: sfsun!hsfmsh!mhyman@sun.com
charliek@madmax.UUCP (Charlie Krasic) (07/20/89)
In article <914@accuvax.nwu.edu> morrison@accuvax.nwu.edu (Vance Morrison ) writes: >After following this discussion of copylefts and listening to a lot of >people rant at the evil of the copyleft, it occures to be there is a >very simple solution to the problem. [stuff deleted...] >Both views are reasonable, here is my solution. >1) The software developer designs his code using the GNU libraries. >2) He then compiles his modules into object files. >3) He sells his software but distributes it with a linker and the > gnu software libraries and gnu source. >4) Part of the installation process is linking his code to the GNU code. [more stuff deleted...] >Vance Morrison Sounds good, but what about stuff like Bison and Flex? I'm new to GNU (and Unix) software, but my understanding is that these programs insert code. In order to get a working product you have to mix your own code with theirs (FSF). I am thinking about starting a project which relies pretty heavily on Bison, so I would be really interested in a scheme which doesn't require me to give my product (or the source) away. Charlie Krasic p.s. I guess my question has little to do with comp.lang.c++, but I was not sure where to put it. -- Charlie Krasic 3755 Riverside Dr. VOICE: (613) 738-1338 ext.5157 Cognos, Inc P.O. Box 9707 FAX: (613) 738-0002 Ottawa, Ontario CANADA K1G 3Z4 UUCP: uunet!mitel!sce!cognos!charliek
jima@hplsla.HP.COM (Jim Adcock) (07/21/89)
> Is anybody else sick of this topic?
Well, I'm certainly sick of not getting anywhere on it. C++ is about code
reuse. Object oriented design is about code reuse. People cannot reuse
code that they cannot or will not share. The C++ community must work out
reasonable, fair, equitable ways of doing this. Until then, we're not going
to get anywhere. People who work for companies are going to have to be able
to get a reasonable, fair profit from their work, or their managers won't
let them share. People who work for companies can't use other's software
if clear title cannot be determined. People who work in acedemia can't
share software that's over priced, or has very restrictive licensing.
Proprietary agreements between companies keep the people involved from sharing
almost anything. Neither copyright, copyleft, nor software patents seem to
be the answer. And each compiler writer comes up with a privately generated
set of base libraries, guaranteeing enough gratuitous incompatibilities to
drive us all batty forever.
There must be some fair ways to share software, which aren't going to stop
people from doing what they want or need to do. I just don't know the
answer.sacco@eileen.mga.com (Joseph E. Sacco) (07/21/89)
The bandwidth in this newsgroup over copyleft issues has expanded
greatly over issues of libg++ and copyleft. I will attempt to put this issue to
rest.
Peter DeVries asked "What in blazes is CopyLeft????????????"
Peter,
Copyleft is the Free Software Foundation's "copyright" [get it?
FSF humor]. In essense the purpose of copyleft and the "charter" of FSF is to
prevent software "hoarding" and facilitate the free exchange of ideas. If you
incorporate a chuck of "copyleft" code into an application, that application
becomes copylefted. That means you have to make the source code for that
application available. It's an academic sort of idea which is perfectly suited
for academic purposes. If you are a commerical software developer, what this
means is you cannot steal FSF code.
The recent flurry of net interest in this issue arose from AT&T's
tenfold price increase of C++. Small commerical operations that were stung by
this policy change are looking at FSF's g++ as a viable alternative. The "problem" is that g++ comes with Doug Lea's libg++ library which is under copyleft. That means that you can use g++ [or gcc] to compile your source but you cannot use
Doug's library without invoking copyleft. This "problem" with libg++ is not
really a problem since there is very little in Doug's library that you really
need to use g++. You may have to create your own stream package but Bjarne
has already shown you how to do that in his book.
The issue here is simple: Doug Lea placed his library with FSF so
people can study and learn from it. It is not placed there for commerical
vendors to steal. I respect his wishes. I am too far away from Oswego to take
a course from him and yet I benefit from his work by studying his code. If
there is something in his library that I would really like to use in a
commerical product I will write my own version. If I am incapable of writing
my own version I should not be in this business.
So, study it, learn from it but don't steal it. I think folks can
live with that. I certainly can.
JosephTim_CDC_Roberts@cup.portal.com (07/21/89)
> Is anyone else sick of this topic?
Why should this topic be moved to the GNU group? I consider this thread
to be a discussion of a valid issue in C++, and therefore a legitimate
topic for the C++ group.
If anything, it should be cross-posted (collective gasp) to GNU.
Tim_CDC_Roberts@cup.portal.com | Control Data...
...!sun!portal!cup.portal.com!tim_cdc_roberts | ...or it will control you.sidney@saturn.ucsc.edu (Sidney Markowitz ) (07/21/89)
In article <329@gt-eedsp.gatech.edu> baud@gt-eedsp.UUCP (Kurt Baudendistel) writes: >In article <914@accuvax.nwu.edu> morrison@accuvax.nwu.edu (Vance Morrison ) writes: >>After following this discussion of copylefts and listening to a lot of >>people rant at the evil of the copyleft, it occures to be there is a >>very simple solution to the problem[: distribute your code as object to >>be linked with gnu code]. > >This sounds great, but it won't work for libg++ since this library is and >must be distributed in source form. You only have to make the copylefted sources available, you can still distribute the binaries, and you can charge for the media and handling costs of distributing the source. I quote from the FSF copyleft, otherwise known as "GNU GENERAL PUBLIC LICENSE, Version 1, February 1989" which comes with the statement "Copyright (C) 1989 Free Software Foundation, Inc. 675 Mass Ave, Cambridge, MA 02139, USA" Along with stating that any modifications or derived works of the software must be covered under the same terms of being freely distributable and with source code available, it says: "Mere aggregation of another independent work with the Program (or its derivative) on a volume of a storage or distribution medium does not bring the other work under the scope of these terms." Well, I'm not a lawyer, so I don't understand why you can't package libg++ (binary and source) on a tape with your proprietary object files and have a customer do the link as part of installation, but here's something that just came from rms himself on the info-gcc mailing list. It's not quite the same, but it's about packaging code to be linked with FSF code by the user. [begin quote] Date: Thu, 20 Jul 89 18:54:55 EDT From: rms@ai.mit.edu To: info-gcc@prep.ai.mit.edu Subject: Next and copyleft A few weeks ago, I found out, along with the readers of this list, that NeXT was distributing proprietary code for the user to link with GCC. A while later, I told them this was not permitted and asked them to stop. Apparently, through a noisy communication channel with me, they had got the impression that I had said this was ok. They agreed to stop distributing the proprietary front-end, as I requested. They have written a new, free objective C front-end which will be released soon by them, and merged into the standard GNU C distribution when I have time. [end quote] -- sidney markowitz <internet: sidney@ai.mit.edu or sidney@saturn.ucsc.edu>
davidm@cimshop.UUCP (David Masterson) (07/22/89)
In message <42888@bbn.com>, jgrace@bbn.com writes: >The key is to avoid having the code or its successive versions become >copyrighted, copylefted, or otherwise hoarded by any institution or >foundation. > Isn't this a copyleft? No really, by your definition, someone still can't use libg++ because its *public domain* and using it in a copyrighted work would take it out of the public domain. David Masterson uunet!cimshop!davidm or DMasterson@cup.portal.com
jima@hplsla.HP.COM (Jim Adcock) (07/22/89)
>Okay, it is time I asked.....What in blazes is CopyLeft???????????
"Copyleft" is slang terminology for the restrictive licensing terms imposed
on software from Gnu aka FSF aka "Free Software Foundation." These licensing
terms say what you can and can't do with their software, and what you have
to do with your software if you use their software. Along with these
licensing terms there is an associated philosophy, outlined in the
"Gnu Manifesto."
If you haven't seen these things yet, the easiest thing to do is probably
to find someone who is using Gnu Emacs, and read their copy of the licensing
terms and Manifesto. Alternately, people using g++ should be able to show
you a copy.jgrace@bbn.com (Joe Grace) (07/22/89)
In article <441@cimshop.UUCP> davidm@cimshop.UUCP (David Masterson) writes: >In message <42888@bbn.com>, jgrace@bbn.com writes: >>The key is to avoid having the code or its successive versions become >>copyrighted, copylefted, or otherwise hoarded by any institution or >>foundation. >> >Isn't this a copyleft? I think Jim Adcock recently (in 2 different articles) explained the problems better than I did. Anyway, copyleft restricts the use of its software. The "copycorrect" I suggested was meant to make software reusable for free. >No really, by your definition, someone still can't use >libg++ because its *public domain* and using it in a copyrighted work would >take it out of the public domain. > >David Masterson >uunet!cimshop!davidm or DMasterson@cup.portal.com libg++ is not public domain, it is copylefted (does that really mean it's copyrighted with a copyleft?). Companies can't afford to use it because it requires the copyleft'ing of libg++-unrelated source code. Kind of like adding a book to a library of your personal works, and losing exclusive rights to your own books! It kind of turns my stomach to think about such an unfair licensing agreement, especially when toted as "free" software. = Joe = Joe Grace ARPA: jgrace@bbn.com UUCP: {harvard,husc6,decvax,etc.}!bbn!jgrace #include <StandardDisclaimer.h>
dbk@mimsy.UUCP (Dan Kozak) (07/22/89)
From article <6613@madmax.UUCP>, by charliek@madmax.UUCP (Charlie Krasic): > Sounds good, but what about stuff like Bison and Flex? > I'm new to GNU (and Unix) software, but my understanding is that these > programs insert code. In order to get a working product you have to mix > your own code with theirs (FSF). True of Bison, I'm not sure about Flex. > I am thinking about starting a project which relies pretty heavily on > Bison, so I would be really interested in a scheme which doesn't > require me to give my product (or the source) away. Here's a scheme: buy another parser generator. As rms has said time again, FSF's goals are primarily political and "free" means "liberty/freedom" not "without cost." FSF's software is supposed to be a carrot to encourage other's to share their work in the same manner that FSF has shared their's. It seems to me that if you don't wish to participate in the copyleft that is up to you, but you must realize that you cannot get the benefits of copylefted software unless you do. (nottwithstanding certain tricks recently proposed here to subvert the copyleft while abding by the letter of the law; these will most likely cause the FSF to burn precious cycles working on modified wording for the GPL - you people ought to be ashamed of yourselves!). -- #dan Clever: dbk@mimsy.umd.edu | "For I was rolled in water, Not-so-clever: uunet!mimsy!dbk | I was rolled out past the pier" - MoB
jeff@aiai.ed.ac.uk (Jeff Dalton) (07/23/89)
In article <42888@bbn.COM> jgrace@porter-square.BBN.COM (Joe Grace) writes: >In article <2053@dataio.Data-IO.COM> you write: >> Redevelop libg++ from scratch. Explicitly make it *PUBLIC DOMAIN*. >> This would solve those nasty copyright problems. > >I'm not sure this approach would really work in general since GNU can >take software from *PUBLIC DOMAIN* and incorporate it under their >copyleft restrictions. Someone pointed out how FSF seems to have >taken some government subsidized code, copylefted it, and taken over >maintenance of the code --- thereby killing the code's *PUBLIC DOMAIN* >availability and utility. (We're talking hoarding here, folks.) The public domain code's public domain status has not changed. Anyone can take public domain code and make a restricted product out of it. No improvements they make will become public domain. Indeed, they will tend to be much more restricted than FSF's improvements would be. Anyone can still go back to the original public domain code, however, and build from that. If someone writes a public domain libg++, it would stay public domain. However, improved versions might not be public domain. Do you think FSF shouldn't be able to copyleft improvements they write?
benson@odi.com (Benson I. Margulies) (07/23/89)
In article <18684@mimsy.UUCP> dbk@mimsy.UUCP (Dan Kozak) writes: >From article <6613@madmax.UUCP>, by charliek@madmax.UUCP (Charlie Krasic): > >> Sounds good, but what about stuff like Bison and Flex? >> I'm new to GNU (and Unix) software, but my understanding is that these >> programs insert code. In order to get a working product you have to mix >> your own code with theirs (FSF). > >True of Bison, I'm not sure about Flex. Definitely not true of flex. I note in passing a few things: 1) the relevant piece of bison is a not-particularly-special implementation of published algorithms. If you can't afford a really good parser generator, all you have to do is re-engineer bison.simple. If you wanted to have some fun, you could then release that into the public domain. 2) As the exchange with NeXt demonstrates, the only definition of what the CopyLeft permits is what rms says it permits. Until there is legal action, everyone is on their own. Now, one might say, "if you go along with the intent of the FSF, there's no problem." The following suggests a possible flaw in this: Note that "copyleft" depends critically on copyright. FSF or whoever holds the copyright, and the so-called general public licence grants some restricted rights to use and make derived works. Were the FSF to get into serious financial trouble, its copyrights could wind up owned by anyone. If this anyone didn't have an ideological belief in socialist software, (and I choose that word to be descriptive, not red-baiting), they would have a great incentive to demonstrate that the GPL was somehow legally inoperative, or a least a lot more restrictive. -- Benson I. Margulies
pj@hrc63.uucp (Mr P Johnson "Baddow") (07/24/89)
Surely you can get around the GNU copyleft by selling the customer a set of objects which s/he then links with the GNU libraries (which you happen to have proided according to the terms of the GNU license). With "bison", this is not so easy, but it is still possible. One way might be to take the parser, diff it with the skeleton bison parser, and sell the diff files and a script to reconstitute and compile your parser (or you could just sell the parser source and have done). The other input (the skeleton bison parser) will of course be handed to the client free. Just to make it totaly clear, you could put all your stuff on one tape and the GNU stuff on another tape. Alternatively you could allege that this could be done, and that therefore selling a tape with an executable on it plus another tape containing the GNU source is equivalent and therefore legal. The FSF might be able to persuade a court otherwise, but I would not bet on it. -- Paul Johnson, | `The moving finger writes, And having writ, moves on,' GEC-Marconi Research | Omar Kyham when contemplating `vi'. ------------------------------------------------------------------------------ The company has put a radio inside my head: it controls everything I say!
jima@hplsla.HP.COM (Jim Adcock) (07/25/89)
> Well, I'm not a lawyer, so I don't understand why you can't package > libg++ (binary and source) on a tape with your proprietary object > files and have a customer do the link as part of installation, but > here's something that just came from rms himself on the info-gcc > mailing list. It's not quite the same, but it's about packaging code > to be linked with FSF code by the user. Well, I'm not a lawyer either, but my job entails writing software to be burned into ROMs and made part of real time electronic test equipment. [Digital oscilloscope-like stuff] So the link idea wouldn't work for me in any case. Maybe someone else can write software to link together their part and the Gnu library when a customer invokes a software program. This all sounds pretty disgusting and ass-backwards to me though. This still doesn't address the issue of .h files and in-line functions in C++. Seems to me this keeps run-time linking from being a "solution."
jima@hplsla.HP.COM (Jim Adcock) (07/26/89)
>Do you think FSF shouldn't be able to copyleft improvements >they write? I don't think anyone ought to be able to copyright/left trivial derivations of someone else's work. All this is plagiarism. All this does is cloud ownership. This is different from making a substantially different work based on someone's initial efforts. I have no problem with that. Examples of trivial derivations: Just adding your copyright/left to someone else's work. Fixing a few bugs, then adding your copyright/left. Adding a few functions, then adding your copyright/left. Modifying software to run on a different compiler, or machine, then adding your copyright/left. Glomming together several chunks of software, then adding your copyright/left. Adding an overriding copyright over a complete work of software, part of which is PD, or copyleft, or someone else's work. Again, if we are ever going to be able to share software, people must not take actions that cloud the ownership or origins of software. To be able to reuse software, users must be able to figure out who wrote the software, and what the restrictions [if any] there are on its use. Trivial derivations and other forms of plagiarism prevent this.
jpainter@tjp.East.Sun.COM (John Painter - Sun BOS Hardware) (07/26/89)
Regarding CopyLeft (by the way is that trademarked or in the PD? trademarking it could
provide amusement to FSF hasslers) The following are MY views on the problem:
1) Use FSF software and play by thier rules
2) Ignore thier rules and hope FSFs legal budget is small
3) Use FSF code generators that do not include code written by FSF
contributors in output (a compilers output is NOT a derivitive
work of the compiler authors)
3a) Write your own libs/parsers to go with part 3
4) Link your code to thiers on the customers time (to avoid part 1) and
provide FSF sources but not yours (requires part 2 for fewest hassels)
5) Provide your source in say Kansas City standard audio cassette format.
(or any other equally obscure form. Say barcode on microfiche, etc ...)
6) Hire a GOOD lawyer to talk to their lawyer and work something out before
committing to parts 1-5
I personnally would reccomend only part 6 to anyone with anything to lose
and part 1 for most others. Part 2 probably holds true given what they are
trying to do, but truley takes unfair advantage (and may influence a court in
decisions against you)
By the way ... A copyright holder also has rights to the derivitive works
based on his work, so FSF can not apply copyleft (CopyLeft (r)?) to works
the author has copyrighted but allowed to be used freely by the public
(copycorrect?) PD software is just that and FSF can do with it what they want
without obligation to anyone.
I am not a lawyer. comp.legal is a GREAT idea.
/Tjp