devutilsFrançaisGitHub A place to start
Learn, one step at a time
Choose a path for your starting point. Each step links to a lesson with its prerequisites.
01 · Guided path
Start from zero
Represent information, reason about models and understand signals.
5 steps 02 · Guided pathUnderstand circuits
From logic gates to registers and sequential circuits.
7 steps 03 · Guided pathUnderstand a computer
Instructions, processors, memory and input/output.
6 stepsSee more learning paths (9)
- Chemistry and materials — from atoms to doped silicon
- Digital control and datapaths
- Electronics and PCB — from circuit model to measured board
- Firmware and embedded — from reset to a running system
- Integrated circuit design — from RTL to timing
- From Boolean decisions to switching circuits
- Physics for computing — from charge to solids
- Semiconductor devices — from junctions to CMOS power
- Semiconductor manufacturing — from wafer to package
The knowledge map
Explore by subject
Open a subject to find its lessons. Upcoming areas are clearly marked.
Foundations5 lessons
Mathematical reasoning, units, signals, information, modeling
- Information and representationCount binary possibilities, decode a small unsigned number and separate a bit pattern from its meaning.
- Mathematical reasoningRead variables, evaluate a rule and distinguish an example, a counterexample and a proof.
- Models and abstractionState what a model promises, trace its predictions and identify where its assumptions stop applying.
- Signals and statesSeparate a physical signal from the discrete state it represents, then read a simple time trace.
- Units and scaleKeep units in a calculation, convert powers of ten and distinguish a duration from a rate.
Physics5 lessons
Electricity, electromagnetism, quantum basics, thermodynamics, solid-state physics
- Electricity — charge, voltage and currentDistinguish electrical quantities and calculate current, power and transferred energy in an ideal resistor circuit.
- Electromagnetism — fields and inductionRead the direction of an electric force and calculate a simple induced voltage from a changing magnetic flux.
- Thermodynamics — heat and energyBalance electrical input, heat leaving a system and stored energy without confusing watts, joules and temperature.
- Quantum basics — probabilities and energy levelsDistinguish probability from amplitude and calculate energy differences in a three-level teaching model.
- Solid-state physics — lattices and energy bandsConnect a repeating crystal model to allowed electron energies, then distinguish a band diagram from a conductivity prediction.
Chemistry & materials5 lessons
Atomic bonding, crystal lattices, silicon, doping, material properties
- Atoms and bonding — from charge to shared electronsCount protons, neutrons and electrons, distinguish isotopes from ions, and explain the energy sign of a covalent bond.
- Crystal structures — cells, sharing and defectsCount shared atoms in cubic cells, scale a repeating volume and distinguish vacancies, substitutions and interstitials.
- Material properties — resistivity, geometry and constraintsDerive a sample resistance from resistivity and shape, convert areas correctly, and evaluate several material requirements together.
- Semiconductor doping — donors, acceptors and neutralityExplain n-type and p-type silicon, count dopants and derive a scoped compensation approximation without confusing carriers with net charge.
- Silicon and silicon dioxide — structure and compositionCount shared bonds, derive the SiO2 atom ratio and distinguish substrate silicon from an electrically insulating oxide.
Semiconductor manufacturing6 lessons
Wafers, photolithography, deposition, etching, implantation, metallization, packaging, testing
- Deposition and etching — growth, transfer and selectivityTrack a film through deposition and mask transfer, calculate a cycle-based thickness and budget underlayer and mask loss.
- Implantation and annealing — dose, depth and active dopantsSeparate dose from concentration, follow a uniform-profile counting model and distinguish retained dopants, activation and mobile carriers.
- Interconnects and planarization — lines, vias and resistanceRead electrical connectivity across levels, follow damascene-style fill and CMP, and calculate a line-and-via resistance model.
- Photolithography — resist polarity, patterns and alignmentTrace positive and negative resist, distinguish a resist opening from a material etch, and calculate a simple overlay margin.
- Testing, yield and packaging — count accepted productsSeparate die and package tests, multiply stage fractions with the right denominators and reason about multi-die assembly assumptions.
- Wafers and process flow — from substrate to patterned stackFollow an ingot into wafer form, distinguish wafer, die and package, and read process changes in top view and cross-section.
Semiconductor devices6 lessons
PN junctions, diodes, MOSFETs, CMOS, scaling, leakage
- CMOS — complementary switches and charging energyBuild an inverter and NAND, separate settled states from transitions and account for capacitive switching energy.
- Device scaling — density, energy and performance tradeoffsCalculate geometric density and dynamic-power ratios without equating transistor count with speed or efficiency.
- Diode models — bias, exponential current and circuit assumptionsDistinguish a continuous junction law from a constant-drop approximation and reconcile circuit power.
- Leakage and static power — energy while idleDistinguish leakage paths, compute standby energy and compare clock gating, sleep and task energy.
- MOSFETs — gate control, terminal voltages and operating regionsUse source-relative gate voltages, distinguish threshold from low resistance and solve a scoped switch circuit.
- PN junctions — diffusion, fields and depletionExplain equilibrium, fixed space charge and bias, then balance depletion widths in an abrupt-junction model.
Electronics & PCB7 lessons
Circuit theory, analog and digital electronics, schematics, layout, power, signal integrity, measurement
- Analog and digital interfaces — margins and settlingCompare logic-level guarantees, calculate RC settling and distinguish physical waveforms from logical interpretations.
- Circuit analysis — nodes, loops and loaded dividersApply current and voltage balance, calculate divider loading and reconcile power in a DC network.
- Measurement and debugging — loading, references and evidenceInclude the probe in the circuit, estimate measurement loading and separate resolution, accuracy and repeatability.
- PCB layout — geometry, resistance and return pathsCalculate conductor resistance and clearance, follow return currents and distinguish connectivity checks from performance.
- Power and decoupling — regulation, loss and transient chargeReconcile regulator power, calculate capacitor droop and explain why effective capacitance and connection impedance matter.
- Schematics and connectivity — nets, pins and footprintsTrace an explicit netlist, map electrical pins to physical pads and understand the scope of schematic checks.
- Signal integrity — travel time, reflections and receiver behaviorCompare propagation with edge time, calculate first load reflections and distinguish incident-wave amplitude from source voltage.
Integrated circuit design6 lessons
RTL, HDL, simulation, verification, synthesis, physical design, timing, ASIC vs FPGA
- ASIC and FPGA — target resources and implementation choicesUnderstand LUTs, registers and dedicated resources, compare a scoped cost model and separate configuration from fabrication.
- Physical design — placement, clocks, routing and extractionTurn a netlist into geometry, calculate utilization and wiring effects, and distinguish connectivity, geometry and timing checks.
- RTL and hardware descriptionDescribe a registered four-bit accumulator in Verilog, separate combinational wiring from clocked storage and trace simultaneous state updates.
- Simulation and verification — contracts, checks and coverageBuild an independent oracle, distinguish exhaustive scope from coverage and understand bounded formal and equivalence checks.
- Static timing analysisCalculate setup and hold slack for a clocked path, derive the effect of skew and distinguish timing constraints from functional simulation.
- Synthesis and technology mappingLower a circuit description into connected implementation cells, reason about Boolean equivalence and account for resource sharing without changing cycle behavior.
Digital logic9 lessons
Boolean algebra, combinational and sequential logic, FSMs, arithmetic, registers, memory
- Arithmetic logic unitCombine a four-bit adder, Boolean functions and selection; distinguish unsigned carry from signed overflow and connect computation to storage.
- Binary addersDerive a full adder, follow carries through four bits, and distinguish unsigned carry from signed overflow.
- Boolean algebraDescribe two-state decisions with AND, OR and NOT, then connect the expressions to switching circuits.
- Combinational logicSpecify a function, build it from gates, and verify a selector without confusing logic with timing.
- Finite-state machinesDesign a serial pattern detector, preserve overlapping matches, encode its states and verify every short input stream.
- Logic gatesTurn Boolean operations into connected components, and distinguish a logical result from an electrical implementation.
- Memory and registersSeparate holding a value from computing one, then organize stored bits into registers and addressed words.
- Sequential logicCombine stored state with a next-state function, trace a counter, and account for the time between clock edges.
- Synchronous interfaces — valid, ready and backpressureTrace accepted values, preserve pending data and separate interface throughput, latency, buffering and clock-domain assumptions.
Computer architecture6 lessons
ISA, microarchitecture, pipelines, caches, CPU/GPU, buses, RISC-V, x86-64
- Buses and I/O — transactions, addresses and shared serviceDistinguish MMIO from RAM, calculate burst payload rate and reason about arbitration, ordering and completion.
- Caches and memory hierarchy — locality, tags and missesMap byte addresses into a direct-mapped cache, reproduce a miss trace and calculate access-time and write-policy consequences.
- CPU and GPU parallelism — useful work, bandwidth and overheadCompare data-parallel execution, lane utilization and scoped scaling limits using end-to-end work and traffic.
- Instruction execution — fetch, operands and architectural updatesExecute a complete eight-bit teaching program, trace wraparound and branches and connect state changes to a datapath.
- ISA and microarchitecture — contract, implementation and performanceDistinguish instruction semantics from hardware organization, read RV32I state and compare scoped execution-time models.
- Pipelines and hazards — overlap, dependencies and penaltiesTrace pipeline stages, distinguish latency from throughput and budget stalls without changing architectural behavior.
Firmware & embedded6 lessons
Bare metal, boot, MCUs, interrupts, DMA, drivers, RTOS, embedded Linux
- DMA and buffer ownership — addresses, visibility and reuseFollow device/CPU buffer ownership, calculate fill intervals and preserve FIFO capacity while separating coherence from ordering.
- Embedded Linux — boot chain, drivers, root filesystems and updatesConnect loader, kernel, hardware description and user space, then budget independent storage/RAM models and reason about recovery.
- Interrupts and drivers — response, context and shared stateBudget event-to-handler latency, separate device flags from controller state and preserve driver lifetime across concurrent completion paths.
- Microcontrollers and MMIO — peripherals, bits and pollingConnect bare-metal code to specified registers, distinguish read/write and W1C behavior and separate volatile from synchronization.
- Real-time scheduling — ready tasks, deadlines and interferenceTrace a preemptive schedule, calculate scoped response times and distinguish utilization, blocking and synchronization.
- Reset and boot — runtime state, images and entry conditionsExplain the path to main, budget RAM and vectors and distinguish image loading, authenticity and recovery policy.
Operating systemsPlanned
Kernel, processes, scheduling, memory, filesystems, syscalls, device drivers, virtualization
This area is planned. No lessons have been published yet.
Programming & toolchainsPlanned
Assembly, C/C++/Rust, compilers, linkers, ELF, ABI, algorithms, debugging
This area is planned. No lessons have been published yet.
Applications & systemsPlanned
UI, APIs, networking, databases, concurrency, distributed systems, operations
This area is planned. No lessons have been published yet.
More ways to learn