Derivative/collective works and OSL

[Chris F Clark]

Chck swiger wrote:
> However, there exists a branch of software engineering known as compiler 
> design, and there exist experts in that field who have written working 
> compilers who share a common understanding of how a compiler toolchain 
> operates: compilers perform a mechanical, deterministic, and reversible 
                                            ^^^^^^^^^^^^^      ^^^^^^^^^^
> transformation on source code to produce object code.

The underlined words are incorrect and important.  

Almost all compilers perform irreverisble transformations (in fact, I
can't think of any "compilers" that perform reversible
transformations, although some Java compilers are close).

Many compilers perform non-deterministic trnasformations
(i.e. transformations that depend on external factors not present in
the source code (e.g. the time-of-day, the location where the compiler
was run, etc.)).  

The transformation is mechanical.

If compilers performed reversible tranformations, there would be no
point in "open source".  However, compilers perform irreversible
transformations that lose information.

It is akin to (but more destructive than) erasing all vowels in
English text.  Many English texts would still be readable with their
vowels removed.  However, occassionally an English text might depend
on a spelling-base pun (e.g. using "end" for "and" or "than" for
"then") and such texts would be destroyed by such a transformation, as
there would be no way of knowing which spelling was used once the
letters were erased.  ("if the and is greater than the mean" is
indistinguishable from "if the end is greater then the mean")

As a result, some of the "expression" written in the original "source
code" is quite often destroyed (lost, cannot be recreated or
retrieved) by its translation to "object code".  Now, some of the
"expression" is also retained--how much is retained depends upon the
compiler.

My apologies if the above reply is strident.  However, as a Sigplan
Editor on a column which teaches about compiler design, this is a
misapprenhension that I am continually fighting.  There are many
points of expression that a compiler cannot retain and cannot
"access".  This makes problems that seem to be trivial actually
excrutiatingly difficult to solve.  As a result, people commonly
under-estimate the task involved in certain translations because the
information is so plainly evident to them (due to its presence in the
expression) but is not obvious to a compiler, due to its presence in
the "inaccessible" portion of the expression, which a compiler is not
able to extract, retain, or use.

-Chris