Compilers

Compilers were the first sort of translator program to be written. The idea is simple: You write the program, then hand it to the compiler which translates it. Then you run the result.

Interpreters

An interpreter is also a program that translates a high-level language into a low-level one, but it does it at the moment the program is run. You write the program using a text editor or something similar, and then instruct the interpreter to run the program. It takes the program, one line at a time, and translates each line before running it: It translates the first line and runs it, then translates the second line and runs it etc.

Compiler characteristics:

• spends a lot of time analyzing and processing the program
• the resulting executable is some form of machine- specific binary code
• the computer hardware interprets (executes) the resulting code
• program execution is fast

Interpreter characteristics:

• relatively little time is spent analyzing and processing the program
• the resulting code is some sort of intermediate code
• the resulting code is interpreted by another program
• program execution is relatively slow

Compiler, transforms source code in one computer language to another one.

Interpreter, executes source code directly (usually inside its own virtual machine).

_{(source: answers.com)}

Generally interpreter is performance costly.

What is a translator?

An S -> T translator accepts code expressed in source language S, and translates it to equivalent code expressed in another (target) language T.

Examples of translators:

• Compilers - translates high level code to low level code, e.g. Java -> JVM
• Assemblers - translates assembly language code to machine code, e.g. x86as -> x86
• High-level translators - translates code from one PL to another, e.g. Java -> C
• Decompilers - translates low-level code to high-level code, e.g. Java JVM bytecode -> Java

What is an interpreter?

An S interpreter accepts code expressed in language S, and immediately executes that code. It works by fetching, analysing, and executing one instruction at a time.

Great when user is entering instructions interactively (think Python) and would like to get the output before putting in the next instruction. Also useful when the program is to be executed only once or requires to be portable.

• Interpreting a program is much slower than executing native machine code
• Interpreting a high-level language is ~100 times slower
• Interpreting an intermediate-level (such as JVM bytecode) language is ~10 slower
• If an instruction is called repeatedly, it will be analysed repeatedly - time-consuming!
• No need to compile code

Differences

Behaviour

• A compiler translates source code to machine code, but does not execute the source or object code.

• An interpreter executes source code one instruction at a time, but does not translate the source code.

Performance

• A compiler takes quite a long time to translate the source program to native machine code, but subsequent execution is fast
• An interpreter starts executing the source program immediately, but execution is slow

Interpretive compilers

An interpretive compiler is a good compromise between compilers and interpreters. It translates source program into virtual machine code, which is then interpreted.

An interpretive compiler combines fast translation with moderately fast execution, provided that:

• VM code is lower than the source language, but higher than native machine code
• VM instructions have simple formats (can be quickly analysed by an interpreter)

Example: JDK provides an interpretive compiler for Java.

The Difference vs How they Work

Q: What are Compilers and interpreters used for ?

A: Most programs are written in High-level languages (c#,java...). High-level languages are which contain understandable words and phrases. On the other hand computer (by the time I wrote this article that is) understand machine code which is 0's and 1's only aka Binary/Machine Code. Therefore we need to convert the High-level code into source code which is (Machine code/binary). Hence the word converting.

So we conclude a Compiler/interpreter job is to Translate high-level code into machine code.

But both have a different way of 'Translating' the code

Difference:

Compiler:

converts source code to some kind of intermediate form. For static language, a compiler usually converts the source code to assembly, which usually did not get stored to disk, then the assembler is invoked to convert the assembly to binary code, which is usually stored as object file(.o or .obj suffix usually), then linker is invoked to link object file(s) to binary executable. Also it is common to refer to this whole process of compiling, assembling, linking as compiling. So you may call gcc a compiler, but it actually invokes cc1 which is the compiler to compile, as which is the assembler to assemble, ld which is the linker to link.

Interpreter:

language which has a intermediate so called bytecode form, the source code is first converted to byte code, this process can be called compiling, javac serves as an example. Bytecode cannot be run on host machines, it needs a program, which is actually the process from the viewpoint of OS, to interpret the bytecode to the host machine, this program is called a interpreter, think of java. Some language, like python, do the compiling and interpreting work with a single

— both from: https://www.quora.com/What-are-the-differences-between-a-compiler-an-interpreter-and-an-assembler-Provide-examples

Comparing

Interpreter

• It takes less amount of time to analyze the source code but the overall execution time is slower.
• No intermediate object code is generated, hence are memory efficient.
• Continues translating the program until the first error is met, in which case it stops. Hence debugging is easy.

Compiler

• It takes large amount of time to analyze the source code but the overall execution time is comparatively faster.
• Generates intermediate object code which further requires linking, hence requires more memory.
• It generates the error message only after scanning the whole program. Hence debugging is comparatively hard.

— from: https://www.programiz.com/article/difference-compiler-interpreter

Examples with Languages

Interpreted

• Python
• Ruby
• PHP
• JAVA(Almighty)
• Perl
• R
• Powershell

compiled

• C
• C++
• C#
• Objective-C
• SWIFT
• Fortran

What is the difference between interpreter and compiler?

The Compiler scans whole program first and then translates it into machine code which will be executed by the computer processor.

The Interpreters translates one statement into machine language, executes it, and proceeds to next statement.

For example: Compiler will give almost all the error at once but interpreter will run till the instruction you have written wrong

How does an interpreter/compiler work?

• Unlike compiled languages which are translated into machine language ahead of time (right).
• Interpreted languages are translated at runtime.
• dBASE and BASIC interpreters (middle) translate the original source code.
• Java and Visual Basic (left) interpreters translate bytecode, which is an intermediate language compiled from the original source code.

Source

Look at PLAI book, it's the best intro to dymanic language realization I found ever:

Programming Languages: Application and Interpretation (c) Shriram Krishnamurthi

• [home] https://cs.brown.edu/~sk/Publications/Books/ProgLangs/2007-04-26/
• [html] http://cs.brown.edu/courses/cs173/2012/book/
• [pdf] http://www.cs.brown.edu/courses/cs173/2012/book/book.pdf

This book centers on writing interpreter for dynamic language in Scheme (dr.Racket), using it you can write your own interpreter for any language, and add some tips on OOP from

• [OOP PLAI] https://users.dcc.uchile.cl/~etanter/ooplai/ (c) Éric Tanter

and SmallTalk and SOM: Simple Object Machine:

• Virtual Machines for Teaching and Research
• A minimal Smalltalk for teaching of and research on Virtual Machines
• Smalltalk-80: The Language and its Implementation

All modern interpreters include compiler inside: compile highlevel elements into low-level but portable byte-code, or use JIT for compiling into machine code into RAM.

PS: If anybody wants to write SmallTalk system on Python, please note me.

Compilers - A compiler translates a source language to a target language. Then the target language takes input and gives output.

Compiler produces a target code by compiling source code

then target code then takes input and gives output

Interpreters - Instead of generating a target code, Interpreter appears to take input directly along with source code and gives output.

Interpreter maps input to output using the source program

Then machine-language targeted program produced by the compiler is much faster than the interpreter at mapping inputs to output. However, since interpreter executes source program line by line it gives better error diagnostics than compiler.

Reference - Compilers: Principles, Techniques, and Tools by Aho aka the dragon book

What is the difference between interpreter and compiler.

To put it directly and intuitively:

• Compiler is what translates the human-readable source code into machine code which the computer could read and execute.

• Interpreter is what pretends to be or simulates a computer to read and execute the source code directly.