Compile and Run It Yourself: the Playground and a Local Toolchain

The Playground is a real GCC in a sandbox on a machine in Singapore. A local toolchain is the same GCC on your own disk. Neither is the serious one; they are the same compiler in two places.

So this lesson is not an instruction to install anything. Everything in this track runs in your browser, forever. Read the second half when you want your own copy, and skip it happily until then.

The Playground: a real GCC, on somebody else's machine

Every example in this track has a Run link, which opens the Playground with the program already loaded. Four parts of that page matter.

The editor holds your program. The Run button sends it away, and a second later the output pane shows what it printed. The input box is where you type what the program reads, which is how every problem in this module is tested.

Your file is written to disk on that machine, compiled, and run inside a sandbox with a time limit and a memory limit. If your program waits for input that never comes, the time limit ends it, and that is a real result rather than a hang.

There is also a limit on how many runs a minute one visitor gets. A "too many requests" message means wait, not break.

So a Playground run is a compile and a run on a real machine. The one thing it hides from you is the command line.

The exact command the Playground uses

It is this, and it is pinned, which means you cannot change it from the page:

gcc -O2 -std=c17 -lm

Three things follow from it, and the third one is the one to remember.

-O2 asks for optimised machine code, so the program runs fast. -std=c17 is the standard this track teaches. -lm is already there, so the maths library is always linked for you.

And there is no -Wall on it. The Playground prints the messages GCC gives by default, and nothing more.

That has a consequence worth stating plainly. A message you see on your own machine may be silent in the Playground. An unused variable, a %s handed a number, an if with one =: all three are quiet there and all three are warnings under -Wall.

The reason is a rule rather than an oversight. The compiler options are fixed per language and the list of options a client may add is empty. Every reader gets the same toolchain.

So the Playground is the honest floor: if it builds there, it builds for your teacher too. Your own machine is where you go looking for more warnings than the floor requires.

Installing GCC, on three operating systems

Only if you want to. Five lines each.

Linux. Open a terminal. On Debian or Ubuntu run sudo apt update and then sudo apt install build-essential. On Fedora run sudo dnf install gcc. Check it with gcc --version. You are done.

macOS. Open Terminal and run xcode-select --install, then accept the dialog that appears. That installs the Command Line Tools, which include a compiler. Check it with gcc --version. On macOS that name actually runs Clang, which is fine for everything in this track.

Windows, the recommended way. Install WSL, the Windows Subsystem for Linux, by running wsl --install in PowerShell as administrator and restarting. Open the Ubuntu app it gives you and follow the Linux instructions above. You now have a real Linux toolchain beside Windows, which is what most professional C work uses.

Windows, without WSL. Install MSYS2 from its own site, open its UCRT64 shell, and run pacman -S mingw-w64-ucrt-x86_64-gcc. Add its bin folder to your PATH if you want gcc in other terminals. This is a real GCC, and one difference matters below.

So every path ends in the same place: a gcc you can type at a prompt.

The four commands you will actually type

Save a program as hello.c and you are four commands away from everything in this module.

1. Compile. gcc -std=c17 -Wall -Wextra hello.c -o hello reads your file and writes a program called hello.
2. Run. ./hello on Linux and macOS; hello.exe or .\hello.exe on Windows.
3. Read the status. echo $? prints the number main returned, which lesson 1 promised was not decoration.
4. Link the maths library. gcc -std=c17 hello.c -o hello -lm, needed on Linux whenever you call sqrt, pow or sin.

Two notes about that last one. On Linux the maths code sits in a separate library file. Leaving out -lm gives you undefined reference to 'sqrt' from the linker, which is Module 0, lesson 4 in action. On Windows with MSYS2, and on macOS, it links without the flag. The Playground passes -lm always, so the question never arises there.

So -Wall -Wextra is the habit, and -lm is the flag you will forget exactly once.

The stage flags: stopping the pipeline early

Module 0, lesson 4 described four stages: preprocessor, compiler, assembler, linker. Three flags stop after each of the first three, and they are the cheapest way to see that the stages are real.

Try gcc -E hello.c | wc -l once. Seven lines of yours become more than a thousand, which is stdio.h arriving. It explains why a missing header is a stage 1 failure.

Reading your first warning

A warning is the compiler saying "this is legal, and I do not believe you meant it". It never stops the build.

The three you will meet first, all of them under -Wall and all of them silent without it:

• warning: unused variable 'total'. You declared it and never used it, which usually means an edit is half finished.
• warning: format '%s' expects argument of type 'char *', but argument 2 has type 'int'. The placeholder and the value disagree, and this one usually ends in a crash.
• warning: suggest parentheses around assignment used as truth value. The = and == trap from lesson 2, caught.

Treat every one as an error you have not been bitten by yet. Beginners who build with warnings on find bugs days earlier than beginners who do not, and professional projects turn warnings into errors on purpose.

So a clean build under -Wall -Wextra is a stronger claim than a clean build in the Playground, and that is the only way the two differ.

gcc -std=c17 -Wall -Wextra hello.c -o hello
 |     |         |           |      |
 |     |         |           |      the name of the program to write
 |     |         |           your input file
 |     |         turn on the useful warnings
 |     pick the language standard
 the program that runs all four stages for you

#include <stdio.h>

int main(void)
{
    int physics = 37;
    int chemistry = 41;
    int total = physics + chemistry;

    printf("Total: %d\n", total);
    printf("Subjects: 2\n");
    return 0;
}

Total: 78
Subjects: 2

#include <stdio.h>

int main(void)
{
    int marks = 90;
    int total = 0;          /* declared, then never used again */

    printf("Marks: %d\n", marks);
    return 0;
}

Marks: 90

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

int main(void)
{
    double side = 5.0;

    /* sqrt is declared in math.h and lives in the maths library. */
    double diagonal = side * sqrt(2.0);

    printf("Diagonal: %.3f\n", diagonal);
    return 0;
}

Diagonal: 7.071

gcc hello.c
./hello

gcc -std=c17 diagonal.c -o diagonal

./hello

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

gcc -std=c17 quiz.c -o quiz
gcc -std=c17 -Wall -Wextra quiz.c -o quiz
gcc -std=c89 -Wall -Wextra -pedantic-errors quiz.c -o quiz

#include <stdio.h>

int main(void)
{
    int marks = 90;
    int bonus = 5;

    printf("Marks: %d\n", marks);
    return 0;
}

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

int main(void)
{
    /* Your one comment goes here, about the linker. */
    printf("2 to the 10 is %.0f\n", pow(2.0, 10.0));
    return 0;
}

That closes Part Zero. Next comes the module's graded problem set, ten problems with hidden tests, and then the module test.