Re: Obfuscators
Lew wrote:
carmelo, you are mistaken. Java is a compiled language. If it wer=
e
interpreted, the JVM would run source code directly, which it does not.=
Other
compiled languages have been decompilable pretty much since they were
invented. There's not even any logical reason to suppose otherwise -=
machine
code, ASM and "high-level" languages are all formally equivalent at lea=
st in
subsets thereof. If you can translate from Java to machine language,=
as Java
compilers do, there's no reason to suppose you couldn't translate just =
as
easily in the other direction.
carmelo wrote:
It seems really strange to me, because after compiling c++ code you'll
get a program written in native machine language. The java bytecode
it's not a native machine language, in fact the JVM (that it's
different for each machine) need to interpret the code and translate
it into native machine commands...
In principle it is no harder to translate from a physical machine
language to source than from bytecode to source. They are both
machine code, i.e., one is for a physical processor and the other for
a virtual processor. Bytecode *is* a "native machine language" -
native to the JVM.
Whether it seems strange to you or not, the facts are the facts.
Fact: Java is a compiled language.
Fact: Java bytecode is a native machine language, for the JVM and
certain processors.
Fact: Decompilers exist for all major machine languages, including
bytecode, back to source.
Fact: Any machine language is still a programming language. There is
no special magic in the translation from one direction compared to
another, other than accounting for features supported in one language
but not another.
Fact: These facts are evidenced by real-world tools.
Fiction: There is anything "strange" about any of this.
--
Lew