15 Hello world

15.1 The first program

By tradition, the first program greets the world.

#include <stdio.h>

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

This is a kind of work plan written in the grammar of the C language, and it is called source code. It becomes an executable file we can run only after a translator called a compiler turns it into machine code and joins it with already-made, pre-built machine code (called a library). Let us look at that process, and at what the first program actually produces.

But one more thing is needed before that. Where and how is the executable run once it is made? That place is the terminal.

15.2 The terminal and the shell — where a program is run

Chapter 10 showed “a band of characters flowing one line at a time”. Today’s window onto that band is the terminal. Open it and you can type characters; something answers what you typed.

Two words must be told apart here. They are used loosely as one, and they do different jobs.

That is, the terminal is the glass, the shell is the worker behind it. “Typing a command into the terminal” is really “typing a command to the shell through the terminal”.

15.2.1 Which windows and which workers

The window may be chosen by taste and the result is the same. But a different worker means a different grammar — the same job is written differently, which is why, when copying a command off the internet, the first question is “whose shell is this written for?”.

How to tell which worker you are talking to also differs.

15.2.2 What a shell does — read, split, run

Given a line, a shell always takes the same three steps.

1. Read — take the line up to the Enter.
2. Split — cut it into words at the spaces. The first word is what to do; the rest are the arguments.
3. Run — if the first word is something the shell knows itself, do it; otherwise find an executable file of that name and launch it.

The “something it knows itself” in that third step is a built-in command. It is fixed inside the shell, with no file of its own.

The names in parentheses are aliases — PowerShell attached familiar names like ls and cd to the same jobs for people arriving from Unix. Just remember that the same name is a different program.

15.2.3 Running the executable you made

Compile the first program and one executable file appears. How it is run differs a little by platform, and this is where beginners get stuck most often.

15.2.4 Passing arguments — how a program is handed values

The shell cuts a line into words, we said. What follows the first word is passed to the program, and those are its arguments.

gcc -Wall -o hello hello.c

Here gcc is what runs, and the four that follow are arguments. Arguments come in conventional kinds.

An argument containing a space is wrapped in quotes, because the shell splits words at spaces.

gcc -o "my program" hello.c     # when the name has a space

These are the shell’s rules, not C’s. How a C program receives those arguments — main’s argc and argv — is treated properly in chapter 53.

15.3 Compiling and running from the command line

Now to turn that work plan into an executable. There are many compilers, but the shapes reduce to three — GCC, Clang and MSVC. The first two share almost all their option syntax; only MSVC belongs to another lineage.

15.3.1 GCC (Linux, macOS, MinGW)

gcc -std=c23 -Wall -Wextra -o hello hello.c
./hello

Word by word: gcc is the program to call, -std=c23 says “read this as C23”, -Wall -Wextra says “tell me everything suspicious” (chapter 17 covers why these two are always on), -o hello says “name the result hello”, and the final hello.c is the material.

Drop the -o and the result comes out named a.out — a default handed down from early Unix, short for “assembler output”.

15.3.2 Clang (the macOS default; Linux and Windows too)

clang -std=c23 -Wall -Wextra -o hello hello.c
./hello

The options are GCC’s. It was built that way deliberately (chapter 18), so moving between the two rarely means editing a command. It is also why this book can cross-check its listings with both.

On macOS, typing gcc often calls Clang — gcc --version reveals the truth.

15.3.3 MSVC (Windows)

MSVC differs from the option syntax up. And it must be run in its own window.

cl /std:c17 /W4 hello.c
hello.exe

The own window is needed because MSVC leans on several environment variables (the paths to headers and libraries). The Start menu’s “x64 Native Tools Command Prompt for VS” opens a cmd with those set. Type cl in an ordinary cmd and you get “not recognized as an internal or external command” — not because the file is missing but because PATH was not prepared, exactly the previous section’s story.

15.4 And so the first program comes out like this

Here is the result of the two lines just typed — compile, then run.

Hello, world!

As with every result in this book, it is not decoration but what the machine really produced — every build compiles and runs the listing and puts its output here.

15.5 Reading it line by line

Having seen it run, we now read what each of those six lines says.

#include <stdio.h> — a declaration of what we need. It means “fetch the standard input/output toolbox”, and the printf used below lives in that box. The name stdio takes the bold letters from standard input/output — under the file-name length limits of early C such compressed names became the practice, which is why most standard header names are short.

The precise identity of lines beginning with # is revealed in the next chapter (preprocessing).

int main(void) — the agreed starting point. A C program that runs on top of an operating system, as the one we are making does (a hosted implementation), starts at the function named main. To run the program is to run main. Where there is no operating system, even the name of the starting point can differ — that story is in chapter 53. The meanings of the parentheses, of int and of void are unravelled in turn in Parts IV and V.

{ and } — the fences of beginning and end. Inside the fence is the list of things main will do.

printf("Hello, world!\n"); — the substance of this program. It calls the tool named printf and lets the letters inside the quotation marks flow onto the band of standard output. \n is the very newline character we met in chapter 10 — the typewriter’s legacy is already in the first program. The semicolon at the end is the full stop of a statement.

return 0; — the parting bow. It ends main and reports 0 to the operating system, meaning “finished without trouble.”

15.6 But what happened between source and execution?

We have just seen two objects: the source code a human reads and writes (hello.c), and the result the machine produced. But as chapter 4 taught, what a machine can execute is machine instructions only, and source code is just a text file — in the terms of chapter 9, a sequence of letters held in UTF-8. So somewhere in between there was a large event in which text became machine instructions.

The name of that event is compilation, and the next chapter tours the scene stage by stage. Seen from outside it is a single command; inside, a relay of four stages turns — in one of which our “order” #include is filled, and in the last of which it is revealed where the substance of printf comes from.