From Switches to Compilers: How Simple Logic Became Modern Programming

Humans first realized that combining simple on/off switches could represent complex Boolean logic, which led to the construction of CPUs that only understand binary values 0 and 1.

Early programmers wrote raw binary on punched tape, as shown by the following bit strings:

1101101010011010
1001001100101001
1100100011011110
1011101101010010

Because raw binary is unreadable, a mapping was created from machine instructions to human‑recognizable words, giving rise to assembly language:

sub $8, %rsp
mov $.LC0, %edi
call puts
mov $0, %eax

Assembly introduced recognizable mnemonics (ADD, SUB, MUL, DIV) but remained a low‑level language that requires programmers to manage every data movement explicitly.

To reduce repetitive detail, programmers identified common patterns:

Conditional transfer (if‑else)

Loops (while)

Functions (named blocks of code)

if ***
  blablabla
else ***
  blablabla

while ***
  blablabla

func abc:
  blablabla

These patterns form the basis of higher‑level programming constructs.

Recognizing that nested conditionals and loops create infinite‑looking structures, the article introduces recursion as a concise way to express such nesting. A simple recursive formula f(x) = f(x‑1) + f(x‑2) illustrates how a seemingly endless dependency chain can be captured compactly.

Recursion leads to the concept of a syntax tree: code is parsed into a tree according to its grammar, where leaf nodes correspond to simple statements that can be directly translated to machine instructions. By translating leaves upward, the entire tree can be compiled into executable code.

The compilation process—named a "compiler"—takes the human‑readable source, builds a syntax tree, and traverses it to generate machine code (or intermediate code that is later optimized). This explains how modern languages like C, C++, Java, and Python ultimately run on CPUs.

Finally, the article notes that real programming languages have far more complex grammars and that compilers usually emit intermediate representations before producing final machine code, but the simplified model presented captures the essential ideas of abstraction, recursion, and compilation.