Every program we write eventually runs, but what does that really mean?
Before diving into complex runtime systems or performance tweaks, let’s start with the fundamentals.
In this section, we’ll explore what a “runtime” actually is, how it differs from compile-time, and what happens when your code finally comes to life inside the computer.
What does “runtime” mean?
When you write code, you’re simply describing what you want the computer to do. But that code, sitting in a file, does nothing on its own, it needs to run.
That moment when your program starts executing, when instructions are loaded into memory, variables are created, and functions begin to work , that’s called the runtime.
In simple terms 
Runtime = the period when your code is actually executing.
But more broadly, a runtime can also refer to the environment that makes your program run, including memory management, type checking, garbage collection, and interaction with the operating system.
print("Hello, world!")
Python
복사
Let’s say we’ve written the Python code shown above.
However, just writing it isn’t enough, the code won’t actually do anything on its own.
The moment we press “Run”, Python’s runtime begins to work behind the scenes.
1.
The Python interpreter is loaded into memory.
2.
It reads the code line by line.
3.
The string "Hello, world!" is stored in memory.
4.
The print() function sends that string to the console for display.
In that moment, the static text sitting inside a file transforms into a living program and the component responsible for making that happen is what we call the runtime.
Compile-time vs Runtime
When we write code, there are two distinct phases in which different kinds of work take place, compile-time and runtime.
Compile-time refers to the period when the program is being checked or translated before it actually runs. In compiled languages such as C or Java, this is when the compiler analyzes the code for syntax errors, type mismatches, or missing references.
Even in interpreted languages like Python, some static checks, such as verifying that the syntax is valid, still occur before the program begins execution.
Runtime, on the other hand, refers to the moment when the program is actively running. During this phase, variables are created, memory is allocated, and the logic defined by the programmer is executed step by step.
This is where the system interacts with real data, receives input from users, and produces visible results.
In simple terms, compile-time is the process of building the program, while runtime is the process of living the program. When you execute a line like print("Hello, world!") in Python, the interpreter first checks whether the syntax is correct, this is a compile-time step, even though Python doesn’t use a traditional compiler.
Once the syntax check passes, the interpreter executes the command: memory is allocated for the string "Hello, world!", and the print() function sends that text to your screen.
Although Python is an interpreted language, both concepts still exist. The difference is that the boundary between compile-time and runtime is much thinner, often happening almost simultaneously, yet understanding this distinction is crucial to grasp how programs are executed and where certain kinds of errors can occur.
Compile-time is like building and inspecting a car before it leaves the factory. Runtime is like driving that car on the road.Interpreter vs Compiler
When we talk about how a program runs, two major components come into play, the interpreter and the compiler. Both serve the same ultimate purpose, to translate human-readable source code into a form the computer can understand and execute.
However, the way they achieve this is quite different.
A compiler translates the entire program into machine code before it is executed. This means that once compilation is complete, the program can run directly on the computer’s hardware without needing the original source code or the compiler again.
Because the translation happens all at once, compiled programs usually run faster at execution time. However, if there’s even a single syntax error, the compilation process will fail, and the program won’t run until all issues are fixed. Languages like C, C++, and Java (after compilation to bytecode) follow this model.
An interpreter, on the other hand, translates and executes code line by line. Instead of converting the entire program into machine code ahead of time, it reads a single instruction, interprets it, and immediately executes it.
This makes interpreted languages more flexible and easier to debug because errors are detected as the program runs, but it also means they tend to run more slowly than compiled ones. Python, JavaScript, and Ruby are common examples of interpreted languages.
In essence, the compiler focuses on translation before execution, while the interpreter focuses on execution during translation.
Compilers prioritize performance, while interpreters prioritize flexibility and simplicity.
Compiler → Translates everything at once before execution (like a full written translation). Interpreter → Translates and executes line by line while the program is running (like live interpreting).Runtime system & runtime libraries
When a program runs, it does not operate entirely on its own. Behind the scenes, it relies on a runtime system that manages how the program interacts with the computer’s hardware and operating system.
The runtime system handles essential tasks such as memory allocation and deallocation, managing the call stack, handling exceptions, and controlling the overall flow of execution.
In higher-level languages, it also provides additional services like garbage collection, thread management, and security enforcement.
For example, when you execute a Python script, the Python interpreter automatically sets up a runtime environment that manages memory, executes functions, and provides built-in operations.
Similarly, in Java, the Java Virtual Machine (JVM) serves as the runtime system that executes compiled bytecode, manages memory, and ensures portability across platforms.
Alongside the runtime system, there are runtime libraries, which are collections of pre-written code that your program can use during execution.
These libraries provide commonly used functionalities—such as mathematical operations, file input and output, string manipulation, and system calls—so that programmers don’t have to implement them from scratch every time.
For instance, languages like C provide the Standard Library (stdio.h, math.h), while Python offers a rich set of built-in modules that can be imported and used instantly.
Together, the runtime system and runtime libraries make it possible for compiled or interpreted code to actually run smoothly on a real machine.
The runtime system ensures that the program executes correctly and efficiently, while the runtime libraries offer convenient building blocks that simplify development and improve reliability.
What happens when you run a simple Python or C program
When you run a program, a series of steps take place behind the scenes before you ever see the output on your screen. Although Python and C take different paths, one interpreted, the other compiled, they both follow the same general flow → translation, loading, and execution.
In the case of a C program, the process begins with compilation. The compiler translates the human-readable source code (.c file) into machine code, a binary format that the CPU can understand directly.
This compiled code is then linked with necessary runtime libraries (like stdio.h for input/output) to create an executable file, typically ending in .exe or no extension on Unix systems. When you run this executable, the operating system loads it into memory, sets up the runtime environment, and the CPU begins executing instructions line by line at machine speed.
In contrast, when you run a Python program, there’s no separate compilation step visible to the user. Instead, the Python interpreter first translates the source code (.py file) into bytecode, an intermediate representation that is platform-independent.
This bytecode is then executed by the Python Virtual Machine (PVM) part of Python’s runtime system, which interprets and runs the instructions one at a time. Even though this process happens quickly, it’s generally slower than compiled C code since each step must be interpreted during execution.
Regardless of the language, the runtime system plays a crucial role. It handles memory management, function calls, error handling, and system-level interactions while the program is running. Without this system in place, even the simplest “Hello, World!” program couldn’t reach your screen.
•
Example: what happens when you run a simple Python or C program
•
(Optional) Short exercise: tracing code execution step-by-step