Crafting a special kind of license for a very special standard.

[David Woolley]

Matthew Flaschen wrote:
> An implementation of a standard is not derived from the standard in the
> copyright law sense.  Thus, even if you GPLed the standard, proprietary
> software could still implement it.

If it were ruled to be the case, it would largely kill open source
software, as, especially for standards from consortia, e.g. W3C,
it could make it impossible to implement interworkable open source
programs.  In fact, companies might start publishing interface standards 
to prevent the production of competing products!  Currently they can 
only do this with patents.

> stop unauthorized implementations without patents.  You could register
> the standard as a trade secret, and require everyone to sign a contract.
>  They could agree:
> 
> a. not to describe the standard to anyone.
> b. only implement it in the ways you describe

I think that has also been done with click wrap specifications, like 
that for the Microsoft Word file format.  I think that Microsoft would 
claim that you are entering a non-disclosure agreement when you view 
that on MSDN.  As NDA normally have to created as deeds in the UK, I'm 
not sure how valid that is, but people are not going to challenge MS
lightly.

> No, but you can learn from reading GPL code and make a separate e.g.
> proprietary implementation that does the same thing.  It's a close call,
> but that separate implementation need not infringe copyright if you do
> it right.

Most of the FSF branded GPL code is emulating proprietary code from 
Unix.  For the FSF created stuff, they have gone to some trouble to 
ensure that it is code by people who have never seen the original code. 
In some cases, I think they have used clean room techniques, where one 
person is allowed to see the original, and writes a high level 
specification, from which the other writes new code.

Internet Explorer probably would never have existed if MS could 
re-implement Netscape's copyrighted code.
> 
>> It is called plagiarism.

Plagiarism is where you do not acknowledge the original as the source,
although, obviously, acknowledging the original gives rise to the sort
of based on xxxx work around.  A lot of student plagiarism is actually
copyright violation.

> implementation",  "Java-compatible", and get away with it.  This is
> actually a really good example, because the Java standard and API is
> copyrighted, but Sun couldn't sue unauthorized implementors for
> copyright infringement.

I seem to remember that, like Adobe and PostScript, Sun claim copyright 
on the Java keywords, but then grant an open licence to use them in 
valid implementations.  Most assembly languages claim copyrights on the 
instruction mnemonics.