Construire un ordinateur à la PRÉHISTOIRE

Main ideas / lessons

• The video is a humorous “Stone Age” re-creation of building a computer, showing that a modern computer can be understood as a system of:

  • Computation (logic/ALU)
  • Storage (registers, RAM, ROM)
  • Communication and control (control unit, buses/address decoding)
  • Memory persistence (secondary storage)
  • I/O (keyboard/screen)
  • Power and timing (generator + clock)

• It repeatedly emphasizes a core technical concept: logic gates built from simple switching elements (relays) can implement binary computation with 0/1 states and clocked memory.

• It also frames “engineering realism” with practical constraints: in prehistoric conditions you must substitute materials (clay, stone, copper/iron, glass, vinegar, animal fat, plant fibers) and accept slow performance and reliability issues.

Key concepts explained

What a computer is

• A programmable machine that manipulates information using binary (0s and 1s) and logical rules.
• A calculator could be considered a computer.

Binary basics

• A bit is the smallest unit (0 or 1).
• Grouping bits (e.g., octet = 8 bits) allows counting up to 255.
• Counting differs from decimal because you only have two digits.

Logic gates

• Seven gates are referenced: NOT, AND, NAND, OR, NOR, XOR, XNOR.
• These gates typically take two inputs and yield one output.

ALU / arithmetic

• Mathematical operations (add/sub/mul/div) can be constructed from logic gates.
• Example idea: building an adder from XOR/AND-style behavior, extended across multiple bits (carry handling).

Memory

• A processor-like system needs storage because you must remember bit values.
• Uses flip-flops as tiny two-state components to build:
  • Registers (small fast storage)
  • RAM (read/write working memory)
  • ROM (boot instructions; “wired” physically)

Relays as gate building blocks

• A relay is described as an electrically activated switch that opens/closes a circuit via an electromagnet pulling a copper strip to a contact.
• Different relay wiring corresponds to different gates:
  • Series relays ⇒ AND
  • Parallel relays ⇒ OR
  • Additional components (e.g., resistors) can help realize other variants.

Clocking (timing)

• A clock provides synchronization (“tic/tick”) so registers and logic update in a controlled rhythm.

Input / output

• Input: keyboard made from spring switches that close circuits into specific data lines.
• Output: screen made from many small individually switchable bulbs behind tinted glass (“big pixels”).

Methodology / step-by-step construction

1) Define what the “computer” will be in binary terms

• Treat information as bits (0/1).
• Build computation using logic gates:
  • Implement arithmetic by chaining gates (e.g., XOR/AND behavior for addition).
• Plan multi-bit operations:
  • Use repeated blocks and carry propagation for addition.

2) Build the ALU (Arithmetic Logic Unit)

• Target an 8-bit design (32/64 too much for “Stone Age resources”).
• Construct logic gates using relays mounted on supports for wiring.
• Create an 8-bit adder by building:
  • A base adder concept (half-adder mentioned, then expanded with carry logic).
• Repeat the general approach for other operations:
  • Subtraction, multiplication, division.
• Add an operation selection mechanism so the ALU knows which operation to perform.

3) Build registers and core memory building blocks

• Use flip-flops to store 0/1:
  • Flip-flop concept: tiny electronic component that can “pass” or “block”.
• Group flip-flops into:
  • Registers (variable-sized storage spaces for the computing unit).
• For RAM:
  • Arrange flip-flops into an addressed grid using:
    • Address lines
    • Data lines
  • Each memory cell contains a set of flip-flops (video example: each cell is built from multiple flip-flops).
• Use an address decoder / chip select:
  • Input a binary address.
  • Activate only the targeted memory region for read/write.

4) Create ROM (boot instructions)

• ROM is read-only in the design:
  • When powered on, it contains fixed startup/boot logic.
• Implement ROM by physically wiring the correct bit values (hand-constructed “wiring the truth”).

5) Provide power: build electricity generation and regulation

• Build an electricity source (described as a “hydroelectric generator” style plan):
  • Construct structure, waterproof protection, insulation sheaths (plant fibers).
  • Add a switch to cut power.
  • Optionally add rechargeable batteries for excess electricity (requires more time).
• Practicalities:
  • Waterproofing to prevent rust/damage.
  • Coating moving parts with animal fat to reduce friction.
  • Protect wood from water exposure.

6) Extract and process materials (prehistoric analog supply chain)

• Iron (for relays, electromagnets, tools, structure):
  • Identify ore types (examples given).
  • Reduce ore using carbon/charcoal and airflow via bellows.
  • Hammer out spongy iron (“soft iron”), accepting purity limits.
• Copper (wires/contacts/electrodes):
  • Identify copper ores and native copper.
  • Melt in a furnace, pour into ingots.
• Vinegar (for batteries):
  • Ferment fruit/grain into alcohol (as described), then vinegar via bacteria and time.
• Glass (insulation + screens):
  • Mix sand + ash + limestone (and rinse sand).
  • Heat into homogeneous paste; shape into plates.
• Additional resources mentioned:
  • Resin/varnish and glue
  • Plant fibers for ropes/sheaths
  • Pigments for color codes
  • Wood/stone for structural parts
  • Animal fat for lubrication

7) Convert copper ingots into usable wire

• Melt copper again, cast into a bar.
• Forge with a die having progressively smaller holes to stretch into thin wire (~1 mm target).
• Coat wire with resin for insulation.
• Wind coils:
  • Use many turns because more turns ⇒ more generated power (for the generator and overall electricity needs).

8) Build the clock mechanism (synchronization)

• Implement a mechanical “water drop clock”:
  • Perforated container + water.
  • Movable copper cup rises/falls with drops.
  • When contact occurs, it sends a tick signal.
• Purpose:
  • Synchronize memory writes and logic updates with a consistent cadence.

9) Add the control unit

• Function described:
  • Reads binary instructions from ROM/RAM.
  • Decodes them using logic gates.
  • Activates the correct circuits at the right time, synchronized to the clock.
• Implementation is described as relay-based; details are skipped due to complexity.

10) Add input device (keyboard)

• Build a set of spring-mounted switches.
• Connect each switch to the appropriate data lines.
• Pressing a key closes the circuit and signals the corresponding binary line.

11) Add output device (screen)

• Build a matrix/array of light bulbs with fine bamboo filaments.
• Mount bulbs on a wooden structure with black-tinted glass plates (to form readable “pixels”).
• Each bulb is individually controlled via a relay connected to I/O logic.

12) Secondary storage (“hard drive” substitute)

• Since RAM is volatile, build a persistent storage medium:
  • Clay discs like “prehistoric vinyl”:
    • Encode bits as grooves (pits and bumps).
  • Mechanical read:
    • Disc rotated by wheel.
    • Needle/copper contact triggers a relay when passing bumps.
• Performance tradeoff noted:
  • Slow and not very reliable, but stylized.

13) Integrate everything into a complete 8-bit computer

• Combine:
  • Processor/ALU + registers
  • RAM + ROM + address decoding
  • Clock + control unit
  • Input keyboard + output screen
  • Storage (secondary) + I/O pathways
  • Power generation + switching
• End goal asserted:
  • A “fully functional 8-bit computer” (Stone Age theoretically).

Performance / limitations highlighted

• Not suitable for modern-demand games.
• Approximate speed estimate given:
  • “About one addition every 10 minutes” assuming no false contacts and moderate temperature (~25°C).
• Reliability concerns:
  • False contact and environmental factors can break or slow operation.

Speakers / sources featured

• Unnamed narrator / instructor (main voice explaining steps)
• Philibert (character addressed and responding verbally)
• “Grandpa” (briefly referenced/appears in banter)
• “Boss” (interruption/role in banter)
• “GPT chat” (mentioned as a place to ask questions)
• “Tinder” (mentioned in a joke, not a source of technical content)