GPL & gforth 
Author Message
 GPL & gforth

        I hope I haven't been flaming anyone about gforth or the use of
the GPL. I'll be happy if I can write to the gforth extensions as a widely
available dialect of forth. I'd be even happier if I found a way to make a
minor contribution. And working on BMW, it can be a whole lot more fun to
use than a smaller forth.

        I think a much better analogy to the problem is the difference
between porting software and portable software. A license is a legal
program for using copyright and other property and contract law to achieve
a certain effect (except of course the 'bench checking' *is* the running
of the program). If the intended effect of the GPL license is the rights
and responsibilities that a user of a GPL'd C compiler with LGPL'd
libraries has, with respect to private use and open source redistribution,
the GPL license is a portable legal program between C and Forth compilers.
If the intended effect also includes the rights and responsibilities with
respect to commercial distribution, it is not portable.
        With any luck, the bug in the legal program won't bite me, and I'd
like to thank John Wavrik, Anton Ertl, Bernd Paysan, Peter Knaggs, Klaus
Schilling, Bart Lateur, Rick Hohensee and (getting tired of scanning the
list) everyone else who contributed their thoughts and/or reactions to the
discussion in this thread. And (again) Anton, thanks for the advice.

Virtually,

Bruce R. McFarling, Newcastle, NSW



Sun, 01 Apr 2001 03:00:00 GMT  
 GPL & gforth
I just came across this sig on comp.dsp. It seems apropos.

[quote]
+-------------------------------------------------+

+-------------------------------------------------+
"He who writes the code gets to choose his license, and nobody
else gets to complain" -- Linus Torvalds

==================================================
[endquote]

Regards to all.

Jerry
--
Engineering is the art       |      Let's talk about what
of making what you want      |      you need; you may see
from things you can get.     |      how to do without it.
---------------------------------------------------------

Quote:

>         I hope I haven't been flaming anyone about gforth or the use of
> the GPL. I'll be happy if I can write to the gforth extensions as a widely
> available dialect of forth. I'd be even happier if I found a way to make a
> minor contribution. And working on BMW, it can be a whole lot more fun to
> use than a smaller forth.

>         I think a much better analogy to the problem is the difference
> between porting software and portable software. A license is a legal
> program for using copyright and other property and contract law to achieve
> a certain effect (except of course the 'bench checking' *is* the running
> of the program). If the intended effect of the GPL license is the rights
> and responsibilities that a user of a GPL'd C compiler with LGPL'd
> libraries has, with respect to private use and open source redistribution,
> the GPL license is a portable legal program between C and Forth compilers.
> If the intended effect also includes the rights and responsibilities with
> respect to commercial distribution, it is not portable.
>         With any luck, the bug in the legal program won't bite me, and I'd
> like to thank John Wavrik, Anton Ertl, Bernd Paysan, Peter Knaggs, Klaus
> Schilling, Bart Lateur, Rick Hohensee and (getting tired of scanning the
> list) everyone else who contributed their thoughts and/or reactions to the
> discussion in this thread. And (again) Anton, thanks for the advice.

> Virtually,

> Bruce R. McFarling, Newcastle, NSW




Fri, 27 Apr 2001 03:00:00 GMT  
 GPL & gforth

Quote:

>I just came across this sig on comp.dsp. It seems apropos.
>"He who writes the code gets to choose his license, and nobody
>else gets to complain" -- Linus Torvalds

Unfortunately, some people aren't convinced of this.  Writing an application
in GForth means that you have to use the licence provided with GForth _and
include a copy of GForth's source in your redistribution_, even if you don't
modify GForth in any way.

Commercial Forths are a little more clear -- you can release an app written
in them under many other licenses, but you can't allow the user to access
the interpreter (a huge pity, because this allows simple in-place patching
and such).

Seems like there is a simple solution, although not pretty in terms of
codebase: give a version of your app compiled by a commercial Forth to your
redistributors (who don't want to see Forth or be responsible for
distributing C source), and post GForth together with the full version of
your app on your web page.

It's simple, but it ain't pretty.  It sure would be nice to see a modified
license for GForth apps, such that so long as you didn't modify the GForth
source code you didn't have to distribute the GForth source code on demand.
(The rest of the license could be held in place, since the reason GPL was
chosen was presumably to force people to release their source code, no
matter what their preference for license.)

I like the GPL, but I don't like the way it limits freedom and then claims
to increase it.  Sure it gives the _software_ liberty, but in this case (and
for linkable libraries) it takes that liberty away from programmers.

This is why I use the LGPL.

Quote:
>Jerry

-Billy


Sat, 28 Apr 2001 03:00:00 GMT  
 GPL & gforth

In Article 2920 of comp.lang.forth

Quote:
William Tanksley writes:

+>"He who writes the code gets to choose his license, and nobody
+>else gets to complain" -- Linus Torvalds

+ Unfortunately, some people aren't convinced of this.  Writing
+ an application in GForth means that you have to use the licence
+ provided with GForth _and include a copy of GForth's source in
+ your redistribution_, even if you don't modify GForth in any
+ way.

    I really don't want to get involved in discussing a
particular application or particular Forth system -- because then
we get into a lengthy discussion about how things can be handled
in this particular case and lose sight of the main issue.

    I would at some point like to start a thread about the
problems faced with trying to get others interested in using
Forth for their work. There is a major problem is that there are
no visible Forth applications in various fields which can serve
as role models.  Mathematicians, for example, do not know of
hand any interesting examples of Forth applications either for
research or for instruction.  If they would want to do some
programming (and produce an application) they can see all around
them examples written in 'C' -- but nothing that might show that
Forth would be a better choice.

    I do not think it serves the Forth community well to show
other people that writing their application in Forth will entail
all sorts of hassle. I include in "hassle" any unusual
requirements about physically distributing source code for a
compiler, trying to decode a very complex license, or forcing a
certain type of license on application authors. I think it would
be advantageous for people in the Forth community to demonstrate
to the rest of the world that Forth applications can be made
available in the same way (both physically and legally) as
applications written in 'C' or any other language.

    This is not a matter of whether there is a way to distribute
my particular application under someone's particular Forth.

+ Commercial Forths are a little more clear -- you can release an
+ app written in them under many other licenses, but you can't
+ allow the user to access the interpreter (a huge pity, because
+ this allows simple in-place patching and such).

    There are four points:  (1) Commercial vendors in the past
have been as much an obstruction as GForth/GPL;  (2) The
commercial license that is more than just "a little more clear"
is for SwiftForth;  (3) I think there are ways to provide some
interpreter access without giving away the entire development
system; (4) Forth, Inc. has indicated its willingness to discuss
this matter. [I do not have an application for which this would
be a major factor -- so I have not tried -- but it would be
wonderful if Forth Inc took the next step itself and recognized
that use of an interpreter is what makes Forth applications
better than 'C' applications]

     The only particular thing is that I did, two years ago, is
look into the GPL when I had an application in preliminary form
that I wanted to send out to a few other universities for
testing.  I had written a program for use in an Abstract Algebra
class -- and I knew that, it its present form, it might not go
with all other textbooks and teaching styles. I tested it with my
students and wanted to see what others thought of it -- and
gather some ideas for how it could be improved. I thought I would
be doing the authors of GForth a favor in spreading their system
if I made a GForth version (in addition to the primary version on
Win32Forth).  This led me to look into their GPL license and
correspond with them and Richard Stallman to clarify it.  

     I concluded that the GPL was more restrictive than
commercial, used misleading rhetoric, was designed mainly for the
community of computer programmers, and was heavily biased to
applications in compiled languages.  I therefore abandoned the
idea of a port to GForth over a year ago without (I had hoped)
hard feelings between me and its authors. A GForth version of my
application was never sent out.

       Let me say that I think that GForth is a fine system and
that I have nothing against Ertl and Paysan other than they
wasted my time. I lost interest a year ago in thinking about all
the peculiar distribution mechanisms and legal red tape involved
in using GForth for applications. I respect their decision that
GForth is intended as a study for computer scientists and not as
a platform for applications.

       I do think it is simplistic to think that the issue is
release of source code.  In the case of an instructional
application there are 4 levels of people involved:

               1.   The authors of the Forth system
               2.   The author of the application
               3.   Teachers to whom the application is sent
               4.   Students in their classes

Since using a Forth system as a "dinner plate" is deemed to be
distribution of the Forth system, one issue is who must
distribute the source code for the Forth system to whom.  The GPL
does not allow just a notice of a WEB site where the source code
may be obtained -- they require that the source code be supplied
in physical form.  But, as Stallman pointed out, there are
mitigating circumstances if the application is provided in binary
form.  (Unfortunately, the authors of GForth do not want
applications using their system to be distributed this way).

       The next issue concerns release of source code.  My
feeling is that most application authors believe that this is
their decision to make.

       The third issue is whether to grant others the right to
distribute modified versions of the application. (I can give
several reasons why an application author might want to stipulate
that the application can be freely distributed IN UNMODIFIED
FORM).

       There are many reasons why the GPL might not appeal even
to those who have some sympathy with its general aim -- and
therefore would oppose an attempt to force them to use this
license for their application.

+ Seems like there is a simple solution, although not pretty in
+ terms of codebase: give a version of your app compiled by a
+ commercial Forth to your redistributors (who don't want to see
+ Forth or be responsible for distributing C source), and post
+ GForth together with the full version of your app on your web
+ page.

       I'm sorry -- but I really don't understand this.

       Suppose I'm interested in writing an instructional
application as a role model to show other people how they might
write such things for their own classes. If they can only do what
they want (i.e. freely distribute their application) using a
commercial Forth -- then why should GForth enter the picture at
all?  Obviously recommending SwiftForth is the way to go (except
you have to be more than curious or rich to spend $395 just to
see if you might like the language). SwiftForth comes with the
only book available on ANS-Forth -- and, except for the cost, it
could actually be the best way for a beginner to get started.

      I don't have this "thing" about commercial software. I
think that the student version of Maple at $89 is the most
incredible value in symbolic computation anywhere.  If I have to
spend a week trying to compile a piece of "free" software (like I
did with GForth) it costs me more than $395 in time. I have spent
more money finding out that GForth is not suitable for what I
want to do than I have in finding that SwiftForth probably is.

      I'm getting old and conscious of how little time I have
been given to do what I need to do. Lots of the people who I
would likely be interest in Forth are also old enough to factor
their time into their calculations -- they would choose Forth if
we could show that they could do things in less time.

      Paying a copyright lawyer and consulting with your
congressman about whether you can legally use GForth to
distribute your application to your class must certainly be added
to the cost. I think that the authors of GForth have shown that
it can actually be quite expensive to use their system.

      "Free" software can be very expensive if you value
your time!

       Right now I still tell people to get F-PC (which is
still readily available).  It is a very good version of Forth,
provides a development environment comparable to a commercial
Forth, and uses a version of Forth (Forth-83) which is compatible
with the only introductory book that Forth has left (Starting
Forth). It presents Forth as it was a decade ago (but Forth still
looked good then). I tell people that I'm sorry if they have a
MacIntosh (I have tried to meet the needs of MacIntosh users --
but even GForth does not have a MacIntosh version).

       GForth, unfortunately, has chosen to make itself
irrelevant as a player in popularizing Forth.  This was clear to
me over a year ago.  So none of my postings really have been
about GForth -- but they have been about problems in making
available applications in Forth.

+ I like the GPL, but I don't like the way it limits freedom and
+ then claims to increase it.  Sure it gives the _software_
+ liberty, but in this case (and for linkable libraries) it takes
+ that liberty away from programmers.

      I really don't care, myself.

      All I care is that if I want to write in Forth I can
use things in my classes or show them to other people just the
way that those who use 'C' can.

      I hate to see a good language destroyed by its own
community.

+ -Billy

                                        John J Wavrik

                                        Univ of Calif - San Diego
                                        La Jolla, CA  92093-0112



Sat, 28 Apr 2001 03:00:00 GMT  
 GPL & gforth

Quote:


>>I just came across this sig on comp.dsp. It seems apropos.

>>"He who writes the code gets to choose his license, and nobody
>>else gets to complain" -- Linus Torvalds

>Unfortunately, some people aren't convinced of this.  Writing an application
>in GForth means that you have to use the licence provided with GForth _and
>include a copy of GForth's source in your redistribution_, even if you don't
>modify GForth in any way.

You could simply not include gforth in your distribution at all (at all!)
and make the user pick it up from somewhere else.  He who wrote gForth
choses the gForth license.  You can chose whatever license for your code,
but if it's gotta be combined with gForth, *shrug*.

--

----
Sometimes a sig is just a sig.



Sat, 28 Apr 2001 03:00:00 GMT  
 GPL & gforth
Three replies wrapped into one, easily deletable posting. Talk about
user-friendly 8-)#


Quote:
>In Article 2920 of comp.lang.forth
>William Tanksley writes:
>+>"He who writes the code gets to choose his license, and nobody
>+>else gets to complain" -- Linus Torvalds

        Taking away the most important of all civil rights -- the
right to whinge (pronounced ``winj'') -- would be an intolerable
imposition on many of my ozzie mates.
        But then there is the choice of what to whinge about. I'm not,
and wouldn't, complain about the authors of Gforth working on a Forth
which is, even at version 0.3, an excellent forth, and requiring
nothing more in exchange that everything distributed using Gforth as a
platform must be distributed in source form. I might be tempted to
whinge that it should say as much up front, to avoid leading someone
to think that the price of using GForth in this way is lower than it
really is. But as long as the price is stated clearly, then someone
willing to pay the price can use the software, just like any other
software.

Quote:
>+ Unfortunately, some people aren't convinced of this.  Writing
>+ an application in GForth means that you have to use the licence
>+ provided with GForth _and include a copy of GForth's source in
>+ your redistribution_, even if you don't modify GForth in any
>+ way.

        This understates the price. Writing an application in GForth
*and distributing it* means that you have to use the license provided
with with GForth and include a copy of GForth's source _and the
application's source_, even if you don't modify GForth in any way.

Quote:
>       I do think it is simplistic to think that the issue is
>release of source code.  In the case of an instructional
>application there are 4 levels of people involved:
>               1.   The authors of the Forth system
>               2.   The author of the application
>               3.   Teachers to whom the application is sent
>               4.   Students in their classes

Source distribution:
        For GForth, 1 & 2 already presumably have it, and distribution
requires that 3 & 4 be provided with it (not just provided with access
to it). For a beta-style release, 3 ought to be provided with GForth
anyway (even if just on the off chance it will pique their interest).
If its a small class, 4's not much of a burden, but in a student
diskette system, if there's a lot of other stuff on the student's, it
may push up the number of student diskette's.

        For the application, only (2) already has it, for a beta style
release (3) ought to be sent it (even if just to pique their
curiosity). There may be good reasons to *not* provide (4) with the
source. The source may well involve solving a problem and checking the
answer: plotting a change in planned aggregate demand and the
resulting impact on national income, and working out the multiplier,
mps, mpc, mpm, aps, apc, etc., and then using the multiplier to work
out the impact of a change in exports, and using the mpm and change in
income to work out the change in the trade balance. If the answer's in
the source, its exactly the students who will spend a half hour trying
to find the answer in the source rather than 15 minutes working out
the answer who really ought to be working with a binary image.
        The advantage of the student disk system is that a different
binary might be automatically generated with a random selection of
different mpc, mpm, autonomous consumption, investment, and export
parameters. So students can work together but still have to repeat the
solution of the problem, rather than just copying a single set of
answers. This might even be replicated by a WWW version which
generates the problem on the fly.
        The whole point of the GPL is to impose restrictions on
distributions of applications and descendents of applications,
according to a particular philosophy, and the goal of writing an
educational application is to give the teacher the maximum flexibility
to use the application within his or her teaching philosophy. Since a
forth application is a descendent of the Forth on which it is written
(or, indeed, any similar itegrated incremental compiler system),
according to the terms of the GPL, there is an inherent conflict
between the GPL and teaching applications written in Forth.
        I still think it is possible to ``trap'' a GPL'd Forth (I
don't want to make this specific to GForth!) within the GPL universe
without trapping all applications compiled with that Forth. It might
be as simple as requiring that any modifications of the GPL'd forth
*which provides the user with access to the compiler semantics of
COMPILE-ONLY words* must be distributed under the GPL. That leaves the
outer interpreter untouched, but ``:'', ``noname:'' and ``]'' (and
what others?) must be renamed with error messages in the Forth
vocabulary of the distribution, and there must be no MARKER words
behind that point.

(
----------
Virtually,

Bruce McFarling, Newcastle,

)



Sun, 29 Apr 2001 03:00:00 GMT  
 GPL & gforth


Quote:
>I think the GPL is a bit outdated. But even then, there are still enough
>people who aren't aware how to get Gforth's sources on the internet, either
>because they don't have internet access, or because they don't know where to
>search.

        The price of having to distribute the original Forth system
*is* a price, but its not a price I mind having to pay. It may
introduce some hassles, but for me they aren't that serious, and it
*does* cast the mustard seeds more widely.

Quote:
>The LGPL doesn't help a bit with Gforth. Gforth isn't a linkable library, at
>east not on the Forth side. It can load sources, but it can't link binaries.

>The only thing I can think of would be an additional license with the
>following intention: as long as you ship an unmodified Gforth (compiled out
>of a publically available source) and your application isn't a Forth
>programming system, you could ship a binary. So if you change Gforth, you
>also must make the changes public.

        That's what my previous post attempted to get at: what is a
Forth programming system? Is it a Forth programming system if it lets
a user create a data structure? Mandating that access to the compiler
semantics of the compile-only words in the original ICGPL'd Forth
requires distribution of those sources under the terms of ICGPL is a
way to try to get to that.

Quote:
>However, this is then still not equivalent to GCC. If I want to change GCC
>(e.g. improve or port or fix a bug) to compile my app, I don't need to
>deliver this improved GCC as well.

        I don't think that this isn't a serious problem. If there is a
requirement to use a modified ICGPL'd compiler to compile an
application, then the bug fixes / extensions just go into that
archive, and the application itself can still be distributed compiled
with the modified ICGPL'd Forth as a binary.

(
----------
Virtually,

Bruce McFarling, Newcastle,

)



Sun, 29 Apr 2001 03:00:00 GMT  
 GPL & gforth

Quote:

>    I don't think that this isn't a serious problem. If there is a
>requirement to use a modified ICGPL'd compiler to compile an
>application, then the bug fixes / extensions just go into that
>archive, and the application itself can still be distributed compiled
>with the modified ICGPL'd Forth as a binary.

Err...
        ``I don't think that this [is] a serious problem.''

(
----------
Virtually,

Bruce McFarling, Newcastle,

)



Sun, 29 Apr 2001 03:00:00 GMT  
 GPL & gforth
On 10 Nov 1998 12:22:47 GMT,

[snip]

Quote:
>       Right now I still tell people to get F-PC (which is
>still readily available).  It is a very good version of Forth,
>provides a development environment comparable to a commercial
>Forth, and uses a version of Forth (Forth-83) which is compatible
>with the only introductory book that Forth has left (Starting
>Forth). It presents Forth as it was a decade ago (but Forth still
>looked good then). I tell people that I'm sorry if they have a
>MacIntosh (I have tried to meet the needs of MacIntosh users --
>but even GForth does not have a MacIntosh version).

[snip]

Quote:

>      All I care is that if I want to write in Forth I can
>use things in my classes or show them to other people just the
>way that those who use 'C' can.

GPL and gforth may not be what you need but you still have
alternatives.

 I was going to suggest using FIG Forth. It's free,  unencumbered and
small. It's ideal for the type of use you want (free
distribution of instructional applications). For DOS it starts at a
size of 8K. After adding screen editor, decompiler, extentions and
most ANS wordsets, I have one, hacked and unoptimised yet still  
under 50K. It supports both block and SEQ files (SEQ files work well
for instructional programs - more room for comments and structured
layout). I would be surprised if there are not FIG Forths available
for the MacIntosh. There was only 2K of code that was system dependent.
 The main point is that FIG Forth, a small, free and unencumbered
Forth, can be made to run today's ANS programs (FIG still lives).
 It seems that FPC also provides you what you want and it's
certainly a robust development system with a fair amount of available
software.
 Is there something lacking in these options?

--
Tom Zegub
WasteLand  http://www.dhc.net/~tzegub



Sun, 29 Apr 2001 03:00:00 GMT  
 GPL & gforth
This is going on & on & on & on and doesn't seem to be getting much
of anywhere.  Apparently Forth types are willing to innovate in
code without even the drop of a hat, but when it comes to written
English they are completely paralyzed.

Look, people, the GPL didn't come down from Sinai.  It was written
by human beings for a purpose.  We seem to be agreed that it was
intended to cover the C "source code, object module, binary executable"
mode of computing.  Quite possibly the authors had never heard of Forth.

So, what would a license for Forth that achieved the goals of
open software look like?  Is the community so dumb it can't
write/agree on one?  Why don't we do *that* and then start
a) using it and b) offer it to the OSF as an alternative license?

   -LenZ-



Sun, 29 Apr 2001 03:00:00 GMT  
 GPL & gforth

Quote:

>This is going on & on & on & on and doesn't seem to be getting much
>of anywhere.  Apparently Forth types are willing to innovate in
>code without even the drop of a hat, but when it comes to written
>English they are completely paralyzed.

>Look, people, the GPL didn't come down from Sinai.  It was written
>by human beings for a purpose.  We seem to be agreed that it was
>intended to cover the C "source code, object module, binary executable"
>mode of computing.  Quite possibly the authors had never heard of Forth.

>So, what would a license for Forth that achieved the goals of
>open software look like?  Is the community so dumb it can't
>write/agree on one?  Why don't we do *that* and then start
>a) using it and b) offer it to the OSF as an alternative license?

I've been minimally following the conversation, and I don't think that your
apparent goals are the goals shared by everyone in the conversation.  There
are several things going on that I saw: people bashing gForth for being GPL,
people bashing GPL for not being Forth-related, and people hoping that
RMS/FSF will soon approve another license for gForth (since the code was
apparently donated to the FSF, they need to okay it if the project isn't
going to split).
        I think it would be more helpful to develop a good license and hope
gForth and others pick it up in time. :)

--

----
"Ludwig Boltzmann, who spend much of his life studying statistical mechanics
died in 1906 by his own hand.  Paul Ehrenfest, carrying on the work, died
similarly in 1933.  Now it is our turn."
                -- Goodstein, States of Matter



Sun, 29 Apr 2001 03:00:00 GMT  
 GPL & gforth

Quote:

> Look, people, the GPL didn't come down from Sinai.  It was written
> by human beings for a purpose.  We seem to be agreed that it was
> intended to cover the C "source code, object module, binary executable"
> mode of computing.  Quite possibly the authors had never heard of Forth.
> So, what would a license for Forth that achieved the goals of
> open software look like?  Is the community so dumb it can't
> write/agree on one?  Why don't we do *that* and then start
> a) using it and b) offer it to the OSF as an alternative license?

        One of my posts addressed this. The key point is that ``the
goals of open software'' aren't necessarily entirely compatible: different
people like open software for different things.

        Take two goals chosen entirely at non-random:

        GOAL1: To use Forth to help spread open software
        GOAL2: To use open software to help spread Forth

Goal1 might look askance at a binary only application compiled with an
open source software Forth, with only the open source software Forth
available in source; goal2 might gaze fondly at the same distribution.
This is subverting Goal1, while promoting Goal2.

[I wrote]

Quote:
>>       I don't think that this isn't a serious problem. If there is a
>> requirement to use a modified ICGPL'd compiler to compile an
>> application, then the bug fixes / extensions just go into that
>> archive, and the application itself can still be distributed compiled
>> with the modified ICGPL'd Forth as a binary.

And Bernd answered:

Quote:
> This sounds like a restricted/modified Artistic License.
> "You may redistribute your application in binary form if
> a) modifications to the system sources are contributed back to the
> maintainers. b) the application has a different name and a different
> purpose.
> Additional files are modifications, if they override or patch
> underlying system functions."
> Overrides would be words with the same intention (if : is defective,
> it won't help you if you name your override DEFINE), patches are code
> modifications.
> I think we are getting closer to an ICGPL that is acceptable under the
> GPL philosophy.

        Now, while its a bit of a problem of fitting a round peg into a
square hole, its something which has been done pretty successfully for the
GPL by the innovation of the LGPL. Its better *not* to have ``forking by
license'' if it can be avoided, so the more different philosophies that
can be served, the better.

        I continue to maintain that the *spirit* of the GPL can be served
with an Open Source Software license which leaves a Forth programmer free
to decide how to license the application that they compile on the OSS
Forth, *and* maintains the rights of the author(s) of the OSS to prevent
the closure of the Forth system.

I think that Bernd has put his finger on it, up above. The GPL is one end
of the spectrum, and the Artistic license is the other. I'm still
wondering whether the LGPL can be included in the ICGPL by reference.

INCREMENTAL COMPILER ANNEX to the LGPL: (wip: hopefully broken in order to
encourage people to fix it, and thereby turn out something better than I
could do on my own).
        ``A Compiler Word is a function from the incremental compiler
library, typically contained in the binary image of the incremental
compiler, which provides runtime support for an application compiled by
the incremental compiler.
        A Compiling Word is a function contained in the incremental
compiler, which is executed in the process of compiling applications.

        The term ``a Word'' is used to refer to either a compiler word or a
compiling word.

Linking by Incremental Compilation
        The incremental compiler may link an application with Compiling
Words with special facilities provided in support of the definition of new
or revised Compiling Words. The incremental compiler links an application
with Compiler Words by compiling a reference to the compiler word in the
incremental compiler library.  A Word, whether a Compiling Word or
Compiler Word, is only considered to be contained with an application if
it has been linked with the application by the Incremental Compiler, or if
facilities are provided to execute the word. If the binary image of the
application contained a binary image of the incremental compiler, a word
which is not linked into the application, and which is not accessible when
the application is executesd, is not considered to be included in the
binary image of the application.
        In other words, if the code contained in the word is not
available to be executed when the application is executed, it is
considered not to be included in the application, even though it is
present in the binary image.
        The license which covers this incremental compiler is a
modification of the LGPL. All provisions of the LGPL apply, except as
described below:
        - all references or descriptions of the process of linking are to
be interpreted in a manner consistent with the above definitions, and for
the following sections which are inconsistent the above definitions, the
following amendments are to be made:
        [ this list needs to be included here ]

        - If an application includes words which link Compiling Words,
these words, together with any words directly or indirectly linked into
these words, are considered to be extensions to the incremental compiler,
and are covered by the provisions of the LGPL for extending or modifying
an application covered by the LGPL. EXCEPT THAT:
        If the author(s) of the ICGPL'd incremental compiler wish to
permit specific Compiling Words to be considered part of the Incremental
Compiler Library, rather than as part of the Incremental Compiler itself,
the author(s) may append an Annex to this ICGPL, listing the words which
may be treated as part of the Incremental Compiler Library, and which may
be linked into an application, and/or made accessible to the user, without
being required by that inclusion or facility to be treated as an extension
of the incremental compiler.

Virtually,

Bruce R. McFarling, Newcastle, NSW



Mon, 30 Apr 2001 03:00:00 GMT  
 GPL & gforth

Quote:
Bernd Paysan writes:

     [A whole lot of stuff that is just a repeat
     of what he has said before -- and a whole lot
     of {*filter*}about "free" that I don't buy -- as well
     as a lot of stuff that confirms our impression that
     the GPL is very technical and complex]

     I must admit that I hate licenses that come with manifestos
-- and I am turned off by nonsense about starving children in the
third world that has absolutely nothing to do with the topic.

     However:  "grits" does not mean source code.  It means any
condition that a vendor of Forth imposes that goes beyond
protecting his intellectual property.  To use someone's Forth as
a "dinner plate" does impose on the application author some
respect for the vendor's intellectual property.  I completely
understand and respect where Elizabeth Rather is coming from. Her
company put a lot of time and money into producing SwiftForth and
its documentation. To pay for the cost of doing this, the system
is not free. To some people getting a well documented and well-
supported version of Forth may be a good value -- so Forth, Inc
deserves some encouragement for doing what they have done. This
vendor encourages applications using their Forth -- and the
constraints are rather obvious.  It is a big thing for me to
praise a commercial vendor, but Elizabeth has made me recognize
that commercial vendors may play a role in the spread of Forth.  

     If people supply a "free" Forth it is harder to justify
imposing conditions of a religious, political or sociological
nature on the use of their Forth for applications. The problem is
compounded when the conditions for using their Forth change on a
daily basis -- or depend on which co-author you speak to at the
moment.

     I really did think I was doing the authors of GForth a favor
by trying to make a GForth port of my application.  My
consideration of GForth ended when their correspondence became
abusive.  

     The bottom line is that use of any Forth should not depend
on an application author doing anything but agreeing not to abuse
the intellectual property of the authors of the Forth system. In
particular, the author need not subscribe to the vendor's political
views.  

     The attempt by the authors of GForth to use their version of
Forth to impose their politics on others is like trying to force
a restaurant owner to serve a certain kind of food in order to
use their dinner plates. It is an improper use of leverage.

    I, incidentally, object more to requiring that a teacher who
wants to use my program must distribute source code for a compiler
he doesn't need, his students don't need, and none of them use.
Physical distribution of source code for a compiler is, for me,
a very serious problem.  (Grits)

    I regard forcing a license on the author of an application
just to distribute it (even if it was not developed on the
platform) as a very serious imposition. (Grits)

    I regard a requirement that the author distribute source code
for an application being tested in preliminary form as an
imposition (Grits)

    Any attempt to impose requirements on a application author
which go beyond protecting the Forth system is grits.

    Any attempt to impose philosophical, religious, political,
etc. views on an application author to use a Forth dinner plate
is grits.

    My challenge to the authors of GForth is this: come up with a
license that protects your intellectual property against abuse --
but allow application authors to do anything except misuse your
system.

                             -------

    I'm not a computer scientist, so I don't know what "open
software" is about.  All I know is that sometimes it is vital to
provide source code for an application, sometimes it is
irrelevant, and sometimes it is detrimental -- and only the
application author is in a position to competently judge.

     In my part of the world, computer programs are distributed
as executables.

    Hey, I'm not a fanatic -- and I'm only a mathematician --
what do I know about how to distribute mathematical software?

     Maybe I'm expecting 50 year old common sense from people in
their 20's.

                       ------------------

Quote:
Len Zettel writes:

+ This is going on & on & on & on and doesn't seem to be getting much
+ of anywhere.  Apparently Forth types are willing to innovate in
+ code without even the drop of a hat, but when it comes to written
+ English they are completely paralyzed.
+
+ Look, people, the GPL didn't come down from Sinai.  It was written
+ by human beings for a purpose.  We seem to be agreed that it was
+ intended to cover the C "source code, object module, binary executable"
+ mode of computing.  Quite possibly the authors had never heard of Forth.
+
+ So, what would a license for Forth that achieved the goals of
+ open software look like?  Is the community so dumb it can't
+ write/agree on one?  Why don't we do *that* and then start
+ a) using it and b) offer it to the OSF as an alternative license?
+
+    -LenZ-

Len,
   We have known each other for several years. Now I understand
why I have developed such a respect for your ability to take
complex issues and penetrate to the heart of the matter.

                                             --John

                                        John J Wavrik

                                        Univ of Calif - San Diego
                                        La Jolla, CA  92093-0112



Mon, 30 Apr 2001 03:00:00 GMT  
 
 [ 47 post ]  Go to page: [1] [2] [3] [4]

 Relevant Pages 

1. Self-dcumenting code (was Re: Gforth, images, GPL...)

2. GForth & Obfuscated Source Code

3. Gforth: TIB history & AT-XY Questions

4. Gforth: TIB History & AT-XY Questions

5. Chuck Moore vs. lesser programmers (was: Gforth, images, GPL)

6. [OT} How to un-GPL parts of a GPL'd module.

7. ABC Templates @#$%^&*&&*&*!!!!!!

8. SPITBOL 360, a SNOBOL4 Compiler, Re-released Under GPL

9. Clipper, Accounting, and the GPL

10. GPL Thread Manager

11. SQL Rdd for clipper, opensource, gpl, or free

12. Clipper and the GPL

 

 
Powered by phpBB® Forum Software