Compiler, Interpreter, and What Happens When You Press Run

David writes eight lines to work out the diagonal of a square. He includes <math.h>, calls sqrt, presses Run, and gets this back: undefined reference to 'sqrt'. He stares at it. He did include the header.

He did not write a function called sqrt, so something else is complaining. It is not the part of the compiler that reads his code.

David is meeting the fact that "compiling" is not one program. It is four programs in a row, each with its own job and its own complaints. Once you know which one is talking, most error messages stop being frightening.

The translator and the interpreter

Imagine a technical manual written in Japanese that you need in Bangla.

Option A, the compiler. A translator takes the whole manual and works for a week. You get a complete Bangla book. The translation happens once, so reading it afterwards is as fast as reading any book. A grammar mistake in the original is caught during that week, before you read a page.

Option B, the interpreter. A human interpreter stands beside you and translates line by line as you read. You can start immediately. Every reading is slower, and a mistake on page 400 is only found when you reach page 400.

C is Option A. Python, JavaScript and PHP are closer to Option B. That one choice explains most of the differences you will meet.

The four stages of compiling a C program

When you compile hello.c, four separate programs run one after another. Each takes a file and produces a new one.

The fourth stage is the one that caught David. The compiler was happy: <math.h> promised that a function named sqrt exists somewhere. The linker's job is to find the actual machine code for it. On many Linux systems the maths part of the library is a separate file. You ask for it by adding -lm to the command.

Why this matters when you see an error

Every message below is real output from GCC. Read the table as a lookup: find the shape of your message, and it tells you who is speaking.

A version note. The two middle rows, the missing prototype and the wrong type, are warnings on GCC 12 and errors on GCC 14.

Two things are worth noticing. A warning does not stop the build, and it is usually right anyway. And the last row has no compiler in it at all. That brings us to the most important sentence in this lesson.

"It compiles" is not "it is correct"

The compiler checks grammar, not meaning. It will happily build a program that gives the wrong answer every single time. You will see one in Example 3 below.

gcc -std=c17 -Wall -Wextra hello.c -o hello

#include <stdio.h>

int main(void)
{
    printf("Hello, C.\n");
    return 0;
}

Hello, C.

#include <math.h>
#include <stdio.h>

int main(void)
{
    double side = 2.0;
    printf("The diagonal is %.4f\n", side * sqrt(2.0));
    return 0;
}

The diagonal is 2.8284

#include <stdio.h>

int main(void)
{
    int marks[2] = {7, 8};
    int average = (marks[0] + marks[1]) / 2;

    printf("Average of 7 and 8 is %d\n", average);
    return 0;
}

Average of 7 and 8 is 7

Compiler and interpreter, side by side

Here is a demonstration of row three. This Python program has a spelling mistake in a function that is never called.

def never_called():
    prnt("this line is wrong")

print("Python starts running anyway")

Python prints its line and exits happily. The mistake is inside a function nobody calls, so nothing ever reads it. Put the same kind of mistake in a C file and the compiler refuses to build. It reads every line, whether or not that line will run.

Real life is a little blurrier: JIT

Java and C# do both. They first compile to a middle form called bytecode. While the program runs, a JIT (just-in-time) compiler turns the busiest parts of that bytecode into real machine code.

Modern JavaScript engines do the same thing to your browser's code. The classic split above still explains the trade-off you are choosing. Almost nothing in 2026 is purely one or the other.

What the Playground actually does

When you press Run on a Progsity Playground page, nothing magic happens. Your program is sent to a separate machine, written to a file, and compiled by GCC 12. The command is gcc -O2 -std=c17 -lm, with no -Wall and no -Wextra on it. All four stages run there, in the same order as Figure 1.

That missing -Wall matters. The Playground prints the messages GCC gives by default, so a missing prototype still shows, and a %s fed a number does not. The syntax card above is the command to run on your own machine, where you want every warning.

The compiled program then runs inside a sandbox, with a time limit and a memory limit. Its output comes back to your browser. That is the whole trick. You are using the same toolchain you would install locally, without installing it.

printf("Hi\n")
return 0;

int area(int w, int h);      /* a promise */

int main(void) {
    printf("%d\n", area(3, 4));   /* nobody kept it */
    return 0;
}

int n = 5;
printf("%s\n", n);

gcc -E hello.c -o hello.i     # stop after stage 1
gcc -S hello.c -o hello.s     # stop after stage 2
gcc -c hello.c -o hello.o     # stop after stage 3
gcc hello.o -o hello          # stage 4 only

Next you will look for C in the day you have already had. It starts with the alarm that woke you and ends with this page.