Library

Discover two fundamental data structures that organise the order in which elements are processed: the stack (LIFO) and the queue (FIFO). You will see their operations, step-by-step diagrams of how they evolve, concrete use cases and a Python implementation.

Learn to find a value in a sorted array in as few steps as possible, by cutting the search space in two each time. An interval diagram helps you visualise each step.

Discover matrices, these arrays of numbers that let you manipulate whole systems at once. Learn to add them, multiply them and use them to transform points.

Learn to compute a probability knowing that an event has already occurred, to build a probability tree and to use it to solve concrete problems such as medical tests.

Master proof by induction, the method that lets you prove a property for all natural numbers from just two steps, thanks to the domino analogy.

How a quantum particle can pass through a barrier that, classically, it does not have the energy to cross. Wave-based origin, exponential dependence on the width of the barrier, and major applications: alpha radioactivity, scanning tunnelling microscope, flash memory. Numerous diagrams.

A quantum property with no classical equivalent: spin, and the rule that follows from it and structures all of matter — the Pauli exclusion principle. From the Stern-Gerlach experiment to the filling of electron shells and the stability of matter. With diagrams.

The true quantum face of the atom, beyond the Bohr orbits: probability clouds instead of trajectories, the four quantum numbers (n, l, m, s), the shape of s, p, d orbitals, and the electron filling that explains the periodic table. With orbital diagrams.

How to make perfectly ordered light: the stimulated emission predicted by Einstein, the population inversion that makes amplification possible, the optical cavity, and the exceptional properties of the laser. A flagship application of quantum physics, with diagrams of the energy levels and the cavity.

From network layers to routing, from DNS to establishing a TCP connection: the technical journey of a simple web request.

States, transitions, and acceptance: how a very simple abstract machine can recognize patterns, and why it is equivalent to regular expressions.

There exists an encryption scheme that is mathematically impossible to break, even with infinite computing power: the one-time pad. This course explores how it works, why Shannon proved that it offers perfect secrecy, and why, despite that, we almost never use it.

A cipher like AES can only process fixed-size blocks: how do you use it on a real message? This course explores splitting, padding, and above all the operating modes — from the dangerous ECB to the safe modes CBC and CTR. You will understand why the choice of mode makes all the difference between solid encryption and an information leak.

How do we protect files, disks, and HTTPS connections today? AES, the world standard for symmetric encryption, taken apart round by round. From the state matrix to Shannon's principles that make it unbreakable.

How do we build a reliable digital digest, and how do we break it? This course dives into the Merkle-Damgård construction and into real-world attacks — the birthday paradox, MD5 and SHA-1 collisions, length extension. An in-depth look at what makes, or breaks, the resistance of a hash function.

A simple hash proves that a message has not been altered by accident, but not that it comes from the right sender. This course shows how a secret key turns a fingerprint into proof of authenticity, and why HMAC has become the standard. It also covers implementation pitfalls: timing attacks and the encryption/MAC ordering.

How can you get the same security as RSA with far smaller keys? This question leads to elliptic curves, a geometric object where you add points together. Along the way you discover the ECDH key exchange, the ECDSA signature and the nonce trap that brought down the PlayStation 3.

How can you split a secret among several people so that no single one of them holds it, yet a large enough group can recover it? Adi Shamir's threshold scheme answers this question with a brilliant idea borrowed from geometry. Along the way we discover polynomials, Lagrange interpolation, and a proven security comparable to the one-time pad.

How can you prove you know a secret without ever revealing it? This course explores zero-knowledge proofs, from the famous Ali Baba cave to challenge-response protocols. You will discover their three fundamental properties and their modern uses, from confidential blockchains to zk-SNARKs.

A serious website never knows your password: it only keeps a hash of it. This course explains why hashing alone is not enough, how attacks (brute force, dictionary, rainbow tables) work, and how salting and slow functions like Argon2 protect modern accounts.

A large enough quantum computer would break RSA, Diffie-Hellman and ECC. How does this threat work, and why is it already relevant today? A look at lattices and the first post-quantum standards published by NIST in 2024.

How do you build a ledger that nobody can quietly tamper with, even without a central authority? This course takes apart the mechanisms of the blockchain: chaining by hashing, Merkle trees and proof of work. You will understand why rewriting the history of a chain of blocks is economically infeasible.

Why are some operations easy to perform but impossible to undo? This course explores one-way and trapdoor functions, the bedrock of all modern cryptography. It connects their security to complexity theory and to the great open question P vs NP.

An algorithm that is perfect on paper can have its key stolen without anyone touching the mathematics. How the time, current, waves, and cache of a computer betray the secret.