|
|
|
| Authored by: Anonymous on Tuesday, May 15 2012 @ 11:56 AM EDT |
I don't recall the code you cite being testified to by anyone. You could be
looking in the wrong place for all I know.[ Reply to This | Parent | # ]
|
| |
| Authored by: Anonymous on Tuesday, May 15 2012 @ 12:09 PM EDT |
You forgot one key element, most if not all "symbolic" referances get
changed by the compiler/linker when the bytecode is created. The whole concept
of using symbolics referances are for us humans when writing code to better keep
track of what the code is doing. Once the code has been change into bytecode all
of these get changed into machine accessible referances (memory offesets,
indexes, etc). This is done by the complier/linkers (for which there is plenty
of prior art) not alledged Google code. So if any symbolic referances exist at
all it is because the language/compiler/linker in question retaines them for
some reason as functional components in the bytecode vs as commetents (non
executed instructions). This is one of the main reasons why many programers on
here are frothing at the bit over this concept. The whole concept of a symbolic
referance is a human thing not a machine thing, its simply how
computers/programming works, and to have been granted an actual patent involving
it is laughable at best.
Also as mentioned several times Static and Dynamic mean specific things in the
programming world and since this is a "software patent" one should be
allowed (forced in my opinion) to use the language/terminology associated with
software ware development, i.e. programming. If I act on data at rest (a file)
it is static, if I act on a file/executing instructions while it is actually
running that is dymanic. Not to use another analogy but I think this one may fit
rather well:
If I turn off my car and then change the oil and other fluids I am acting on the
car statically.
If I attempt to do the same things except the engine is on/running that is
Dynamic. Since the code Oracle alledges violates their patent does not act on
the application while it is actually running/executing (i.e. dynamically)but
rather acts on the program file which containes the application (i.e.
statically) the code does not violate their patent.
- Ish
[ Reply to This | Parent | # ]
|
| |
| Authored by: Anonymous on Tuesday, May 15 2012 @ 12:18 PM EDT |
The symbolic reference has to be in the instruction, or it doesn't match the
claims.
Patent claims are extremely specific, and all the claims have to be met exactly.
It's not enough that somewhere in the sources there is some symbolic resolution
occurring, when the symbolic reference is not in the instruction.
A different patent could cover the case of a symbolic reference being located in
a table, but this one does not, and it's totally unacceptable to suggest that
this second reference pathway is covered as well when it's not stated
explicitly.
If patents could cover mechanisms not specified explicitly in their claims, the
current patent disaster would go into total meltdown.[ Reply to This | Parent | # ]
|
| |
| Authored by: Anonymous on Tuesday, May 15 2012 @ 11:56 PM EDT |
Your code has Java doing symbolic lookup, not Dalvik, unless I'm sadly
misreading what you said. I don't think anyone has argued that Java doesn't do
this, only that Dalvik does not, having replaced searching for the right symbol
with the exact offset location in the table.
Even if the symbol remains in the table, Dalvik doesn't appear to be using it.
I would have difficulty saying that they were dereferencing a symbolic reference
when they were jumping to the location of that symbol's data directly.
After all, that's the point here: Google didn't use the crappy way of doing
things that was patented for Java, they replaced it with a better way. They
might still need that data in the class file, but they've replaced all the
symbolic references with direct offsets.
So I'm not sure I agree.[ Reply to This | Parent | # ]
|
|
|
|
|
