|
|
|
| Authored by: IANALitj on Saturday, May 19 2012 @ 11:08 AM EDT |
The USPTO is not omniscient nor inerrant (at least the last I heard).
Isn't it permissible to argue to a jury the same prior art that was not accepted
by the USPTO?
I do think that -- given the limited time available -- Google was correct to
pick one argument to make, rather than two. I gather that the simpler one was
chosen. It may also have been the stronger.[ Reply to This | Parent | # ]
|
| |
| Authored by: Anonymous on Sunday, May 20 2012 @ 07:54 AM EDT |
It may be a bit of a stretch, but has anyone considered the old language FORTH
and its use of symbolic references? It is heavily stack oriented, there is no VM
involved, but to me the language operates 100% on symbolic references.
For you younger guys and girls, FORTH is language from the 1970's that was a bit
like writing programs for a RPN calculator. It was stack-oriented and didn't
have statements as such, but essentially executed single symbols. So the
equivalent of x = 2 + 5; was written
2 5 + X !
This put 2 on the stack, 5 on the stack, add the two top stack items replacing
them with the result, put the address of X on the stack, and stored the second
value on the stack at the address identified by the first item on the stack,
popping both after the operation.
FORTH stores its programs as a big linked list. Each entry contains the symbol,
a pointer to the code that executes the function, and a list of parameters. What
is most interesting is that most of the time, the code pointer points to FORTH's
interpreter and the parameters are the addresses of other symbols in the
language. The interpreter just steps through the addresses calling one function
after another until the end when it returns.
To execute the above example, FORTH takes each symbol in turn and searches its
linked list for a matching symbol. If found, it executes the function indicated
by its code pointer. If the symbol is not found, FORTH tries to interpret the
symbol as a numeric value and if it works, puts that value on the stack.
The example above would execute instantly. If you entered
: Useless 2 5 + X ! ;
FORTH would put this in a function called Useless. To execute it, you would type
"Useless<CR>" and it would search its linked list looking for
the symbol "Useless" and when found, execute the interpreter indicated
by its code pointer.
So, what is the similarity with patent 104? To create Useless, Forth would
execute the ":" which is FORTH's 'compiler'. ":" consumes
the next word and add a new symbol of the given name. It adds a pointer to its
interpreter. From here it gets interesting. FORTH then takes each symbol that
follows and just like when it executes, it searches its linked list for a
matching symbol and if it finds one, it resolves that symbol to an address and
stores the address in the new function it is compiling as a parameter. It does
this with all of the symbols it finds until the ";" that terminates
this compilation process.
FORTH programs are never stored in this compiled form as the addresses are
dependent on the physical memory address containing the final code.
Consequently, FORTH programs are saved in their symbolic reference form. These
symbolic references are resolved to addresses as the program is loaded using a
similar process to what is done when the code is executed.
Sound familiar?
Now, a bit of a diversion...
IIRC, FORTH was used by John Dykstra for the then cutting edge special effects
for the original Star Wars movie.
Also, for any Hitchhikers Guide to the Galaxy fans, try the following
: 9 7 ;
6 9 * . <CR>
Result : 42. Yes, we redefined "9" as a symbol that puts the value 7
on the stack.
Alternatively,
DECIMAL 13 BASE ! 6 9 * . <CR>
Result : 42. 42 in base 13 is 54 decimal.[ Reply to This | Parent | # ]
|
| |
| Authored by: Anonymous on Monday, May 21 2012 @ 09:22 AM EDT |
I'm still not clear on the patents. Are the patent(s) about the Java
run-time,
jvm, using symbolic references to initialize an array vs. a run-time,
dex vm,
statically initializing an array?
In the early 80's,
Management Science America, MSA, had a project that
produced a product that was
portable across different machines and OS's. I
designed and wrote the
run-time, vm, for it. We worked in the same large
room. For an array, the
compiler generated instructions that the run-time
used to initialize
arrays.
Since I'm not at all clear on what the patents cover, I don't
know if this is
pertinent.
Brenda H.
[ Reply to This | Parent | # ]
|
|
|
|
|
