[ros-kernel] RE: [ros-cvs] CVS Update: reactos

[Travis Snoozy]

AFAIK (IANAL), interfaces in the US and Europe are not copyrightable.
Hence, a *signed* NDA might pose a problem, but our rights override a
(clickthrough) EULA. That is to say, we can make a legal copy and view
it _without_ having to follow the terms of the NDA, if our purpose is to
extract interoperability informaion.

The only reason clickthrough NDA/EULAs work is because they are the
"only thing that authorizes you to" (copy, view, et al). In this case,
fair use authorizes us to make copies/view info/et al, bypassing the
EULA -- unless we *physically sign* and enter into a contract.

(http://www.sims.berkeley.edu/~pam/papers/Sweet&Maxwell_1.htm)
"Sega v. Accolade and companion U.S. decisions rely upon the U.S. fair
use doctrine to reach the conclusion that no infringement occurs when a
firm makes intermediate copies of programs for a legitimate reason such
as to get access to information necessary to create an interoperable
program."

http://cse.stanford.edu/class/cs201/projects-99-00/intellectual-property-law/reverse_engineering.htm

This is a really funny area of law; the _code_ is copyrightable, so we
can't copy-paste it. The API (the interface information embodied by the
code) is not copyrightable, though. Because of the way C works, we don't
have a choice in the naming of functions/structures/macros. Also, if
both we and MS happen to use the same formatting convention (I don't
know if we do or not), if it's fairly standard (return type\ncall
type\nfunction(\n is pretty standard), then there still isn't a problem.
However, comments and variable names should be digested, and we should
use our own variable names/ comments within the API code.

We should also probably do a dirty/clean implementation. It's really
inefficient, but it's the safest way to make sure that, without a doubt,
we are not infringing. This could be accomplished by a pair of coders
over IRC, one "dirty", who's looking at the API and describing, in
English, the call; the other "clean", who's taking the digested info,
interpereting it, and writing the API on his side. The upshot to using
IRC is that the process is clearly accounted for and audit-able.

-- Travis