A processor executes instructions in machine code, which consists of binary instructions represented using 1s and 0s.
Programming languages can be grouped by how closely they relate to machine-level instructions and computer hardware.
The two broad categories are low-level languages and high-level languages.

A low-level language provides little abstraction from the computer’s hardware and has instructions closely related to processor operations.
Low-level languages give programmers greater control over hardware and can allow efficient use of processor operations and memory.
Low-level programs are generally more difficult and time-consuming to write, understand, debug, and maintain than high-level programs.
The two low-level languages are machine code and assembly language.
Machine code consists of binary instructions that can be executed directly by a processor.
Machine code does not require a translator before execution.
Machine code is difficult for humans to read, write, remember, and debug.
Machine code is hardware dependent because different processor architectures have different instruction sets.
Assembly language represents machine-code operations using short textual codes called mnemonics.
Assembly language cannot be executed directly by the processor and must be translated into machine code by an assembler.
Assembly language is easier for humans to understand than machine code but is still a low-level language because its instructions correspond closely to processor operations.
Like machine code, assembly language is hardware dependent because its instructions are designed for a particular processor architecture.

A high-level language provides greater abstraction from computer hardware.
High-level languages use more human-readable syntax and programming constructs rather than requiring programmers to specify individual processor operations.
High-level languages hide low-level hardware details from the programmer.
High-level languages are generally easier and quicker to write, read, debug, and maintain than low-level languages.
High-level languages are generally more portable because the same source code can often run on different computer systems when a suitable translator is available.
High-level source code cannot normally be executed directly by the processor and must be translated into executable instructions.

A translator is software that converts program code from one form into another so that it can ultimately be executed by the computer.
The three main types of translator are assemblers, compilers, and interpreters.
Translators are needed because a processor can only execute machine code, so programs written in other programming languages must be translated first.

A compiler translates the whole high-level source program into machine code before execution and produces an executable file.
The original program written by the programmer is called source code.
Once an executable has been produced, the unchanged program can be run again without translating the source code each time.
If the source code is changed, the program must be compiled again to produce an updated executable.
Errors are reported during compilation and must be corrected before a successful executable can be produced.
Advantages of using a compiler include that the program does not need to be translated each time it is run, compiled programs generally execute quickly, executables can be distributed without the source code, and errors can be identified before a successful executable is produced.
Disadvantages of using a compiler include that compilation can take time, source-code changes require recompilation, executables may need to be recompiled for different platforms, and even small changes must be recompiled before they can be tested.

An interpreter translates and executes high-level source code one instruction at a time while the program is running.
The interpreter repeatedly reads, translates, and executes each instruction before moving to the next.
An interpreter does not produce a separate standalone executable in the same way as a compiler.
The source code must be interpreted again each time the program is run.
Errors can be identified when the affected instruction is reached.
Interpreters allow changes to source code to be tested quickly without first compiling the whole program.
Interpreted programs generally run more slowly than compiled executables because translation takes place during execution.
Advantages of using an interpreter include that code can be run without compiling the whole program first, errors can be identified as affected instructions are reached, changes can be tested quickly, and the same source code may run on different platforms where a suitable interpreter is available.
Disadvantages of using an interpreter include that execution is generally slower because translation happens while the program is running, the source code must be interpreted each time it runs, a suitable interpreter is required, and no standalone executable is produced in the same way as with a compiler.

Module Review