What is the difference between object code and machine language?

Answer 1

The whole notion of "virtual" has become rather stretched in recent years, but the traditional distinction was that machinecode executes directly on the hardware, whilst bytecode is executed by a software emulator of a fully specified mythical machine. Bytecode is important to the UCSD Pascal p-system, to Forth, to SmallTalk, and more recently to Java. Of course, one could certainly build hardware which properly executes any of those bytecodes, and some folks have done just that.

Answer 2

Generally, "machine code" refers to the data that can be executed by a certain computer, while "bytecode" refers to data that can be executed by a virtual machine. The virtual machine takes the bytecode and produces machine code appropriate for the actual machine it is running on.

Answer 3

Source code is the code that the programmer writes. It must pass through the compiler, where it is compiled into bytecode. Bytecode is a condensed and optimized form of the original source code. It is then interpreted by the JVM and executed.

Answer 4

the Java virtual machine is an interpreter. It translates byte code into machine coded subroutines. the Java compiler produces the byte code. The byte code can be executed upon any Java virtual machine without modification, regardless of the underlying hardware. The Java compiler creates the byte code from the high-level source code.

Answer 5

It depends on the programming language.

In general, "byte code" and "machine code" mean the same thing.

In Java: When source code is compiled, it is turned into byte code (in the form of a .class file). These class files are used by the Java Virtual Machine to translate byte code into native machine code on the fly in order to execute your program.

Answer 6

Source code is the code that programmers write while machine code is the native language of the machine. Although it is possible to write programs entirely in machine code, it is extremely difficult, tedious, prone to error and hard to debug. Moreover, machine code is non-portable, it is specific to a machine with a particular architecture; it is machine-dependent code.

Source code is generally written using a high-level programming language. High-level languages make it much easier for programmers to express their ideas in code because the source code is not machine-dependent. That is, the same source code may be executed on a wide variety of machines. However, in order to execute the code, the source must be converted to machine code. This is achieved by using another program known as a compiler. Most compilers produce machine code, however each machine requires its own compiler to produce the machine-specific code. Some programming languages are interpreted rather then compiled, which means the translation program (the interpreter) needs to be memory-resident while the program is executing. Interpreted languages are generally converted into machine code and executed one line at a time rather than converting the entire program at once. As such, interpreted languages are much slower than compiled languages. However, some languages are both compiled and interpreted, such that the compiler produces an intermediate code known as byte code which is then interpreted. These are faster than the purely-interpreted languages because the compiler can optimize the byte code, but they are still very much slower than their purely-compiled counterparts. The main advantage is that the same byte code can be executed on any machine with a suitable interpreter. With purely-compiled languages, the source code has to be recompiled for each architecture.

High-level programming languages evolved from low-level languages. The earliest programming languages became known as assembly languages. These are symbolic languages that map near 1:1 with the machine code produced by the translator (the assembler). There is very little abstraction between the source code and the machine code thus they are machine-dependent languages and therefore low-level languages. Assembly languages made it much easier to write machine code programs and thus made it easier to create compilers and interpreters for the next generation of languages, the high-level languages. Once we had one high-level language, we could then use it to produce more advanced compilers and interpreters for even more abstract languages, a process that is still going on today.

Answer 7

Byte code typically uses fixed-width 8-bit groupings (bytes), whereas bit code can use any combination of fixed-length and variable-length groupings. Data is typically read 1 bit at a time, such that the initial bits determine the structure of the stream of bits that follow.

Answer 8

Object code is the output of the compiler. It contains instructions and tokens like your source code, but in a compact and optimized (often executable) format. It can also contain other things like debugger symbols. Usually, object code is then processed by the linker, which connects the object code from each compilation unit together to form an executable (or library, such as a dll). The executable or library contains machine code, which can be executed directly by the processor and is specific to the machine architecture and operation set.

Answer 9

There is no difference between machine code and native code. They are one the same thing.