[Gllug] Hypothetical GPL question

[Nix]

On Tue, 30 Oct 2001, David Spencer stipulated:
> Simply define your own licence based upon the GPL but without the bits
> you don't like.
> Unfortunately you won't then be able to call it "GPL".

Yes you can. (It might *expand* to something different, and if RMS hears
about it you can expect to get into hot water, and shortly afterwards to
be covered in mud, but you *can* do it. Not recommended. ;) )

> iirc, GPL doesn't state that you have to release source, only that you
> have to make it available for reasonable costs only (check the small
> print for details).

And this differs from `release' how, exactly?

> Look for the LGPL - this seems to be a way of doing what you want to. 
> You can hide the bulk of the code in the library then release a GPL
> source code that is simply:
> 
> #include <mylib.h>
> main()
> {
> 	justdoit();
> }

You mean `LGPL'. Distributing GPLed code that did this would be in
violation of the license (unless, of course, you are the author, who can
do anything; it's just that the people you distributed it to wouldn't be
allowed to give it to anyone else).

> Clearly you are not an assembler programmer!  There is a vast difference
> between a disassembly of a compiled program and an assembler source code
> file.

Oh yes, indeed.

>       If you can find a compiler that will compile via assembly (gcc
> for example) this will give you an idea but there will still be lots of
> obviously machine generated label names.

That means little; a disassembler can easily assign similar names.
However, the compiler-inserted comments saying what is going on in the
compiler's assembly output will *not* be present in the disassemabled
output ;)

> A program written in assembly can be sold under the GPL.  If your

ITYM `distributed'. Sale or giveaway is irrelevant; it's copying that
matters.

>                                                               You can
> even define your own language, although if you do this I believe you
> have to release the compiler as well,

Untrue. If compilers for the language are widely available then there is
no need to do that --- otherwise every GPLed program would have to
include a complete toolchain and OS!

The situation with `little languages' is murkier; probably, if you're
working in good faith, if you use a language you designed and
implemented in a GPLed project, the language translator should be GPLed
too.

>                                       which is why the GPL doesn't fit
> easily onto Windows as very few compilers are free and very few people
> are willing to give a copy of MSVC to every customer.

Untrue. XEmacs, mingw and many other GPLed programs will compile with
MSVC --- some will *only* compile with MSVC --- but there is no need to
provide copies of MSVC to anyone when distributing such :)

>                                                       By "source" the
> GPL means "the ability to rebuild the program".

I hate to say this, but have you *read* the GPL? If it meant that,
giving out obfuscated code would be acceptable; but it is not. The GPL
states:

,----[ GPL, clause 3 ]
| The source code for a work means the preferred form of the work for
| making modifications to it.  For an executable work, complete source
| code means all the source code for all modules it contains, plus any
| associated interface definition files, plus the scripts used to
| control compilation and installation of the executable.  However, as a
| special exception, the source code distributed need not include
| anything that is normally distributed (in either source or binary
| form) with the major components (compiler, kernel, and so on) of the
| operating system on which the executable runs, unless that component
| itself accompanies the executable.
`----

Not unclear, I think. The important point is that the user can *modify*
it, not that the user can rebuild it (although that should not be made
overly hard either).

>                                                  You'll have to read it
> in detail with a lawyer to get the full effect.

You'll have to read it. A lawyer is not necessary; while ambiguous in
places, the GPL cuts new legal ground by being comprehensible to
non-lawyers ;)

>> ...what *is* source code...
> 
> If you can demonstrate the ability to open a hex editor and write
> working machine code, then there is nothing to stop you calling the .EXE
> the source code.

Yes, there is; it is not the `preferred form... for making
modifications'. Hence, under the GPL, it is not source code.

(Sheesh, does nobody *read* the GPL before commenting on it?)

>                   But I think you'll have a job proving this (although
> the burden of proof is on the prosecutor.

... who would not have a hard job in that code.

>                                            However these days all big
> companies have to do to swing the judgement their way is to shout
> "Pirate!" and it seems every judge at this point winds up proceedings in
> their favour even if there is no piracy involved.

Sometimes, regrettably, yes; but this is what appeals courts are for,
and thankfully, even though the judicial selection process in the UK is
distinctly opaque, UK judges and the UK legislative process is a little
less rotten than the US's... (although we have that lovely civil service
culture of secrecy to replace it. Oh joy.)

>                                                    See DeCSS for an
> example).

I'm sorry, was that an English court?

> Therefore source code is what you write the program in, before running a
> compiler or interpreter to convert it into machine-executable format. 

That's correct. It's what *you* wrote and debugged the program in.

(Note that this is in direct opposition to your statements above.)

> Java is source code.  Java byte code is not source code.  If you know
> byte code extremely well, you could theoretically write a program in
> byte code directly, this would then be the source.  But again you would
> have a problem with credibility unless you were a recognised JBC expert.

Even then; nobody sane writes anything in Java bytecodes.

>> To a non-programmer
> 
> To a non-programmer, the GPL is pretty much a waste of space except that
> it allows them to install on however many computers they want.  But that
> non-programmer may want one day to hire a programmer, e.g. you, to make
> changes they want.  They are less likely to hire you if you are a
> rip-off merchant.

And it lets you avoid being locked in to rip-off merchant original
vendors (like, hell, most proprietary software companies).

> I don't believe you have to publish your plans, only the final source
> itself.  So if your program is of the form:
> 
> 10 DATA 10,20,30,40,...
> 20 FOR ...poke this lot into RAM starting at P
> 30 LET L=USR(P);
> 
> then that is the source you must release.  It is up to your customers

Is that *really* the preferred form for making modifications to the
work? I very much doubt it. Hence it is not source under the GPL.

>          Clearly it _is_ source code,

Clearly it is not.
>                                      but you may lose the case as
> anyone from GNU hypothetically hired as a consultant might instantly
> zoom in on the "10,20,30,40,..." and declare this non-source.

... if anyone who can read reads clause 3 of the GPL and casts doubt on
the likelihood of your preferring to make modifications to the source in
that form.


Please sit down and read the GPL (and the GPL FAQ on the FSF's site,
which answers most of these questions far more cogently than I ever
could).

-- 
`You're the only person I know who can't tell the difference
 between a pair of trousers and a desk.' --- Kieran, to me

-- 
Gllug mailing list  -  Gllug at linux.co.uk
http://list.ftech.net/mailman/listinfo/gllug