As we move to "modern" programming, the C language and its compilers represent a major leap from assembly. C is a compiled language, meaning source code is transformed into machine code before execution. This allows standalone executables that run without the compiler or development environment. We'll use the count-to-100 and print "Hello Readers" example to illustrate, explaining the compilation process and portability.
A compiler is a tool that translates high-level source code (e.g., C) into low-level machine code or assembly, producing an executable file. Unlike interpreters (e.g., BASIC, which execute line-by-line), compilers perform upfront translation, optimizing for speed and efficiency. The resulting binary runs directly on the CPU. Popular C compilers include GCC (GNU Compiler Collection, free/open-source) and Clang; early ones like the Portable C Compiler (pcc, 1970s) influenced portability.
Here's the program in C that loops a counter to 100 (as a delay) then prints "Hello Readers". It uses standard library functions for output:
#include <stdio.h>
int main() {
int i;
for (i = 0; i < 100; i++) {
// Loop does nothing but count (simple delay)
}
printf("Hello Readers\n");
return 0;
}
Explanation:
Like an assembler (which converts assembly to machine code), a C compiler processes source in stages to produce an executable. Using GCC: gcc example.c -o example
The executable is standalone—copy to another compatible computer (same OS/architecture, e.g., x86 Linux) and run without compiler. No development tools needed, unlike interpreters requiring runtime.
C executables are portable across similar systems: compile once for target platform, move the binary. Source is highly portable (recompile for different OS/CPU). But binaries aren't cross-platform (e.g., Windows .exe won't run on Linux without emulation). Interesting fact: C's "portable assembly" roots made Unix rewriteable across hardware, fueling its spread.