Explorez les exemples

Architecture client serveur

Connexion WebSocket persistante : on voit le code client et le code du hub, puis un SendAll qui diffuse le message à tous les clients connectés.

Auth et Données derrière Nginx, chacun avec sa base : authentification (JWT) puis requête de données.

Le serveur web renvoie du HTML puis du JavaScript ; la coquille rendue attend les données, que le Web API sert en JSON.

Échange de clés Diffie-Hellman sur un canal public écouté par Ève : elle voit passer les valeurs publiques mais ne peut pas reconstituer la clé partagée.

ClientHello / ServerHello, validation du certificat, dérivation de la clé de session, puis bascule en canal chiffré pour les données applicatives.

Connexion déléguée : redirection vers le serveur d’autorisation, code à usage unique, échange contre un jeton sur le canal arrière, puis appel de l’API.

Une seule machine inonde le serveur de requêtes jusqu’à le saturer ; l’utilisateur légitime est alors privé de service. Comme tout vient d’une IP unique, l’attaque reste blocable.

Un serveur de commande (C&C) ordonne à un botnet d’attaquer : tous les bots inondent la cible simultanément. Le trafic venant de milliers d’IP, on ne peut pas simplement bloquer une adresse.

Un reverse proxy plafonne les requêtes par IP : le flood mono-source est rejeté en 429 dès la bordure, le backend reste sain et l’utilisateur légitime continue d’être servi.

Tout le trafic transite par une bordure de filtrage (type Cloudflare/Anycast) qui absorbe le volumétrique et jette les bots ; seule la requête légitime atteint l’origine, qui ne voit jamais l’attaque.

Le résolveur interroge tour à tour la racine, le TLD puis le serveur autoritaire avant de renvoyer l’adresse IP au navigateur (et de la mettre en cache).

Du git push au déploiement : webhook, tests et build dans le runner, publication de l’image dans le registry, puis mise en production.

Disposition circulaire : un candidat sollicite les votes des suiveurs, obtient la majorité, devient leader puis maintient son autorité par des battements de cœur.

Un producteur publie un événement dans un broker, qui le distribue à plusieurs workers ; chacun traite puis accuse réception.

La même ressource demandée deux fois : premier appel en cache MISS (aller jusqu’à l’origine), second en cache HIT servi immédiatement depuis le bord.

Trois requêtes successives distribuées chacune à un backend différent ; la quatrième reboucle sur le premier.

De kubectl apply au pod Running : l’API Server persiste l’état désiré dans etcd, le scheduler choisit un nœud, le kubelet lance le conteneur.

Intention de paiement, autorisation bancaire avec authentification forte, puis confirmation asynchrone de la boutique par webhook.

Une transaction signée rejoint le mempool, plusieurs mineurs cherchent le nonce, l’un forge le bloc et le propage au réseau.

Du client d’Alice à la boîte de Bob : envoi SMTP, résolution de l’enregistrement MX, relais entre serveurs de messagerie, puis relève IMAP.

Une requête unique éclatée par la gateway vers plusieurs sous-graphes, dont les réponses sont recomposées en un seul objet.

La livraison échoue deux fois (récepteur indisponible) puis réussit ; les temps morts entre tentatives matérialisent le back-off exponentiel.

Disposition circulaire : un orchestrateur central distribue une commande aux services satellites puis agrège leurs confirmations.

Insertion d'une feuille rouge sous un parent rouge dont l'oncle est rouge aussi : le rééquilibrage se fait par pure recoloration (parent et oncle en noir, grand-parent en rouge), sans rotation. Illustre l'action set_color.

Le cas rotation : on insère un nœud rouge sous un parent rouge dont l'oncle est noir. La recoloration ne suffit pas — il faut une rotation puis une recoloration. Combine les actions rotate_subtree et set_color.

Insertion de 10, 20, 30 : l'arbre dégénère en chaîne à droite (facteur d'équilibre −2). Une seule rotation gauche le rééquilibre. Illustre direction:'tree' et l'action rotate_subtree (les nœuds glissent à leur nouvelle profondeur).

Recherche d'une clé dans un arbre binaire de recherche : un jeton descend depuis la racine, compare à chaque nœud et bifurque à gauche ou à droite jusqu'à trouver la valeur. Illustre la descente pas à pas en O(log n).

Insertion d'une clé dans un arbre binaire de recherche : la nouvelle clé arrive orpheline et descend pas à pas en comparant à chaque nœud, jusqu'au slot vide où le nœud est alors créé.

Algorithme de Dijkstra sur un graphe pondéré libre (direction:'graph', nœuds placés en x/y). On règle tour à tour le nœud non visité le plus proche ; chaque étape recolore le nœud et l’arête empruntée, faisant croître l’arbre des plus courts chemins jusqu’à la cible.

A* sur une grille (direction:'graph', nœuds placés en x/y) : Dijkstra guidé par une heuristique h(n) = distance de Manhattan restante. On développe toujours le nœud au plus petit f = g + h, si bien que la recherche file droit vers le but sans explorer les cases de côté.

Algorithme de Kruskal (direction:'graph') : on trie les arêtes par poids et on ajoute la moins chère qui ne crée pas de cycle, jusqu’à relier les six nœuds par cinq arêtes. Les arêtes retenues passent au vert, celles qui formeraient un cycle sont écartées.

Le segment App ↔ BD est emprunté dans les deux sens en même temps : le moteur décale automatiquement les trajets sur des voies parallèles.

Cycle de vie complet d'une notification push : comment l'appareil d'Alice fait connaître son adresse de livraison (le token FCM), puis comment un message envoyé par Bob est acheminé jusqu'à elle, même si son application est fermée.

Une boucle en série pile/interrupteur/résistance/LED sur `direction: circuit` : fils orthogonaux entre bornes nommées, fermeture de l’interrupteur (`toggle`) puis courant animé (`flow`) et LED qui s’allume.

Deux LED en parallèle sur `direction: circuit` : le courant (`flow`) se sépare à la jonction, alimente les deux branches à la fois, puis se recombine.

Explique la différence entre tension (différence de potentiel, aux bornes), courant (ampérage, à travers), résistance et puissance (V·I) sur un circuit série avec ampèremètre et voltmètre.

Les six portes logiques de base (AND, OR, XOR, NAND, NOR, NOT), alimentées par les mêmes entrées, avec la règle de chacune et sa sortie.

Diagramme numérique complet : deux bits A et B additionnés par un XOR (somme) et un AND (retenue), parcourant les quatre combinaisons.

Le demi-additionneur reconstruit uniquement avec des portes NAND (« universelles ») : cinq NAND reproduisent le XOR (somme) et le AND (retenue).

Le demi-soustracteur (A − B) construit uniquement avec des NAND : cinq portes donnent la différence (XOR) et l’emprunt (A′·B), en miroir du demi-additionneur.

L’additionneur complet (A + B + retenue) construit avec neuf portes NAND : deux XOR pour la somme, la retenue réutilisant leurs termes internes. La cellule de tout additionneur.

Le soustracteur complet (A − B − emprunt) construit avec onze portes NAND : un double XOR pour la différence, l’emprunt réutilisant les termes internes du XOR.

Deux portes NAND couplées en croix forment un verrou — un bit de mémoire. Entrées actives à l’état bas : mise à 1, remise à 0, et maintien (la mémoire).

Ce qu’il y a DANS une porte NAND : deux pMOS en parallèle au-dessus, deux nMOS en série en dessous. Les transistors qui conduisent s’allument à chaque combinaison.

Une résistance charge un condensateur : le régime transitoire, la constante de temps τ = R·C, la montée exponentielle de la tension et l’arrêt du courant une fois chargé.