Assembler, Interpreter, and Compiler

Banner Assembler Interpreter Compiler

In this blog we will discuss the following:-

  • Compilers
  • Different types of Compilers
  • Interpreters
  • Assemblers
  • Different types of Assemblers

Generally, the purpose of a translator is to translate that specific topic into an understandable form for the required person. In this case, a translator in a computer program is used to translate that programming into an equivalent form that is understandable by the computer without changing its functional or logical structure or the meaning of the program. The translations in a computer include the translation between the high-level language and human-readable computer languages such as C++, Java, and COBOL.


A compiler is a software (or combination of programs) that converts source code written in one programming language (the source language) into code written in another programming language (the target language) (the target language, often having a binary form known as object code). Creating executable software is the most typical purpose for translating source code. The term "compiler" refers to the software that translates source code from a high-level programming language to a lower-level programming language (e.g., assembly language or machine code). The compiler is known as a cross-compiler if the built application can run on a machine with a different CPU or operating system from the one on which the compiler runs. Compilers, more broadly, are a subset of translators. A decompiler is a software that converts a low-level language to a higher-level one. A source-to-source compiler or transpiler is software that translates between high-level languages. A language rewriter is a program that converts the form of expressions into another language without changing the language itself.
A parser generator, which is frequently used to assist in the creation of the lexer and parser, is also referred to as a compiler.

A compiler is likely to perform many or all of the following operations:

  1. Lexical analysis,
  2. Preprocessing,
  3. Parsing,
  4. Semantic analysis (syntax-directed translation),
  5. Code generation, and code optimization.

Because program errors produced by incorrect compiler behavior can be difficult to track down and fix, compiler developers put a lot of effort into ensuring compiler accuracy.
Compilers made it possible to create machine-independent programs. Machine-dependent assembly language was widely used prior to the invention of FORTRAN, the first higher-level language, in the 1950s. Assembly language, like machine code, produces more refinement on the same architecture, but it must be adjusted or rewritten if the program is to be performed on a different computer hardware architecture. Programmers could construct machine-independent source programs with the introduction of high-level programming languages that followed FORTRAN, such as COBOL, C, and BASIC. A compiler converts high-level source programs into machine-language target programs for specified hardware. The user can run the target program after it has been produced.

Types of Compiler

1. Single Pass Compiler:-The ability to compile in a single pass has long been regarded as a positive since it makes the process of developing a compiler easier, and one-pass compilers are typically quicker than multi-pass compilers. As a result, many early languages were expressly intended to be constructed in a single pass, partly due to the resource constraints of early computers (e.g., Pascal).
In certain circumstances, the design of a language feature may need more than one pass through the source code. Take, for example, a declaration on line 20 of the source that has an impact on the translation of a statement on line 10. In this situation, the first run must collect data on declarations that come after statements that they influence, with the actual translation taking place in a future phase. The downside of compiling in a single pass is that many of the advanced optimizations required to build high-quality code are not achievable. Counting how many passes an optimizing compiler does can be tricky. For example, various optimization stages may analyze one expression several times while only analyzing another expression once. Researchers interested in building observably accurate compilers employ the concept of breaking down a compiler into little programs. Proving the correctness of a collection of little programs frequently takes less time than proving the correctness of a single, bigger program.

2. Multi Pass Compiler:-While the majority of multi-pass compilers produce machine code in their final pass, there are a few exceptions: A "source-to-source compiler" takes a high-level language as input and produces another high-level language as output. An automated parallelizing compiler, for example, may commonly accept a high-level language program as input and then modify and annotate the code with parallel code annotations (e.g. OpenMP) or language structures (e.g. Fortran's DOALL instructions).

3. Incremental Compiler In a run-time environment that also includes interpreted functions, individual functions can be compiled. The incremental compilation has been used in Common Lisp systems since 1962 when the first Lisp compiler was released.

4. Stage Compiler Compilers that compile to a theoretical machine's assembly language, such as some Prolog implementations. The Warren abstract machine is another name for this Prolog machine (or WAM). Compilers for Java, Python and other languages are a subclass of this.

5. Just-In-Time Compiler Just-in-time (JIT) compilation, also known as dynamic translation in computers, is a compilation that occurs during the execution of a program, rather than before execution. This usually refers to translation to machine code, which is then immediately executed, although it may also refer to translation to a different format.JIT compilation combines some of the benefits and disadvantages of the two traditional techniques to machine code translation – ahead-of-time compilation (AOT) and interpretation.

With the overhead of an interpreter and the extra overhead of compiling, JIT compilation combines the speed of compiled code with the flexibility of interpretation (not just interpreting).JIT compilation is a type of dynamic compilation that allows for adaptive optimization such as dynamic recompilation. As a result, JIT compilation can theoretically result in quicker execution than a static compilation. Because the runtime system can handle late-bound data types and impose security requirements, interpretation and JIT compilation are particularly well suited for dynamic programming languages.

Advantages of Compiler

  • Because the source code is not provided, generated code is safer than interpreted code.
  • Produces code more quickly than understanding source code.
  • Produces an executable file, allowing the program to be executed without the need for the source code.

Disavatages Of Compiler

  • Before a final executable file can be created, object code must be created, which can be a lengthy process.
  • For the executable file to be created, the source code must be error-free.


An interpreter is a computer program that immediately executes, that is, performs, instructions provided in a programming or scripting language without first compiling them into a machine language program in computer science. An interpreter is a program that takes a source program and data as input and then translates the source program instruction by instruction.

Let us understand more about interpreters through some examples

  • A class file is translated into code that can be run directly on the supporting computer by the Java interpreter java.
  • VirtualPC is a tool that converts applications written for the Intel Pentium (IBM-PC clone) architecture to the PowerPC architecture (Macintosh). Users of Macintosh computers may now run Windows apps on their machines.


  1. Because each operator in a command language is generally an invocation to a sophisticated process such as an editor or compiler, interpreters are commonly employed to run command and glue languages.
  2. In an interpreted language, self-modifying code is simple to implement. This has something to do with the roots of interpretation in Lisp and AI research.
  3. Virtualization: A virtual machine, which is effectively an interpreter, may run machine code written for one hardware architecture on another.
  4. Sandboxing: A virtual machine or interpreter is not required to execute all of the instructions in the source code it is processing. It can, for example, refuse to execute code that breaches any security restrictions it is subject to.

Advantages Of Interpreter

  • Debugging (checking for errors) is easier than using a compiler.
  • It would be easier to write multiplatform programming since each platform would have its own interpreter to run the same code.
  • Prototyping software and testing fundamental program logic are both possible with this tool.

Disadvantages Of Interpreter

  • The application must have source code in order to run, and this source code may be read, making it insecure.
  • Because of the per-line translation process, interpreters are often slower than compiled applications.


Assembly language is translated into machine code by an assembler. An assembler is a software that converts notations and syntax for operations and addressing modes into numerical counterparts, resulting in object code.

Assembly Languages

It consists of mnemonics for machine opcodes, which are translated 1:1 from mnemonic to direct instruction by assemblers. An assembly language (or assembler language) is a low-level programming language for a computer or other programmable device in which the language and the architecture's machine code instructions have a very strong (usually one-to-one) connection. In contrast to most high-level programming languages, which are typically portable across many architectures but require interpreting or compiling, each assembly language is specialized to single computer architecture. A utility software known as an assembler converts the assembly language into executable machine code; the conversion process is known as assembly or assembling the code.

Types Of Assemblers

Based on how many passes through the sources, assemblers are classified into two types.

  1. One-Pass Assemblers:-One-pass assemblers look at the source code only once. Any symbol used before it is defined will need "errata" at the conclusion of the object code (or, at the very least, no earlier than the point where the symbol is declared), instructing the linker or loader to "go back" and overwrite a placeholder left where the as yet undefined symbol was used.
  2. Multi-Pass Assemblers:-In the initial passes, multi-pass assemblers establish a table with all symbols and their values, then utilize the table to produce code in subsequent passes.

In both circumstances, the assembler must be able to calculate the addresses of the following symbols by determining the size of each instruction on the initial passes. This means that if the size of an operation referring to an operand defined later depends on the type or distance of the operand, the assembler will make a pessimistic estimate when encountering the operation and pad it with one or more "no-operation" instructions in a later pass or the errata if necessary. Addresses may be recalculated between passes in an assembler with peephole optimization, allowing pessimistic code to be replaced with code customized to the precise distance from the target. The usage of one-pass assemblers was originally motivated by the need for speed, as a second pass would frequently need rewinding and rereading a tape or rereading a deck of cards. This is no longer an issue with modern computers. The absence of errors in the multi-pass assembler makes the linking procedure (or the programs load if the assembler outputs executable code directly) quicker.

Application Of Assemblers

  • Assembly is commonly used in a system's boot code, which is the low-level code that initializes and tests the system hardware before booting the operating system and is generally placed in the ROM. (An example is BIOS on IBM-compatible PC systems and CP/M.)
  • Some compilers transform high-level languages into assembly code before completing compiling, allowing debugging and optimization of the assembly code.
  • C and other low-level languages allow the programmer to directly include assembly language in the source code. Programs that use such features, such as the Linux kernel, may subsequently create abstractions on each hardware platform using a separate assembly language. Through a consistent interface, the system's portable code may access these processor-specific components.
  • In reverse engineering, assembly language comes in handy. Many programs are only available in machine code, which is easy to translate into assembly language but difficult to translate into a higher-level language. The Interactive Disassembler, for example, makes extensive use of disassembly for this purpose.
  • Assemblers can be used to generate data blocks from formatted and commented source code with no high-level language overhead, which can then be used by other code.

Advantages of Assemblers

  • Very quick at translating assembly language to machine code in a one-to-one ratio.
  • Because assembly is a low-level language, it is often very efficient (and thus fast).
  • Because of the use of English-like mnemonics, assembly code is fairly easy to understand.

Disadvantages Of Assemblers:

  • Assembly language is a programming language that is tailored to a certain instruction set and/or processor.
  • Because assembly is optimized for the hardware it is intended for, it is frequently incompatible with other hardware.
  • Simple jobs need a lot of assembly code, while complicated programs necessitate a lot of programming time.

Download CuriousJr for more updates on Coding for Kids.
Happy coding!