Computer Science (9210) | Classification of programming languages and translators

Study Notes: Classification of Programming Languages and Translators

Hello future Computer Scientists! Welcome to the exciting world of programming. In this chapter, we are going to learn how humans (that's us!) communicate instructions to the computer and how the computer understands them. Think of this chapter as learning how to build a universal translator! Understanding these concepts is essential because it explains why your code eventually runs so fast.

1. Classifying Programming Languages

Programming languages fall into two main categories based on how close they are to the computer's native language (which is just 1s and 0s) or how close they are to human language.

1.1 Low-Level Languages (LLLs)

Low-Level Languages are very close to the hardware and the Central Processing Unit (CPU). They are often difficult for humans to read, write, and debug (fix errors).

Key Characteristics of LLLs:

• They are hardware-specific: code written for one type of CPU often won't work on another.
• They run very fast because they require little to no translation.

There are two main types of Low-Level Languages:

a) Machine Code

This is the only language the CPU natively understands. It consists entirely of binary digits (1s and 0s).

• Example: 0010 1100 0001 0000 (which might mean "add two numbers").
• Why it's hard: Imagine writing a novel using only 1s and 0s. It’s almost impossible for humans to manage!

b) Assembly Language

Assembly language was developed to make LLLs slightly easier for humans. Instead of 1s and 0s, it uses short codes called mnemonics (pronounced: nee-mon-iks).

• Mnemonics: Short, easy-to-remember abbreviations of instructions.
• Example: Instead of 0010, you might write ADD (for Addition) or MOV (for Move data).
• Requirement: Even though it uses words, Assembly language still needs a translator (called an Assembler) to convert it into Machine Code.

Quick Review: LLLs are fast, specific to hardware, and hard for humans. They are Machine Code (binary) and Assembly Language (mnemonics).

1.2 High-Level Languages (HLLs)

High-Level Languages are designed to be easy for humans to read, write, and understand. They use vocabulary and structures similar to human languages and mathematics.

Key Characteristics of HLLs:

• They are portable: Code written on one computer will generally run on many different types of hardware (e.g., Mac, PC, Linux) without major changes.
• They are abstract: The programmer doesn't need to know the specific details of the CPU hardware.
• They are easier to debug and maintain.

Example: Languages like Python, Java, C++, and JavaScript are HLLs.
If you want the computer to add two numbers, in a HLL you would simply write:

total = num1 + num2

This is much clearer than writing pages of 1s and 0s!

2. The Need for Translation

Here is the golden rule: The CPU can only execute instructions written in Machine Code (binary).

Since HLLs (like Python) are written in English-like words, they must be converted into Machine Code before the CPU can run them. This conversion process is called translation, and the programs that do this conversion are called translators.

Don't worry if this seems tricky at first! Translators are just like human interpreters in a foreign country—they bridge the communication gap.

3. Types of Translators (The Language Bridge)

There are three main types of software translators you need to know: Assemblers, Compilers, and Interpreters.

3.1 The Compiler

A Compiler is a translator designed to handle High-Level Languages.

How a Compiler Works:

A compiler translates the entire source code into Machine Code all at once, before the program runs.

1. The compiler takes the original High-Level code (the source code).
2. It checks the whole program for errors (syntax errors).
3. If there are no errors, it converts the entire program into a new file called object code (Machine Code).
4. This object code is saved as a stand-alone executable file (like a .exe file) that the user can run whenever they want, without needing the compiler again.

Advantages and Disadvantages of Compilers:

• Advantage (Speed): Once compiled, the program runs very fast because the translation is already complete.
• Advantage (Distribution): It creates a permanent executable file that can be sold or shared without sharing the original source code.
• Disadvantage (Development): The entire program must be error-free before any of it can be tested or run. Finding errors requires re-compiling the entire code, which can be slow.

3.2 The Interpreter

An Interpreter is also a translator for High-Level Languages, but it works very differently from a compiler.

How an Interpreter Works:

An interpreter translates and executes the source code line-by-line, while the program is running.

1. The interpreter reads the first line of the source code.
2. It translates that line into Machine Code.
3. It executes that line immediately.
4. It then moves to the next line and repeats the process.

Advantages and Disadvantages of Interpreters:

• Advantage (Debugging): If an error is found, the interpreter stops immediately and tells the programmer exactly which line the error is on. This makes testing and finding errors much faster.
• Advantage (Testing): The program can be run immediately, even if only a small part of the code is complete.
• Disadvantage (Speed): The program generally runs slower than compiled code because every line must be translated every time the program is executed.
• Disadvantage (No Executable): It does not produce a permanent, stand-alone executable file. The source code and the interpreter must be present every time the program is run.

3.3 The Assembler

The Assembler is the simplest type of translator. Its job is specific: to translate Assembly Language (mnemonics) into Machine Code (binary).

Since Assembly Language is already very close to Machine Code, this translation process is quite straightforward and usually very fast.

4. Comparing Compilers and Interpreters

The distinction between compilers and interpreters is a very important exam topic. You must be able to state the differences in their method, speed, and output.

Here is a side-by-side comparison table summarizing the crucial differences:

Key Differences in Translators

Did you know? Python, a very popular High-Level Language, usually uses an Interpreter for development because it makes debugging so fast! However, some companies use specialized compilers for Python when they need maximum execution speed.

Common Pitfall to Avoid!

A common mistake is forgetting that even though interpreters are slower to run the final program, they are often faster for the programmer during the development phase because they pinpoint errors instantly. Always specify why one is faster than the other (execution speed vs. debugging speed).