From: Pedro Rezende
Frank Küster wrote:
"Pedro A.D.Rezende" wrote:
Alexander Terekhov wrote:
Object code is a
well established term. GNUspeak is irrelevant. The
Copyright Act defines a computer program as"a set of statements or
instructions to be used directly or indirectly in a computer in order
to bring about a certain result. " 17 U.S.C. § 101.
The copyright act is
WRONG. A computer program can
NEVER be "a SET of statements or instructions...",
a computer program has to understood as "a SEQUENCE of statements or
instructions...".
I wouldn't be too sure
that "set" doesn't have a different meaning to lawyers than it has to
mathematicians or computer scientists. Anyway, I doubt whether
sequence is correct, too - unless you redefine sequence to include
conditional execution and loops.
[REVISED FROM POST]
Apologizing in advance for the length of this reply, I may say I'm
afraid this thread is only getting noisier.
Lawyers and lawmakers ought not pretend to be writing words for which
meanings have been settled for millenia (SET, SEQUENCE), to mean
differently in their writings just when their incompentence in using
them gets exposed. On the above doubt, please consider:
An instruction, whether jumpable (such as 'goto', 'if', 'loop') or
non-jumpable (such as 'move_data', 'add_integers'), is an element from
a finite set of instructions defined by a model of hardware or by a
lower level language. That is, defined by objects that give expression
to a computer program in their corresponding object code. Such a set of
instructions is defined by rules on how instructions can be coded by
bits (syntactic rules), and rules on how instructions cause the object
(in case of low level language, an interpreter program) to behave while
interpreting instances of these instructions (semantic rules).
The syntax for a jumpable instruction is just like the syntax for any
other instruction: it says that an instance of the instruction is to be
formed by a certain sequence of bits, the identity and lengtht of which
can be determined from inspection. An object code is formed by the
finite set of instructions (sequence of bits) obeying the object's
syntactic rules, plus the semantic rules. The semantic rules are those
rules which determine how instances of such instructions shall be
interpreted by one such object.
A (jumpable) instruction is determined to jump, or not to jump, only at
the
semantic level, by semantic rules. If a semantic rule dermines that
some instance of a jumpable instruction, while being interpreted, is
not to jump, the next instructon to be interpreted shall be, like with
non-jumpable instructions, the following instruction. The concept of
'following instruction' comes as a feature of the von-Neumann
architecture, used to build the commodity hardware in use since the
begining of digital programmable computers.
Thus, for the purpose of this discussion (author's right to
distributable software), the rules of an object code assume that a
program is formed by a SEQUENCE of instructions. Since the semantic
rules for jumpable instructions have to refer to positions where they
are to jump if the instance's context so determines, this can only be
achieved by references to marks or distances (in bytes) over the
sequence of instructions. Therefore, in the formation of an object
code, adherence to syntactic rules, which determine those marks and
distances through the sequence, have to precede the interpretation of
semantic rules, which refer to them.
Therefore, in the von-Neumann architecture (today's commodity
computers) the sequencing of instructions can not be extricated from
the concept of 'computer program', a fact that can be tested as
follows: what happens if I show you a bag filled with bits (a lawyer's
definition of 'SET of instructions'?), and tell you "this is a program
in object code", and ask you "show me the jumps!". What can you do?
Without knowing what object that code is for, you (or anyone else, for
that matter), can do nothing.
You can not tell which instances of instructions in that bag may cause,
or not cause, the execution of the program to jump when intepreted. In
fact, you can neither tell if an instruction is jumpable or
non-jumpable. Actually, you can not even tell where an instance of
instruction begins or ends. You, or any object, can only hope to do any
of these things if the bag's content is first parsed into a sequence of
instances of well-formed instructions, if the object is a commodity
hardware or computer language used at large since the begining of
digital programmable computers.
Thus, in such a context, any object code pressuposes, at a minimum,
that a program written to be interpreted by its objects shall be
construed as a (finite) sequence of instances of instructions, from the
(finite) set of syntactically well-formed instrucions. Refering to
computer programs by its form or expression, that is, as sequences of
instances of instructions from some object code, yelds a syntactical
definiton of computer program. This syntactical definition, in turn,
allows for a semantical definition of computer program, the part of the
definition that tells what a computer programs is for.
Thus, at least for the purpose of describing what is "out there", a
proper definition of computer program shall start with a syntactical
definition, which pressuposes sequences of instructions in some code,
irrespective of whether or how the semantics of any instruction under
such code establishes how instances of it may, during the
execution of the program, jump to a point in that sequence
other than the following instruction. Furthermore, the syntactical part
of the
definition has to precede the semantical part, for the latter is built
upon the former.
Another way to explain this is to say that a computer language, like
human languages, pressuposes that the copying of its texts has to
preserve the sequence in which the text is supposed to lay written, to
preserve its original intended meaning. And that the execution of a
program, expressed in some form of object code in a commodity computer,
pressuposes the copying (loading) of the program into (random access)
memory.
As a consequence, 'source code'
may become, with more than two levels of languages, merely a cardinal
direction of reference for interpretation, in
layered forms of expression for computer programs (the 'object code' in
one level becomes the 'source code' in the next lower level). This is
why we
can download computer programs, either in source or executable form,
over a copper wire ;-). Or why, in the definition quoted from the
copyrights act, the syntactical definition (where the word 'set' was
misused) precedes the semantical definition, in the sentence defining
computer programs.
Therefore, to say "object code is a well established term". Or that a
computer program is not a sequence of instructions because its
execution does not necessarity follow its written sequence, is
misleading at least.
You seem to be confusing the syntactical definition of computer program
(i.e.,
the program's EXPRESSION, the program in aristotelian category
'form', the part we were discussing in this thread), with the semantic
definition of program (i.e., the program's BEHAVIOUR, the program in
aristotelian category 'substance', the part we were NOT discussing).
In other words, one can safely say that a computer program is, or is
expressable as, a sequence of instances of instructions in some code.
This is irrespective of the fact that programs which include jumpable
isntructions may, while executing, have these instances interpreted in
a sequence which does not match the program's (written) sequence. In
other words,
the execution sequence (behaviour) may differ from the programming
sequence (form) if the program contains any jumpable instructions.
The correctness of the definition given in the copyright act can not be
feigned by pretending that the first part of the definitional sentence
is to mean what the second part is construed to mean (by choice of
verbs), or that lawyers and lawmakers would know how to better use
technical terms, and thus they so used some, in law, to mean
differently
than what they have always meant, without bothering to tell anyone
else.
Another sign of the quoted definition's incorrectness, and of its
drafter's incompetence, is that the copyrights act's definition of
'computer program' trivializes any attempt
to establish a method for telling programs apart, if the word SET is
read as in any english dictionary (can't find an entry for 'SET' in
legalese
dictionaries).
As it stands, any program that makes use of instances of the same set
of
instructions would be the same. As it stands, the semantic part of the
definition can not do the
job of distinguishing them. Nor could any semantic definition
distinguish
programs because, according
to Gödel's answer to the halting problem, there is no method to
generally distinguish the funtionality of two programs,
in the sense of generally determining what a program's 'result' will
certainly be. And there
can be no such method, neither distinguishing in advance, by another
program (ran on computer
or by human hand), nor 'on the fly', by runing two programs side by
side.
If such determination was not a theoretical impossibility, dictated by
the nature of the realm of symbols, computer security, for one thing,
would be a much less dounting enterprise and a much more precise
scientific field.
For those who can not phatom what has been said, I can only suggest to
go write a compiler.