What's the difference between compiled and interpreted language?

[snehasaini]

Hello friends,

What's the difference between compiled and interpreted language?

[wpnukes]

Interpreted language is executed at the run time according to the instructions like in shell scripting and compiled language is one which is compiled (changed into Assembly language, which CPU can understand ) and then executed like in c++.

[sylvia]

In interpreted languages, the instructions are executed immediately after parsing. Both tasks are performed by the interpreter. The code is saved in the same format that we entered. Interpreted languages include the MS-DOS Batch language (the OS itself is the interpreter), shell scripts in Unix/Linux systems, Java, Perl etc. Advantages of interpreted languages include relative ease of programming and no linker requirement. Disadvantages include poor speed performance and that we do not generate an executable (and therefore distributable) program. The interpreter must be present on a system to run the program.

In compiled languages the instructions into machine code and store them in a separate file for later execution. Many modern compilers can compile (parse) and execute in memory, giving the 'appearance' of an interpreted language. However, the key difference is that parsing and execution occurs in two distinct steps. Examples of compiled languages include Visual Basic, C/C++, Delphi and many others. In a compiled environment, we have several separate files like: source code (the text instructions), object code (the parsed source code) and the executable (the linked object code). There is definitely an increase in complexity in using compilers, but the key advantages are speed performance and that one can distribute stand-alone executables.

[vaghela dev]

Hello
Please Read


Having got that out of my system, here's an answer:

• In a compiled implementation, the original program is translated into native machine instructions, which are executed directly by the hardware.
  
• In an interpreted implementation, the original program is translated into something else. Another program, called "the interpreter", then examines "something else" and performs whatever actions are called for. Depending on the language and its implementation, there are a variety of forms of "something else". From more popular to less popular, "something else" might be
  
  • Binary instructions for a virtual machine, often called bytecode, as is done in Lua, Python, Ruby, Smalltalk, and many other systems (the approach was popularized in the 1970s by the UCSD P-system and UCSD Pascal)
    
  • A tree-like representation of the original program, such as an abstract-syntax tree, as is done for many prototype or educational interpreters
    
  • A tokenized representation of the source program, similar to Tcl
    
  • The characters of the source program, as was done in MINT and TRAC

One thing that complicates the issue is that it is possible to translate (compile) bytecode into native machine instructions. Thus, a successful intepreted implementation might eventually acquire a compiler. If the compiler runs dynamically, behind the scenes, it is often called a just-in-time compiler or JIT compiler. JITs have been developed for Java, JavaScript, Lua, and I daresay many other languages. At that point you can have a hybrid implementation in which some code is interpreted and some code is compiled.

[ankigupta]

thanks for sharing the information.

[simar]

thanks for information.

[jobtardis]

It’s not correct to mention that a language is understood or compiled as a result of interpretation and compilation square measure each properties of the implementation of that exact language, and not a property of the language itself. So, in theory, any language will be compiled or understood – it simply depends on what the actual implementation that you just square measure mistreatment will.