How programs are compiled or interpreted in Intro to Computing - Mechanics & Internals

Overview - How programs are compiled or interpreted

What is it?

Programs are sets of instructions written by humans to tell computers what to do. These instructions need to be changed into a language the computer's hardware understands, called machine code. This change happens in two main ways: compiling, which translates the whole program at once before running it, and interpreting, which translates and runs the program line-by-line. Both methods help computers understand and execute human-written programs.

Why it matters

Without compiling or interpreting, computers would not understand the instructions we write because they only understand machine code. This would make programming impossible or extremely difficult. These processes allow us to write in easy-to-understand languages and still have computers perform complex tasks quickly and correctly. They bridge the gap between human ideas and machine actions.

Where it fits

Before learning this, you should understand what a program and programming language are. After this, you can learn about specific programming languages, how to write code, and how to run and debug programs. This topic is a key step in understanding how software works behind the scenes.

Mental Model

Core Idea

Compiling and interpreting are two ways to translate human-friendly code into machine-friendly instructions so computers can execute programs.

Think of it like...

Imagine writing a recipe in your language. Compiling is like translating the entire recipe into a language the chef understands before cooking. Interpreting is like having a translator who reads and explains each step to the chef as they cook.

┌───────────────┐        ┌───────────────┐
│ Human Code    │        │ Machine Code  │
│ (Source Code) │        │ (Binary)      │
└──────┬────────┘        └──────┬────────┘
       │                         ▲
       │                         │
       │                         │
┌──────▼────────┐        ┌───────┴────────┐
│ Compiler      │        │ Interpreter    │
│ (Translates   │        │ (Translates &  │
│ all at once)  │        │ runs line-by-line)
└───────────────┘        └────────────────┘

Build-Up - 7 Steps

1

Foundation

What is source code and machine code

Concept: Introduce the idea of source code as human-readable instructions and machine code as computer-readable instructions.

Source code is written in programming languages like Python or C. It uses words and symbols humans understand. Machine code is a series of 0s and 1s that the computer's processor can execute directly. Computers cannot run source code without converting it to machine code first.

Result

Learners understand the two types of code involved in programming: source code and machine code.

Understanding the difference between source code and machine code is essential because it explains why translation is necessary for computers to run programs.

2

Foundation

Why translation is needed for computers

Concept: Explain why computers cannot understand source code directly and need translation.

Computers only understand machine code, which is a low-level language made of binary digits. Source code is written for humans to read and write easily. To make computers execute instructions, source code must be translated into machine code. This translation is done by special programs called compilers or interpreters.

Result

Learners grasp the fundamental need for translation from human-friendly code to machine-friendly code.

Knowing why translation is necessary helps learners appreciate the role of compilers and interpreters in software development.

3

Intermediate

How compilers translate programs

🤔Before reading on: do you think a compiler translates code all at once or line-by-line? Commit to your answer.

Concept: Introduce the compiler as a program that translates the entire source code into machine code before running it.

A compiler reads the whole source code and translates it into a complete machine code program. This machine code is saved as an executable file. When you run this file, the computer executes the machine code directly without needing the compiler again. This process usually makes the program run faster.

Result

Learners understand that compiling produces a standalone machine code program ready to run.

Understanding that compiling happens all at once explains why compiled programs often run faster and do not need the source code at runtime.

4

Intermediate

How interpreters run programs

🤔Before reading on: do you think an interpreter translates the whole program first or translates as it runs? Commit to your answer.

Concept: Explain that an interpreter translates and executes source code one instruction at a time during program execution.

An interpreter reads the source code line-by-line or instruction-by-instruction. It translates each instruction into machine code and immediately runs it. This means the source code is needed every time the program runs. Interpreted programs usually start quickly but may run slower than compiled ones.

Result

Learners see that interpreters translate and run code simultaneously, requiring source code at runtime.

Knowing that interpreters work line-by-line helps explain why interpreted programs are easier to test and debug but may run slower.

5

Intermediate

Differences between compiling and interpreting

🤔Before reading on: which do you think is faster at running programs, compiled or interpreted? Commit to your answer.

Concept: Compare the main differences in how compilers and interpreters work and their effects on program speed and flexibility.

Compilers translate the whole program before running, creating a fast executable but requiring a separate compilation step. Interpreters translate and run code at the same time, making it easier to test and change code but usually slower to run. Some languages use both methods to balance speed and flexibility.

Result

Learners understand the trade-offs between compiling and interpreting.

Recognizing these differences helps learners choose the right approach for different programming needs.

6

Advanced

Hybrid approaches: Just-In-Time compilation

🤔Before reading on: do you think it's possible to combine compiling and interpreting? Commit to your answer.

Concept: Introduce Just-In-Time (JIT) compilation, which mixes compiling and interpreting to improve performance.

JIT compilers start by interpreting code but compile parts of it into machine code while the program runs. This way, frequently used code runs faster because it is compiled on the fly. Languages like Java and modern JavaScript engines use JIT to get the best of both worlds: quick startup and fast execution.

Result

Learners discover a modern technique that blends compiling and interpreting.

Understanding JIT shows how language designers optimize performance and flexibility in real-world systems.

7

Expert

Compiler and interpreter internals and optimizations

🤔Before reading on: do you think compilers just translate code directly or do they also improve it? Commit to your answer.

Concept: Explain that compilers and interpreters do more than translation; they analyze and optimize code for better performance.

Compilers analyze the source code to find ways to make the machine code run faster or use less memory. They perform optimizations like removing unnecessary instructions or rearranging code. Interpreters may also optimize by caching translated instructions. These processes are complex and involve multiple stages like lexical analysis, parsing, semantic analysis, and code generation.

Result

Learners appreciate the complexity and power behind compiling and interpreting beyond simple translation.

Knowing about optimizations reveals why compiled programs can be highly efficient and why interpreters can still perform well.

Under the Hood

Compilers work by first reading the entire source code and breaking it down into tokens (lexical analysis). Then they check the structure and meaning (parsing and semantic analysis). After that, they generate machine code, often optimizing it for speed or size. Interpreters read source code line-by-line, translate each instruction into machine code, and execute it immediately, sometimes caching results for speed. Both use complex internal steps to ensure correct and efficient translation.

Why designed this way?

Compilers were designed to produce fast, standalone programs by translating all code before running, which suits performance-critical applications. Interpreters were created to allow easier testing, debugging, and flexibility by running code directly, which suits scripting and learning. Over time, hybrid designs like JIT emerged to combine the benefits of both. These designs balance speed, flexibility, and ease of development.

┌───────────────┐
│ Source Code   │
└──────┬────────┘
       │
       ▼
┌───────────────┐
│ Lexical       │
│ Analysis      │
└──────┬────────┘
       │
       ▼
┌───────────────┐
│ Parsing       │
│ (Syntax Tree) │
└──────┬────────┘
       │
       ▼
┌───────────────┐
│ Semantic      │
│ Analysis      │
└──────┬────────┘
       │
       ▼
┌───────────────┐
│ Optimization  │
└──────┬────────┘
       │
       ▼
┌───────────────┐
│ Code          │
│ Generation    │
└──────┬────────┘
       │
       ▼
┌───────────────┐
│ Machine Code  │
└───────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Does a compiler run the program while translating it? Commit to yes or no.

Common Belief: A compiler runs the program as it translates the code.

Reality: A compiler only translates the entire program into machine code; it does not execute the program during compilation.

Why it matters: Believing this can confuse learners about when and how programs actually run, leading to misunderstandings about debugging and program behavior.

Quick: Do interpreters produce a separate executable file? Commit to yes or no.

Common Belief: Interpreters create a standalone executable file like compilers do.

Reality: Interpreters do not produce separate executable files; they translate and run code on the fly each time the program runs.

Why it matters: This misconception can cause confusion about program distribution and execution requirements.

Quick: Is interpreted code always slower than compiled code? Commit to yes or no.

Common Belief: Interpreted programs always run slower than compiled ones.

Reality: While interpreted code is often slower, modern techniques like JIT compilation can make interpreted languages run nearly as fast as compiled ones.

Why it matters: Assuming all interpreted code is slow may discourage using flexible languages that are efficient in practice.

Quick: Does compiling mean the program cannot be changed after compilation? Commit to yes or no.

Common Belief: Once a program is compiled, it cannot be changed or fixed without recompiling.

Reality: Compiled programs can be updated by recompiling, and some systems support dynamic linking or plugins to change behavior without full recompilation.

Why it matters: This misconception limits understanding of software maintenance and modular design.

Expert Zone

1

Some compilers perform multiple optimization passes, balancing between compilation time and runtime performance.

2

Interpreters often include debugging tools that leverage their line-by-line execution nature for better error reporting.

3

JIT compilers must carefully decide which code parts to compile to avoid slowing down startup times.

When NOT to use

Compiling is less suitable for rapid development or scripting tasks where quick changes and testing are needed; interpreters or REPL environments are better. Interpreting is not ideal for performance-critical applications where compiled languages excel. For some applications, ahead-of-time (AOT) compilation or hybrid approaches like JIT are preferred.

Production Patterns

In production, compiled languages like C and Rust are used for system software and performance-critical apps. Interpreted languages like Python and JavaScript are common for web development and automation. JIT compilation powers platforms like Java Virtual Machine and modern browsers to optimize performance dynamically.

Connections

Natural Language Translation

Both involve converting information from one language to another while preserving meaning.

Understanding how compilers and interpreters translate code helps appreciate challenges in translating human languages, such as context and ambiguity.

Assembly Language

Assembly is a low-level programming language closer to machine code, often the output target of compilers.

Knowing about compilation clarifies how high-level code is transformed step-by-step down to assembly and then machine code.

Human Learning and Teaching

Interpreting code line-by-line is similar to how teachers explain concepts step-by-step to learners.

This connection shows how breaking down complex tasks into smaller parts aids understanding and execution, both in computers and humans.

Common Pitfalls

#1 Trying to run source code without compiling or interpreting it.

Wrong approach:

double-clicking a .c file expecting it to run directly

Correct approach:

compile the .c file using a compiler to create an executable, then run the executable

Root cause:

Misunderstanding that source code needs translation before execution.

#2 Assuming interpreted languages do not need any preparation before running.

Wrong approach:

running a Python script without installing the Python interpreter

Correct approach:

install the Python interpreter first, then run the script through it

Root cause:

Confusing the language with the tool that runs it.

#3 Expecting immediate performance from interpreted code without optimization.

Wrong approach:

running large JavaScript code in a browser without considering JIT optimizations

Correct approach:

understand that modern JavaScript engines use JIT to improve performance during execution

Root cause:

Lack of awareness about runtime optimizations in interpreters.

Key Takeaways

Programs written by humans must be translated into machine code for computers to execute them.

Compilers translate the entire program before running, producing fast standalone executables.

Interpreters translate and run code line-by-line, allowing flexibility but usually slower execution.

Hybrid methods like Just-In-Time compilation combine compiling and interpreting for better performance.

Understanding these processes helps in choosing the right tools and languages for different programming tasks.