I wasn't sure if the GPL and LGPL covered just the software or if they also cover accompanying documentation.

They can cover whatever you say they cover - remember that everything you write is copyright by you, and only if it is covered by a license can people use it, and even then only if they comply with its terms.

It's conventional to put the license in each file as a header or footer, accompanied by a copyright notice, but it's not technically necessary (this is why a stripped out a license header makes no difference to the copyright, although it might invalidate the license.)

There is also the GFDL which is specifically aimed at documentation, so you could use that, just for the documentation files.

IMHO, this always has to be clarified, because the GPL is simply not this broad as implied here.

When you distribute a GPL work, you are obligated to make the source of your work available to the parties that you distribute the work to. You also can not restrain those parties from further releasing the work.

There is also a sunset on the duration of your obligation, of I think 3-5 years.

This means that if you distribute a GPL work, you are not obligated to put it on a public server and make it available to the world. You are not obliged to respond to requests from everyone or anyone. You're not obliged to do that for eternity. Rather, if the party you distributed to asks for the source code, you are obliged to make it available to them, AND you can charge for the service of providing it to them.

Also, you are not obligated under the license to release any changes you made "back up stream", back to the community. Only downstream to the folks you distribute your derived works to.

So, when you go and write your Automated System for Tire Stores, and SELL the system to Bobs Tire Warehouse, Bob can ask for the source code. And, that's it. You're done. Bob can post the code to the web, Bob can make large signs of your source code and stick it to the company van. Bob can sell USB Fobs with the source code on it.

But you don't have to support any of that. You don't have to offer the source to anyone else. And, frankly, Bob is in the Tire business not the software business.

Mind, I think the Free Software Foundation really dropped the ball on the GPL. IMHO I think every web page with GPL code in it (whether from a web template or java script) should be implicitly licensed as GPL, but they don't see it that way.

I think you miss one of the crucial things about the GPL. Read it for the specifics, but broadly, if you don't accompany your product with the source when you distribute it, then you have an obligation to make the source available to everyone.

With something as small as a Forth for the Commodore 64, I plan to include the source code with it. That takes care of that obligation. Just don't hold me accountable if someone goes mad reading it.
Even though it is an indirect threaded code Forth (ITC) it has some words with a mix of assembly and high level code.

Mixing assembly into a colon definition

I've read the license many times, and I've the same understanding as whartung: If you distribute the binary to party A, then you are only obliged to provide the source to party A, and only if party A is asking for it. If A distributes the binary to party B (or the whole world), you have no obligation to provide the source to them ('everyone').
Of course, if party A is actually everyone (=you put your product as a download on an open web site), then in practice you'll have to put the source there too, unless you're prepared to handle a lot of single requests.

It's section 3b of v2 of the GPL that I was thinking of. Section 6 of the v3 license reads differently - I haven't the energy or inclination to try to re-interpret that here.

So, I looked it up.

The spirit of the third party clause is that anyone who only gets a binary of the software is entitled to get the source code.

The basic premise is that when the binary is distributed (in whatever manner), that instead of distributing the source code with they binary, the written offer gets transmitted with the software.

In that sense, yes, you need to make the source available to "anyone".

However, only those who received the binary are entitled to it vs "everyone". How that is enforced, of course, is an exercise for the reader.

GPLv3 clarifies that aspect of it, whereas GPLv2 just says "third party".

Yes, the offer (valid for 3 years) has to be provided with the binary. Not sure if that's in any way covered by just providing the license itself (the 'COPYING' file, where this is stated).
But in section 3 it clearly says that if 'you' distribute the 'Program (or a work based on it)', then 'you' are also responsible for providing source, *or* that written offer. I can only interpret that in one way: If party A provides the binary to party B (and only to party B), then A must offer the source to B (if requested), but if B provides the binary to C, or the world, then *B*, not A, is responsible for providing the source (after getting it from A if necessary).

(It also effectively states, in the last paragraph of section 3, that if you provide the binary on a web site then it's fine to provide the source at the same place. You don't have to handle individual requests.)

So lets see if I've got this. If I release my Forth system under the LGPL and someone writes an application in it, just the part that came with my Forth would need to be released under the LGPL while the rest could be under any license?
Also, if I later write an application in my Forth, I could release the application under the GPL, and the part that was released under the LGPL would still be under the LGPL?
Forth makes this a little tricky because programming in Forth is extending the language until it is a solution to a given problem ( unlike say, an assembler where the executable, although dependent on a particular processor and its opcodes, is independent of the assembler that was used.)
With Forth, the system, at least the kernel, needs to be included with the application, which is why, for the Forth system, I'm considering the LGPL.
Something else to consider. It's always possible that someone, maybe even me, could write not an application, but an extention to the Forth system for um... controlling robotics and release that as a robotic's control language built ontop of Forth. How would this be different from an Application? Would the robotic's control language need to be released under the LGPL or could any license be used for that portion that was not included with the Forth system?

Yes

Yes. (As the originator of the code, you could choose to release under totally different licenses, but this choice would be natural.)

Quite reasonable. Think of LGPL as being for libraries, which are marvellous enough to need the protection of the GPL, and whose author is generous enough to allow them to be used in any project. It helps the adoption of the library, while not necessarily helping the end-user get the benefit of a GPL application.

It would be cleanest, and normal, if the LGPL part was all in one file or set of files, and the other parts were in other files. The granularity of licenses, which is ideally at project level, in this case comes down to directory level or file-by-file level. If the extension could only be deeply embedded in and mixed into the LGPL ancestor, it pretty much needs to be LGPL.

Oops!

An RCL,robotic control language, could be written in any Forth. The imagery that comes to mind reminds me of a diagram from Radio Electronics "Build the R. E. Robot". Forth was the circle in the center. Their RCL was the shell surrounding the circle. User level programs were the shell surrounding that shell. At least, I think that's how the diagram was ( I can't seem to find that particular issue ). I don't know if you use Forth, but I hope that description helps clarify the different aspects.

For copyright, the unit of licensing is "the work" - the usual examples would be a written story, or a poem. A poem may be published within an anthology, and it's established that the anthology is itself a work, in which case there are nested licenses.

If someone wishes to use an LGPL component within a larger project that they wish to license differently (or not at all) they need to separate the works according to their licenses. So, the simplest approach is for the LGPL content to be within one file or one set of files, with an explanation nearby or within, and for the other content to be in separate files.

That is to say, the programming language of choice isn't the important thing, it's the separability of the works. Usually, that means there's an API or ABI which allows a user of a library to integrate it without losing the separability.

Edit to add: when a copyright work is mixed in with another work, for example if I cut and paste some CRC code into my project source, what's created is a derived work. The copyright in the new mixed-source work is now owned both by the original creator (in this case the CRC expert) and by me, the author of the other code. In order to license this new mixed-source work we need the cooperation of both parties, who are both authors. If the CRC author chose a standard and acceptable license, it's usually possible for me to choose the same license. If they chose a sufficiently liberal license, it may be possible for me to use a different license, or to keep the work closed-source. If they chose GPL, I will need to choose GPL too, or, in any case, I could seek a new license from them which suits us both. If we're talking about mixed-license codebases, it makes good sense to keep differently-licensed code in separate files or even separate sub-projects.

You should be careful with a Forth.

If your source code uses an LGPL library, and links to it, then the SOURCE CODE is not considered to be a derivative work (and thus not subject to the LGPL license).

However, if you STATICALLY link the library in to your executable then the EXECUTABLE /IS/ considered a derivative work -- and thus subject to the LGPL.

If you DYNAMICALLY link the library, as is common on Unix and such, then this is not that case.

A Forth, typically, does not support dynamic linking. So, even if your Forth is LGPL, there can be "viral" effects from it.

This is why many systems use the LGPL (and GPL) with "exemptions" to handle the typical use case.

Lisp suffers similarly from this, like most "image" based systems (which I also consider a Forth).

Here's a relevant quote from a "Lisp LGPL" http://opensource.franz.com/preamble.html :


So, anyway, just be careful the LGPL may not be as slam dunk as you might like.

This could be a problem. After reading Garth Wilson's article on zero overhead interupts in Forth, I modified NEXT to add the second jump which saves 1 clock cycle in over 99 % of the cases. Also, I've read "All About Forth" which has plenty of high level source code. If I saw a better way of doing something ( better size/speed tradeoff ), I used it. I wasn't thinking about releasing my Forth at the time. I just wanted a better forth for the Commodore 64 ( this was about a quarter of a century ago when I first wrote it, I rewrote it just a few years ago since I no longer have my Commodore 64, any of the peripherals, or the disks, including the ones that had the source code ) I originally rewrote it to refamiliarize myself with metacompiling but next thing I knew, I was incorporating anything I could think of to make it better. I wasn't thinking of derivative works.
It also has one line of BASIC to kick things off
10 SYS XXXXX
where XXXXX is the address of the cold start routine.
So now I don't know if I will be able to release it.
What if a short piece of code is the best and most obvious way of doing something? If I remember correctly, the test of obviousness applies to patents but what about source code?
For example, If I wrote a book on how to build houses and someone read it, then wrote their own book teaching all the same methods and general knowledge but expressed it in their own words, would it be a derivative work? If that were the case, wouldn't all Forth's be a derivative work of Charles Moore's original Forth?
This is making my head hurt. I am so glad I am not a lawyer. I couldn't deal with stuff like this for a living.