Entraînement Practice

Contexte (quoi, pour qui, quelle équipe, quel délai) → Problème (la difficulté concrète) → Décisions (les choix, leurs alternatives, qui a fait quoi) → Résultat (ce qui a marché, avec des chiffres) → Leçons (ce qu'on referait autrement). Le tout en 90 secondes, puis l'intervieweur creuse. Context (what, for whom, what team, what deadline) → Problem (the concrete difficulty) → Decisions (the choices, their alternatives, who did what) → Result (what worked, with numbers) → Lessons (what you'd redo differently). All in 90 seconds, then the interviewer digs.

2 à 3 projets connus à fond : architecture dessinable au tableau, décisions et alternatives, un ou deux chiffres, ce qui a raté, ce qu'on referait autrement. Trois histoires maîtrisées valent mieux que huit lignes de CV survolées. 2 to 3 projects known inside out: architecture drawable on a whiteboard, decisions and alternatives, one or two numbers, what went wrong, what you'd redo differently. Three mastered stories beat eight skimmed CV lines.

Un chiffre transforme une affirmation en preuve : « le chargement est passé de 4 s à 800 ms » raconte une investigation, là où « une app rapide » ne dit rien. Utilisateurs, latence, volume, temps gagné — un chiffre honnête bat un superlatif. A number turns a claim into evidence: "load time went from 4 s to 800 ms" tells an investigation, where "a fast app" says nothing. Users, latency, volume, time saved — an honest number beats a superlative.

L'assumer, en le contextualisant : « c'est la base qu'on connaissait, nos données étaient relationnelles, c'était le choix sûr en trois semaines » — honnête et défendable. Bonus : nommer ce qu'on comparerait aujourd'hui. Inventer une justification savante a posteriori s'effondre à la deuxième question. Own it, with context: "it's the database we knew, our data was relational, it was the safe choice in three weeks" — honest and defensible. Bonus: name what you'd compare today. Inventing a scholarly after-the-fact justification collapses at the second question.

Jamais « rien ». Un raté précis + sa cause + ce qu'on a changé depuis : « on a perdu une semaine faute d'avoir figé le schéma ; depuis je commence par le modèle ». Le recruteur juge la lucidité et la boucle d'apprentissage, pas l'échec lui-même. Never "nothing". One precise failure + its cause + what you changed since: "we lost a week for not freezing the schema; since then I start with the model". The interviewer judges lucidity and the learning loop, not the failure itself.

L'intervieweur isole votre contribution : « qu'as-tu fait, toi, précisément ? ». S'attribuer le projet entier se détecte en trois questions techniques. Réponse au « je » avec un périmètre net, en créditant les autres : « j'ai pris le serveur de jeu ; le front, c'était Marie et Tom ». The interviewer isolates your contribution: "what did you, precisely, do?". Claiming the whole project gets detected within three technical questions. Answer in the first person with a clear scope, crediting the others: "I took the game server; the front end was Marie and Tom".

Une capture d'écran (ou un GIF de démo), une ou deux phrases sur le quoi et le pourquoi, des instructions de lancement qui marchent (idéalement docker compose up), pas de node_modules commité ni de secrets dans l'historique. C'est le seul document qui parle pour vous en votre absence. A screenshot (or a demo GIF), one or two sentences on the what and the why, launch instructions that work (ideally docker compose up), no committed node_modules and no secrets in the history. It's the only document that speaks for you in your absence.

Tester l'URL déployée le matin même, et préparer un plan B hors ligne : capture vidéo de 30 s ou GIF dans le README. La démo live échoue pour des raisons étrangères à votre travail (wifi, service gratuit endormi) ; enchaîner calmement sur la vidéo fait partie de l'évaluation. Test the deployed URL that same morning, and prepare an offline plan B: a 30 s video capture or a GIF in the README. Live demos fail for reasons unrelated to your work (wifi, sleeping free tier); calmly switching to the video is part of the evaluation.

L'octet est l'unité de stockage (UTF-8 : 1 à 4 octets par code point). Le code point est le numéro Unicode d'un caractère (é = U+00E9). Le graphème est ce que l'utilisateur voit à l'écran — il peut regrouper plusieurs code points (e + accent combinant, emoji famille avec ZWJ). The byte is the storage unit (UTF-8: 1 to 4 bytes per code point). The code point is a character's Unicode number (é = U+00E9). The grapheme is what the user sees on screen — it can group several code points (e + combining accent, family emoji with ZWJs).

Deux raisons : en forme NFD, é est décomposé en deux code points (e + accent combinant U+0301) ; et length compte des unités UTF-16, pas des graphèmes ('👍'.length === 2 à cause de la paire de substitution). Fix : normalize('NFC') et Intl.Segmenter pour compter les graphèmes. Two reasons: in NFD form, é is decomposed into two code points (e + combining accent U+0301); and length counts UTF-16 units, not graphemes ('👍'.length === 2 because of the surrogate pair). Fix: normalize('NFC') and Intl.Segmenter to count graphemes.

NFC = forme précomposée (é en un code point), NFD = forme décomposée (e + accent). Deux chaînes visuellement identiques peuvent différer binairement — la comparaison et la recherche échouent alors. Normaliser en NFC aux frontières du système : formulaires, imports, noms de fichiers (macOS produit du NFD). NFC = precomposed form (é as one code point), NFD = decomposed form (e + accent). Two visually identical strings can differ at the binary level — comparison and search then fail. Normalize to NFC at system boundaries: forms, imports, filenames (macOS produces NFD).

Du texte corrompu du type été au lieu de été : des octets UTF-8 décodés avec le mauvais charset (Latin-1 par exemple). é en UTF-8 = deux octets C3 A9, que Latin-1 relit comme deux caractères é. Fix : UTF-8 déclaré explicitement partout — fichiers, en-têtes HTTP, connexion DB. Corrupted text like été instead of été: UTF-8 bytes decoded with the wrong charset (Latin-1 for instance). é in UTF-8 is two bytes C3 A9, which Latin-1 re-reads as the two characters é. Fix: UTF-8 explicitly declared everywhere — files, HTTP headers, DB connection.

Stocker en UTC au format ISO 8601, convertir dans le fuseau de l'utilisateur uniquement à l'affichage. Exception : un événement futur lié à un lieu (réunion à 9 h à Paris) se stocke en heure locale + identifiant IANA (Europe/Paris), car les règles de fuseau peuvent changer avant l'événement. Store in UTC in ISO 8601 format, convert to the user's timezone only at display time. Exception: a future event tied to a place (9am meeting in Paris) is stored as local time + IANA identifier (Europe/Paris), because timezone rules may change before the event.

Stocker une date-seule (anniversaire, deadline) comme timestamp à minuit dans le fuseau local : affichée depuis un fuseau plus à l'ouest, elle recule d'un jour. Fix : un type date sans heure (DATE en SQL, Temporal.PlainDate en JS), jamais un timestamp. Storing a date-only value (birthday, deadline) as a timestamp at midnight in the local timezone: displayed from a timezone further west, it moves back a day. Fix: a time-less date type (DATE in SQL, Temporal.PlainDate in JS), never a timestamp.

Un quantificateur glouton (.+) avale le maximum puis rétrocède (backtracking) ; lazy (.+?) prend le minimum puis étend. Sur '<b>x</b>', <.+> capture tout, <.+?> capture '<b>'. Troisième option, souvent la meilleure : la classe négée <[^>]+> — même résultat, sans backtracking. A greedy quantifier (.+) swallows the maximum then backs off (backtracking); lazy (.+?) takes the minimum then extends. On '<b>x</b>', <.+> captures everything, <.+?> captures '<b>'. Third option, often the best: the negated class <[^>]+> — same result, no backtracking.

Le Regular expression Denial of Service : une regex à quantificateurs imbriqués comme (a+)+$ part en backtracking exponentiel sur une entrée hostile, et gèle un thread avec une seule requête (pannes Stack Overflow 2016, Cloudflare 2019). Parades : éviter les quantificateurs imbriqués, timeout d'exécution, moteur linéaire (RE2, regex Rust). Regular expression Denial of Service: a regex with nested quantifiers like (a+)+$ goes into exponential backtracking on hostile input, freezing a thread with a single request (Stack Overflow 2016 and Cloudflare 2019 outages). Countermeasures: avoid nested quantifiers, execution timeout, linear engine (RE2, Rust regex).

L'API est sans état : chaque tour renvoie tout l'historique en tokens d'entrée. Au tour n, on re-paye les n−1 tours précédents. Mitigations : tronquer ou résumer l'historique, et cache de prompts sur le préfixe stable. The API is stateless: every turn resends the whole history as input tokens. At turn n, you re-pay the previous n−1 turns. Mitigations: truncate or summarize the history, and prompt-cache the stable prefix.

Le time-to-first-token est le délai avant le premier token de la réponse. Le streaming affiche les tokens au fil de la génération : la durée totale ne change pas, mais l'utilisateur commence à lire au TTFT (quelques centaines de ms) au lieu d'attendre la réponse complète. Time-to-first-token is the delay before the first token of the answer. Streaming displays tokens as they are generated: total duration is unchanged, but the user starts reading at the TTFT (a few hundred ms) instead of waiting for the full answer.

Le fournisseur facture ~10 % du prix normal pour un préfixe de prompt déjà vu (le prefill est réutilisé). Contrainte : le préfixe doit être identique octet pour octet — d'où instructions système et documents stables en tête, contenu variable en fin de prompt. The provider bills ~10% of the normal price for a prompt prefix it has already seen (the prefill is reused). Constraint: the prefix must be byte-identical — hence system instructions and stable documents at the head, variable content at the tail.

La sortie d'un LLM est une entrée non fiable : JSON invalide, champ manquant, format inattendu, même à température 0. La validation par schéma transforme du texte libre en données typées garanties conformes, avec retry puis fallback en cas d'échec. LLM output is untrusted input: invalid JSON, missing fields, unexpected formats, even at temperature 0. Schema validation turns free text into typed data guaranteed to conform, with retry then fallback on failure.

Un jeu de test métier (50-200 cas réels annotés) rejoué à chaque changement de prompt ou de modèle, comme des tests de non-régression. Sans evals, modifier un prompt en prod revient à déployer sans tests — et le choix d'un modèle plus petit ne peut pas se justifier. A business test set (50-200 annotated real cases) replayed on every prompt or model change, like regression tests. Without evals, changing a prompt in production is deploying without tests — and switching to a smaller model can't be justified.

Verbosity bias (préférence pour les réponses longues), position bias (préférence pour la première réponse dans une comparaison), self-preference (préférence pour ses propres sorties). Parade : calibrer le juge contre un échantillon annoté par des humains. Verbosity bias (preference for long answers), position bias (preference for the first answer in a comparison), self-preference (preference for its own outputs). Countermeasure: calibrate the judge against a human-annotated sample.

Elles sont structurelles : le modèle prédit le texte le plus plausible, pas le plus vrai. On réduit leur fréquence et leur impact — RAG pour ancrer sur des sources, citations vérifiables, humain dans la boucle sur les actions critiques — mais aucun réglage ne les élimine. They are structural: the model predicts the most plausible text, not the most true. You reduce their frequency and impact — RAG to ground answers in sources, verifiable citations, human in the loop on critical actions — but no setting eliminates them.

Des instructions hostiles cachées dans le contenu que le LLM traite (document, page web, email). Le modèle ne sépare pas instructions et données dans son contexte — il n'existe pas d'équivalent des requêtes préparées. Défense en profondeur : moindre privilège des outils, validation des sorties, confirmation humaine des actions sensibles. Hostile instructions hidden in content the LLM processes (a document, web page, email). The model doesn't separate instructions from data in its context — there is no equivalent of prepared statements. Defense in depth: least privilege for tools, output validation, human confirmation of sensitive actions.

Le joker en tête de motif empêche l'utilisation d'un index B-tree (qui ordonne par préfixe) : la base scanne toute la table à chaque requête, O(n). Et fonctionnellement : pas de stemming, pas de score de pertinence, pas de tolérance aux fautes. The leading wildcard prevents any B-tree index use (B-trees order by prefix): the database scans the whole table on every query, O(n). And functionally: no stemming, no relevance scoring, no typo tolerance.

La structure qui inverse la relation document→termes en terme→documents : pour chaque terme (après analyse), la liste des documents qui le contiennent (postings, avec positions). Chercher devient une lecture directe suivie d'intersections (AND) ou d'unions (OR) de listes, triées par score. The structure that inverts the document→terms relation into term→documents: for each term (after analysis), the list of documents containing it (postings, with positions). Searching becomes a direct lookup followed by list intersections (AND) or unions (OR), sorted by score.

Il transforme le texte brut en termes : tokenization, lowercase, suppression des stop words, stemming — par langue. La requête passe par le même pipeline, sinon « Chaussure » (requête) ne matcherait jamais « chaussur » (terme stocké dans l'index). It turns raw text into terms: tokenization, lowercasing, stop word removal, stemming — per language. The query goes through the same pipeline, otherwise "Shoe" (query) would never match "shoe" (the stemmed term stored in the index).

TF-IDF : un terme pèse plus s'il est fréquent dans le document (TF) et rare dans le corpus (IDF) — « running » discrimine, « de » non. BM25 ajoute la saturation du TF (les répétitions rapportent de moins en moins) et la normalisation par longueur du document (un match dans un titre court pèse plus). TF-IDF: a term weighs more if it's frequent in the document (TF) and rare in the corpus (IDF) — "running" discriminates, "the" doesn't. BM25 adds TF saturation (repetitions yield less and less) and document-length normalization (a match in a short title weighs more).

`text` est analysé (tokenizé, stemmé) : fait pour la recherche full-text via `match`. `keyword` est stocké brut : fait pour les filtres exacts (`term`), les tris et les agrégations. Trier sur un champ analysé ou faire du full-text sur un keyword sont les deux erreurs classiques. `text` is analyzed (tokenized, stemmed): made for full-text search via `match`. `keyword` is stored raw: made for exact filters (`term`), sorting and aggregations. Sorting on an analyzed field or full-text searching a keyword are the two classic mistakes.

`must` participe au score BM25 (pertinence) ; `filter` est binaire : il élimine sans noter, il est plus rapide et son résultat est mis en cache. Pattern type : le texte cherché en must (match), la catégorie et la fourchette de prix en filter (term, range). `must` contributes to the BM25 score (relevance); `filter` is binary: it eliminates without scoring, runs faster and its result is cached. Typical pattern: the searched text in must (match), category and price range in filter (term, range).

Double écriture applicative (simple, mais gérer l'échec d'indexation après le commit : retry, file de messages) ou CDC — Debezium lit le WAL de la base et rejoue les changements vers l'index. Dans tous les cas : cohérence à terme, et une réindexation complète pour rattraper les dérives. Application-level double write (simple, but handle indexing failure after the commit: retry, message queue) or CDC — Debezium reads the database's WAL and replays changes to the index. Either way: eventual consistency, plus a full reindex to catch up on drift.

`tsvector` (document analysé : tokenisation, stemming par dictionnaire de langue) + `tsquery` (requête), l'opérateur `@@` pour matcher, un index GIN pour la vitesse et `ts_rank` pour trier par pertinence. Dans la même base que les données : transactionnel et zéro synchro — souvent suffisant. `tsvector` (analyzed document: tokenization, stemming via language dictionaries) + `tsquery` (the query), the `@@` operator to match, a GIN index for speed and `ts_rank` to sort by relevance. In the same database as the data: transactional and zero sync — often enough.

Une fonction dont la sortie ne dépend que de ses arguments (même entrée → même sortie) et qui ne produit aucun effet de bord : pas d'I/O, pas de mutation externe, pas de Date.now() ni Math.random() cachés. Conséquences : testable sans mock, mémoïsable, parallélisable. A function whose output depends only on its arguments (same input → same output) and that produces no side effect: no I/O, no external mutation, no hidden Date.now() or Math.random(). Consequences: testable without mocks, memoizable, parallelizable.

L'héritage couple fortement la classe fille à l'implémentation de la mère : un changement se propage silencieusement et les hiérarchies profondes finissent par mentir. La composition assemble des capacités (un objet POSSÈDE plutôt qu'il n'HÉRITE) : couplage faible, testable pièce par pièce, recombinable. Inheritance tightly couples the child class to the parent's implementation: a change propagates silently and deep hierarchies end up lying. Composition assembles capabilities (an object HAS rather than IS-A): loose coupling, testable piece by piece, recombinable.

Quand deux morceaux de code peuvent modifier la même structure, chacun casse les hypothèses de l'autre : bugs d'action à distance, difficiles à reproduire, aggravés en concurrence (race conditions). L'OOP le contrôle (encapsulation), la FP le supprime (immutabilité). When two pieces of code can modify the same structure, each breaks the other's assumptions: action-at-a-distance bugs, hard to reproduce, worse under concurrency (race conditions). OOP controls it (encapsulation), FP removes it (immutability).

map transforme chaque élément (n éléments → n éléments), filter garde ceux qui passent un prédicat (n → ≤n), reduce replie la liste en une seule valeur via un accumulateur et une valeur initiale. Ensemble : un pipeline déclaratif qui remplace la boucle à accumulateur. map transforms each element (n elements → n elements), filter keeps those passing a predicate (n → ≤n), reduce folds the list into a single value via an accumulator and a seed. Together: a declarative pipeline replacing the accumulator loop.

Un cœur de logique métier écrit en fonctions pures (calculs, validation, décisions), entouré d'une coquille fine impérative qui gère les effets de bord (DB, HTTP, fichiers, horloge). On teste le cœur sans mock et la coquille en tests d'intégration. A core of business logic written as pure functions (computation, validation, decisions), surrounded by a thin imperative shell handling side effects (DB, HTTP, files, clock). You test the core without mocks and the shell with integration tests.

Elle rend les états invalides impossibles : l'état privé ne se modifie que par des méthodes qui garantissent les invariants (ex. un BankAccount dont le solde ne change que via deposit/withdraw qui vérifient les règles). Une classe anémique (getters/setters sans logique) n'encapsule rien. It makes invalid states impossible: private state only changes through methods that guarantee invariants (e.g. a BankAccount whose balance only changes via deposit/withdraw enforcing the rules). An anemic class (getters/setters with no logic) encapsulates nothing.

Une fonction qui prend une fonction en argument ou en retourne une. Exemples courants : les middlewares Express (reçoivent next), les hooks React (useEffect prend un callback), les décorateurs, debounce/throttle, ou un comparateur passé à sort(). A function that takes a function as argument or returns one. Common examples: Express middlewares (receive next), React hooks (useEffect takes a callback), decorators, debounce/throttle, or a comparator passed to sort().

Un type somme, ex. `{ ok: true; data: User } | { ok: false; error: string }` : le champ discriminant force le switch à traiter chaque cas et le compilateur signale les cas oubliés. C'est un concept venu des langages fonctionnels (types sommes + pattern matching) adopté par le typage moderne. A sum type, e.g. `{ ok: true; data: User } | { ok: false; error: string }`: the discriminant field forces the switch to handle every case and the compiler flags forgotten ones. It's a concept from functional languages (sum types + pattern matching) adopted by modern type systems.

Git n'oublie rien : l'ancien blob reste dans l'historique, les reflogs, les forks et les clones existants (`git log -p` le retrouve). Le secret est considéré comme compromis dès le push : la seule réponse correcte est de le révoquer et d'en générer un nouveau. Git never forgets: the old blob stays in the history, reflogs, forks and existing clones (`git log -p` finds it). The secret is considered compromised as soon as it's pushed: the only correct response is to revoke it and generate a new one.

Elles sont visibles dans `/proc/<pid>/environ` et via `ps e` pour les processus du même utilisateur, héritées par tous les processus enfants (y compris les scripts tiers), et finissent facilement dans les logs d'erreur et crash reports. Bon transport, mauvais stockage. They're visible in `/proc/<pid>/environ` and via `ps e` for same-user processes, inherited by every child process (including third-party scripts), and easily end up in error logs and crash reports. Good transport, bad storage.

Il documente les NOMS des variables attendues avec des valeurs bidon : c'est le contrat de configuration. Versionné, il permet à un nouveau dev de faire `cp .env.example .env` et de remplir — sans lui, quelqu'un finira par commiter le vrai .env. It documents the NAMES of the expected variables with dummy values: it's the configuration contract. Versioned, it lets a new dev run `cp .env.example .env` and fill it in — without it, someone eventually commits the real .env.

1) Révoquer/rotater le secret immédiatement (stoppe l'hémorragie), 2) vérifier les logs d'accès pour évaluer l'exploitation, 3) nettoyer l'historique git (git filter-repo) et forcer le push, 4) ajouter un garde-fou (gitleaks en pre-commit). Nettoyer sans révoquer ne sert à rien. 1) Revoke/rotate the secret immediately (stops the bleeding), 2) check access logs to assess exploitation, 3) clean the git history (git filter-repo) and force-push, 4) add a guardrail (gitleaks in pre-commit). Cleaning without revoking is pointless.

Chaque token ou clé n'a que les droits strictement nécessaires à sa fonction : la clé du service de mails ne peut pas toucher au stockage. En cas de fuite, les dégâts sont proportionnels aux droits accordés — un scope minimal limite l'incident. Each token or key gets only the rights strictly needed for its job: the email service's key can't touch storage. If it leaks, the damage is proportional to the rights granted — a minimal scope contains the incident.

Un scanner de secrets qui détecte les patterns connus (clés AWS, tokens GitHub) et les chaînes à forte entropie. On le branche en hook pre-commit — le seul moment où bloquer est encore gratuit, avant que le secret n'entre dans l'historique — et en CI comme filet. A secret scanner that detects known patterns (AWS keys, GitHub tokens) and high-entropy strings. You wire it as a pre-commit hook — the only moment when blocking is still free, before the secret enters the history — and in CI as a safety net.

Via le store de secrets chiffrés du repo/org, référencés par `${{ secrets.MY_KEY }}`, injectés en variables d'environnement au run et masqués dans les logs (***). Jamais en clair dans le YAML. Le masquage est un filet : un base64 le contourne. Through the repo/org encrypted secrets store, referenced with `${{ secrets.MY_KEY }}`, injected as environment variables at run time and masked in the logs (***). Never in plain text in the YAML. Masking is a net: base64 bypasses it.

Ces variables sont intégrées au bundle JavaScript envoyé au navigateur : tout ce qui part côté client est public par définition. Un appel nécessitant une vraie clé secrète doit passer par le backend, qui garde la clé côté serveur. These variables are baked into the JavaScript bundle sent to the browser: anything shipped client-side is public by definition. A call requiring a real secret key must go through the backend, which keeps the key server-side.

LCP (Largest Contentful Paint, < 2,5 s) : le temps d'affichage du plus gros élément visible — le chargement perçu. INP (Interaction to Next Paint, < 200 ms) : la réactivité aux interactions. CLS (Cumulative Layout Shift, < 0,1) : la stabilité visuelle (les éléments qui se décalent). Elles comptent aussi pour le SEO. LCP (Largest Contentful Paint, < 2.5 s): render time of the largest visible element — perceived loading. INP (Interaction to Next Paint, < 200 ms): responsiveness to interactions. CLS (Cumulative Layout Shift, < 0.1): visual stability (elements shifting around). They also count for SEO.

no-cache autorise le stockage mais impose une revalidation à chaque utilisation (requête conditionnelle ETag → 304 si inchangé). no-store interdit tout stockage — pour les données sensibles. Le piège d'entretien classique : no-cache ne veut PAS dire « ne pas cacher ». no-cache allows storage but forces revalidation on every use (conditional ETag request → 304 if unchanged). no-store forbids any storage — for sensitive data. The classic interview trap: no-cache does NOT mean "don't cache".

Le serveur envoie un ETag (empreinte du contenu) avec la ressource. Quand elle est périmée ou en no-cache, le navigateur renvoie If-None-Match: <etag>. Si le contenu n'a pas changé, le serveur répond 304 Not Modified sans corps : le navigateur garde sa copie. On paie un aller-retour, pas le transfert. The server sends an ETag (a fingerprint of the content) with the resource. When it's stale or under no-cache, the browser sends If-None-Match: <etag>. If the content hasn't changed, the server answers 304 Not Modified with no body: the browser keeps its copy. You pay a round trip, not the transfer.

HTML en no-cache (+ ETag) : revalidé à chaque visite, jamais périmé. Assets buildés avec un hash du contenu dans le nom (app.9f3ab2.js) en public, max-age=31536000, immutable : cachés un an sans revalidation. Un déploiement change le hash → nouvelle URL référencée par le HTML frais. On n'invalide jamais : on change d'URL. HTML on no-cache (+ ETag): revalidated on every visit, never stale. Built assets with a content hash in the name (app.9f3ab2.js) on public, max-age=31536000, immutable: cached one year with no revalidation. A deploy changes the hash → new URL referenced by the fresh HTML. You never invalidate: you change the URL.

Formats modernes (WebP/AVIF : 30-50 % plus légers que JPEG), loading="lazy" natif sous la ligne de flottaison (jamais sur l'image LCP), srcset/sizes pour servir la bonne résolution par écran, et width/height ou aspect-ratio systématiques pour réserver l'espace et éviter le CLS. Modern formats (WebP/AVIF: 30-50% lighter than JPEG), native loading="lazy" below the fold (never on the LCP image), srcset/sizes to serve the right resolution per screen, and systematic width/height or aspect-ratio to reserve space and avoid CLS.

Code splitting : découper le bundle (par route, imports dynamiques) pour ne charger que le nécessaire. Tree shaking : éliminer au build le code jamais importé. defer : télécharger le script en parallèle mais l'exécuter après le parsing du HTML, sans bloquer le rendu. Les trois réduisent le coût du JS — téléchargement ET exécution sur le main thread. Code splitting: cutting the bundle (per route, dynamic imports) to load only what's needed. Tree shaking: removing never-imported code at build time. defer: downloading the script in parallel but executing it after HTML parsing, without blocking rendering. All three reduce JS cost — download AND main-thread execution.

font-display: swap pour afficher le texte immédiatement en police système (petit swap visuel plutôt que texte invisible), <link rel="preload"> pour charger tôt la font critique, self-host pour éviter DNS + connexion vers un domaine tiers, et limiter les variantes (chaque graisse est un fichier à télécharger). font-display: swap to show text immediately in a system font (a small visual swap rather than invisible text), <link rel="preload"> to load the critical font early, self-hosting to avoid DNS + a third-party connection, and limiting variants (every weight is a file to download).

Le CDN place des serveurs edge près des utilisateurs : ils cachent les réponses de l'origin et coupent la latence géographique (plus absorption des pics et protection de l'origin). s-maxage est le max-age spécifique aux caches partagés : il permet un cache CDN différent du cache navigateur (ex. s-maxage=600 au CDN, no-cache au navigateur). A CDN places edge servers near users: they cache origin responses and cut geographic latency (plus spike absorption and origin shielding). s-maxage is the max-age specific to shared caches: it allows a CDN cache different from the browser cache (e.g. s-maxage=600 at the CDN, no-cache in the browser).

Parce qu'un appel peut ne jamais répondre : sans timeout, le thread ou la connexion de pool qui attend est bloqué indéfiniment. Sous charge, ces attentes s'accumulent et épuisent les ressources du service appelant — la panne de la dépendance devient la vôtre. Un appel sans timeout est une fuite de ressources en puissance. Because a call may never answer: without a timeout, the waiting thread or pool connection is blocked indefinitely. Under load, these waits pile up and exhaust the caller's resources — the dependency's outage becomes yours. A call without a timeout is a resource leak waiting to happen.

Dans une chaîne A → B → C, les timeouts doivent décroître : si A accorde 2 s à B, B doit accorder moins (ex. 1,5 s) à C, sinon B répond après que A a abandonné — travail gaspillé et erreurs incohérentes. On découpe le SLO de bout en bout en budgets par étage, chacun avec une marge. In a chain A → B → C, timeouts must decrease: if A gives B 2 s, B must give C less (e.g. 1.5 s), otherwise B answers after A has given up — wasted work and inconsistent errors. The end-to-end SLO is split into per-tier budgets, each with a margin.

Sans jitter, tous les clients tombés au même moment réessaient exactement aux mêmes instants (1 s, 2 s, 4 s…) : des vagues synchronisées frappent le service pendant qu'il tente de se relever. Le jitter (délai aléatoire, ex. full jitter : uniforme entre 0 et le plafond) étale les tentatives et casse la synchronisation. Without jitter, all clients that failed at the same moment retry at exactly the same instants (1 s, 2 s, 4 s…): synchronized waves hit the service while it tries to recover. Jitter (random delay, e.g. full jitter: uniform between 0 and the cap) spreads attempts out and breaks the synchronization.

Parce qu'un échec apparent peut être un succès dont la réponse s'est perdue : rejouer un POST /payments dans ce cas crée un paiement en double. Solution : les idempotency keys — le client joint un identifiant unique, le serveur détecte le rejeu et renvoie la réponse originale au lieu de ré-exécuter. Because an apparent failure may be a success whose response got lost: replaying a POST /payments in that case creates a double charge. Solution: idempotency keys — the client attaches a unique identifier, the server detects the replay and returns the original response instead of re-executing.

Closed : les appels passent, les échecs sont comptés. Open (déclenché quand les échecs dépassent un seuil) : échec immédiat sans appeler le service, pendant un délai de repos. Half-open (après ce délai) : quelques appels de sonde passent ; s'ils réussissent → closed, s'ils échouent → open. But : laisser récupérer le service aval et échouer vite côté appelant. Closed: calls pass, failures are counted. Open (triggered when failures exceed a threshold): instant failure without calling the service, for a cool-down period. Half-open (after that delay): a few probe calls pass; if they succeed → closed, if they fail → open. Goal: let the downstream service recover and fail fast on the caller side.

Cloisonner les ressources par dépendance, comme les compartiments étanches d'un navire : pools de connexions/threads séparés, quotas. Si une dépendance devient lente, elle sature son propre pool (ex. 10 connexions) sans épuiser les ressources globales du service — la panne reste contenue. Partitioning resources per dependency, like a ship's watertight compartments: separate connection/thread pools, quotas. If a dependency turns slow, it saturates its own pool (e.g. 10 connections) without exhausting the service's global resources — the failure stays contained.

Liveness : « le process tourne-t-il ? » — en cas d'échec, on le redémarre. Readiness : « peut-il servir du trafic ? » — en cas d'échec, on le retire du load balancer sans le tuer. Les confondre provoque des redémarrages en boucle quand une dépendance est juste lente ; et un readiness check qui teste les dépendances peut sortir toutes les instances du LB d'un coup. Liveness: "is the process running?" — on failure, restart it. Readiness: "can it serve traffic?" — on failure, pull it from the load balancer without killing it. Confusing them causes restart loops when a dependency is merely slow; and a readiness check that tests dependencies can pull every instance from the LB at once.

Une masse de clients (ou d'entrées de cache expirant ensemble) frappe l'origine au même instant — au redémarrage d'un service ou à l'expiration d'un cache populaire. Parades : jitter sur les TTL et les reconnexions, request coalescing (une seule requête régénère le cache, les autres attendent le résultat), warm-up progressif du trafic. A mass of clients (or cache entries expiring together) hits the origin at the same instant — on a service restart or a popular cache expiry. Countermeasures: jitter on TTLs and reconnections, request coalescing (a single request regenerates the cache, the others wait for the result), progressive traffic warm-up.

La stack stocke les frames d'appel et les variables locales, allouées/libérées automatiquement par déplacement d'un pointeur (rapide, une stack par thread, durée de vie liée à la fonction). Le heap stocke les objets à durée de vie arbitraire, partagé entre threads, géré par un allocateur et un GC (ou manuellement en C). The stack holds call frames and local variables, allocated/freed automatically by moving a pointer (fast, one stack per thread, lifetime tied to the function). The heap holds objects with arbitrary lifetimes, shared between threads, managed by an allocator and a GC (or manually in C).

Savoir quand libérer un objet du heap : un objet ne peut être libéré que quand plus personne ne peut y accéder. Le GC détecte automatiquement les objets inaccessibles depuis les racines (stack, globals) et récupère leur mémoire, éliminant use-after-free, double free et libérations oubliées. Knowing when to free a heap object: an object can only be freed when nobody can reach it anymore. The GC automatically detects objects unreachable from the roots (stack, globals) and reclaims their memory, eliminating use-after-free, double free and forgotten releases.

À cause des cycles : deux objets qui se référencent mutuellement gardent chacun un compteur ≥ 1, même devenus inaccessibles — ils ne sont jamais libérés. Il faut un mécanisme complémentaire : détecteur de cycles (CPython) ou weak references (Swift/ARC). Because of cycles: two objects referencing each other each keep a counter ≥ 1, even once unreachable — they are never freed. A complementary mechanism is needed: a cycle detector (CPython) or weak references (Swift/ARC).

Phase mark : depuis les racines (stack, globals, registres), on suit récursivement toutes les références et on marque chaque objet atteint. Phase sweep : tout objet non marqué est libéré. Les cycles inaccessibles sont collectés naturellement puisque personne ne les marque. Souvent complété par une compaction pour défragmenter. Mark phase: from the roots (stack, globals, registers), recursively follow all references and mark every reached object. Sweep phase: every unmarked object is freed. Unreachable cycles are collected naturally since nobody marks them. Often complemented by compaction to defragment.

L'observation empirique que la plupart des objets meurent jeunes (temporaires, objets d'une requête). Les GC séparent donc le heap : une young generation collectée souvent et vite (minor GC — seuls les rares survivants sont copiés), et une old generation collectée rarement (major/full GC, plus coûteux). C'est le design de V8 et de la JVM. The empirical observation that most objects die young (temporaries, per-request objects). GCs therefore split the heap: a young generation collected often and fast (minor GC — only the few survivors are copied), and an old generation collected rarely (major/full GC, more expensive). That's the design of V8 and the JVM.

1) Listeners jamais retirés (l'emitter garde une référence vers le callback et tout son scope capturé). 2) Caches sans borne (Map qui grossit indéfiniment — penser WeakMap ou éviction LRU). 3) Closures qui capturent de gros objets. 4) Variables globales qui accumulent. Dans tous les cas : l'objet reste accessible, donc incollectable. 1) Listeners never removed (the emitter keeps a reference to the callback and its whole captured scope). 2) Unbounded caches (a Map growing forever — think WeakMap or LRU eviction). 3) Closures capturing large objects. 4) Global variables that accumulate. In every case: the object stays reachable, hence uncollectable.

Symptôme : mémoire en marches d'escalier qui ne redescend pas après GC. Méthode : heap snapshots (DevTools → Memory) avant/après le scénario suspect, comparer, trier par retained size, puis remonter la chaîne des retainers jusqu'à la référence coupable (souvent un listener ou un cache). Sur Node : --inspect + Chrome DevTools. Symptom: staircase-shaped memory that never comes down after GC. Method: heap snapshots (DevTools → Memory) before/after the suspect scenario, compare, sort by retained size, then walk the retainers chain up to the guilty reference (often a listener or a cache). On Node: --inspect + Chrome DevTools.

Par l'ownership : chaque valeur a un propriétaire unique et sa libération est insérée à la compilation quand le propriétaire sort du scope. Le borrow checker vérifie statiquement qu'aucune référence ne survit à la valeur qu'elle pointe. Résultat : ni GC ni pauses, sécurité mémoire prouvée à la compilation. Through ownership: every value has a single owner and its release is inserted at compile time when the owner goes out of scope. The borrow checker statically verifies that no reference outlives the value it points to. Result: no GC, no pauses, memory safety proven at compile time.

Un mécanisme où l'on décrit des outils au modèle (nom, description, JSON schema) ; le modèle peut alors répondre par un appel structuré (nom + paramètres JSON) au lieu de prose. Le code applicatif valide, exécute la vraie fonction et renvoie le résultat au modèle — le modèle n'exécute jamais rien lui-même. A mechanism where tools are described to the model (name, description, JSON schema); the model can then reply with a structured call (name + JSON parameters) instead of prose. The application code validates, executes the real function and returns the result to the model — the model never executes anything itself.

Objectif → le LLM raisonne et choisit un outil → le code exécute l'appel → le résultat (observation) est réinjecté dans le contexte → le modèle raisonne à nouveau, jusqu'à la réponse finale ou une limite (itérations, budget). Tout l'historique est renvoyé à chaque tour. Goal → the LLM reasons and picks a tool → the code executes the call → the result (observation) is fed back into the context → the model reasons again, until a final answer or a limit (iterations, budget). The whole history is resent every turn.

C'est la description que le modèle lit pour décider quand et comment utiliser l'outil. Une bonne description précise quand l'utiliser, quand ne pas l'utiliser, ce que l'outil retourne et ses limites. La plupart des mauvais choix d'outil viennent d'une description floue, pas du modèle. The description is what the model reads to decide when and how to use the tool. A good one states when to use it, when not to, what it returns and its limits. Most wrong tool choices come from a fuzzy description, not from the model.

Un rôle clair (« tu es un agent support de X »), des contraintes explicites (format, longueur, interdits), des exemples few-shot (2-3 paires entrée/sortie), et une sortie structurée (JSON conforme à un schéma) exploitable par un programme. Pas d'« astuces magiques » : elles ne survivent pas au changement de modèle. A clear role ("you are a support agent for X"), explicit constraints (format, length, prohibitions), few-shot examples (2-3 input/output pairs), and structured output (JSON conforming to a schema) usable by a program. No "magic tricks": they don't survive a model change.

L'intégration N outils × M applications : sans standard, chaque app re-code chaque connexion. MCP (Model Context Protocol) standardise l'exposition d'outils et de ressources via un protocole client/serveur : un serveur MCP écrit une fois est utilisable par tout client compatible. The N tools × M applications integration problem: without a standard, every app re-codes every connection. MCP (Model Context Protocol) standardizes exposing tools and resources through a client/server protocol: an MCP server written once is usable by any compatible client.

1) La boucle infinie : l'agent réessaie sans fin un appel qui échoue. 2) L'hallucination d'outil : appel d'un outil inexistant ou paramètres inventés. 3) L'explosion des coûts : l'historique complet repart à chaque tour, donc un agent qui boucle consomme le contexte à répétition. 1) The infinite loop: the agent endlessly retries a failing call. 2) Tool hallucination: calling a nonexistent tool or inventing parameters. 3) Cost explosion: the full history is resent every turn, so a looping agent consumes the context repeatedly.

Du contenu externe lu par l'agent (page web, email, ticket) qui contient des instructions détournant le modèle (« ignore tes consignes et… »). Grave car l'agent a des outils : l'injection peut déclencher des actions réelles (exfiltration, suppression). Pas de correctif définitif — mitigations : moindre privilège, validation humaine, séparer données et instructions. External content read by the agent (web page, email, ticket) containing instructions that hijack the model ("ignore your instructions and…"). Serious because the agent has tools: the injection can trigger real actions (exfiltration, deletion). No definitive fix — mitigations: least privilege, human approval, separating data from instructions.

Limite dure d'itérations et budget de tokens, timeouts sur les outils, validation stricte des paramètres contre le schéma, permissions graduées par outil (lecture libre, écriture sur validation), humain dans la boucle pour les actions irréversibles, et logs de chaque appel d'outil pour l'observabilité. A hard iteration limit and token budget, timeouts on tools, strict parameter validation against the schema, graduated per-tool permissions (free reads, writes behind approval), a human in the loop for irreversible actions, and logs of every tool call for observability.

Un triplet (id, classes/attributs/pseudo-classes, éléments/pseudo-éléments) comparé de gauche à droite : (1,0,0) bat (0,15,3) — un id bat n'importe quel nombre de classes. À égalité exacte, la dernière règle déclarée gagne. L'inline surclasse tout, `!important` court-circuite le mécanisme. A triplet (id, classes/attributes/pseudo-classes, elements/pseudo-elements) compared left to right: (1,0,0) beats (0,15,3) — one id beats any number of classes. On an exact tie, the last declared rule wins. Inline style tops everything, `!important` short-circuits the mechanism.

On l'utilise quand on a perdu le contrôle de sa spécificité : il masque le conflit au lieu de le résoudre et déclenche la surenchère (le prochain conflit exigera un autre `!important`). Le vrai fix : comprendre quelle règle gagne et baisser la spécificité (des classes, pas d'id). You use it when you've lost control of your specificity: it hides the conflict instead of resolving it and triggers an arms race (the next conflict will require another `!important`). The real fix: understand which rule wins and lower specificity (classes, no ids).

Une dimension → flexbox (navbar, ligne de boutons : les items se répartissent le long d'un axe, pilotés par le contenu). Deux dimensions → grid (layout de page, galerie : lignes et colonnes définies par le conteneur). Ils se combinent : grid pour la structure, flexbox dans les composants. One dimension → flexbox (navbar, row of buttons: items distribute along an axis, driven by content). Two dimensions → grid (page layout, gallery: rows and columns defined by the container). They combine: grid for structure, flexbox inside components.

`rem` est relative à la taille racine, donc au réglage de l'utilisateur : quelqu'un qui a agrandi sa police système voit le texte grandir. `px` fige la taille et ignore ce réglage. C'est un enjeu d'accessibilité, pas seulement de style. `rem` is relative to the root size, hence to the user's setting: someone who enlarged their system font sees the text grow. `px` freezes the size and ignores that setting. It's an accessibility issue, not just a style one.

Gratuitement : focus clavier (atteignable au Tab), rôle annoncé aux lecteurs d'écran, activation Entrée/Espace, état `:disabled`, comportement dans les formulaires. Le div exige tabindex, role et handler keydown — une réimplémentation toujours incomplète. For free: keyboard focus (reachable via Tab), a role announced to screen readers, Enter/Space activation, the `:disabled` state, form behavior. The div requires tabindex, role and a keydown handler — an always-incomplete reimplementation.

Quand le HTML natif ne suffit pas : états dynamiques (`aria-expanded` pour un menu, `aria-live` pour du contenu mis à jour). Première règle du W3C : ne pas utiliser ARIA quand un élément natif existe. Et un mauvais ARIA est pire que pas d'ARIA : il promet des comportements que le JS n'assure pas. When native HTML isn't enough: dynamic states (`aria-expanded` for a menu, `aria-live` for updated content). The W3C's first rule: don't use ARIA when a native element exists. And bad ARIA is worse than no ARIA: it promises behaviors the JS doesn't deliver.

À afficher un contour de focus net pendant la navigation clavier sans l'afficher au clic souris. Ça résout proprement le conflit « l'outline est moche » : on garde le site utilisable au clavier sans polluer l'expérience souris. Supprimer l'outline sans remplacement rend le site inutilisable au clavier. Showing a clear focus outline during keyboard navigation without showing it on mouse clicks. It cleanly solves the 'the outline is ugly' conflict: the site stays keyboard-usable without polluting the mouse experience. Removing the outline with no replacement makes the site keyboard-unusable.

Une taille fluide bornée : la valeur préférée (2.5vw) suit la largeur du viewport, sans jamais descendre sous 1rem ni dépasser 1.5rem. C'est la typo responsive sans media query. Cousines modernes : `dvh` corrige le bug du 100vh sur mobile, les custom properties sont des variables vivantes dans la cascade. A bounded fluid size: the preferred value (2.5vw) follows the viewport width, never going below 1rem nor above 1.5rem. It's responsive typography without a media query. Modern cousins: `dvh` fixes the 100vh bug on mobile, custom properties are live variables in the cascade.

Vertical (scale up) : une machine plus grosse — zéro changement de code, mais plafond matériel et le SPOF reste. Horizontal (scale out) : plus de machines identiques derrière un load balancer — quasi illimité et tolérant aux pannes, mais exige une app stateless. Vertical (scale up): a bigger machine — zero code changes, but a hardware ceiling and the SPOF remains. Horizontal (scale out): more identical machines behind a load balancer — nearly unlimited and fault-tolerant, but requires a stateless app.

Le LB route chaque requête vers n'importe quelle instance : un état en mémoire locale (session, cache, fichier) devient invisible pour les autres. On externalise : sessions dans Redis ou JWT, fichiers en object storage, vérité en base. Test : tuer une instance à tout instant sans impact utilisateur. The LB routes each request to any instance: state in local memory (session, cache, file) becomes invisible to the others. Externalize it: sessions in Redis or JWT, files in object storage, truth in the database. Test: kill any instance at any moment with zero user impact.

TLS termination (HTTPS s'arrête au proxy, certificats gérés en un seul endroit), compression gzip/brotli, cache du statique, routing par domaine ou chemin, et en-têtes comme X-Forwarded-For pour conserver l'IP réelle du client. TLS termination (HTTPS stops at the proxy, certificates managed in one place), gzip/brotli compression, static caching, routing by domain or path, and headers like X-Forwarded-For to preserve the client's real IP.

Round-robin distribue équitablement en nombre de requêtes : bien quand elles se valent. Least-connections envoie vers l'instance ayant le moins de connexions actives : meilleur quand les durées varient (une grosse requête ne bloque pas la file). Health checks obligatoires dans les deux cas. Round-robin distributes evenly by request count: fine when requests are similar. Least-connections sends to the instance with the fewest active connections: better when durations vary (one big request doesn't block the queue). Health checks are mandatory either way.

Le LB sonde régulièrement chaque instance (ex. endpoint /health) et sort du pool celles qui ne répondent plus, puis les réintègre quand elles guérissent. C'est le mécanisme qui transforme « une instance est morte » en « personne ne l'a remarqué ». The LB regularly probes each instance (e.g. a /health endpoint) and removes from the pool those that stop responding, then reinstates them when they recover. It's the mechanism that turns 'an instance died' into 'nobody noticed'.

Le LB colle un client à une instance fixe (cookie) pour que son état en mémoire reste accessible. À éviter : répartition de charge dégradée, et la mort d'une instance déconnecte tous ses clients d'un coup. La vraie solution : rendre l'app stateless. The LB pins a client to a fixed instance (cookie) so its in-memory state stays reachable. Avoid them: degraded load distribution, and one instance dying disconnects all its clients at once. The real fix: make the app stateless.

Single point of failure : un composant unique dont la panne emporte tout. On les traque étage par étage : N instances d'app, DB primary + replica avec failover, deux LB avec IP flottante (keepalived). La haute dispo se vérifie maillon par maillon. Single point of failure: a unique component whose failure takes everything down. Hunt them tier by tier: N app instances, primary + replica DB with failover, two LBs with a floating IP (keepalived). High availability is verified link by link.

Le délai entre une écriture sur le primary et sa propagation aux replicas. Une lecture sur replica juste après une écriture peut renvoyer l'ancien état. Pour les lectures critiques (« read your own writes »), on lit sur le primary. The delay between a write on the primary and its propagation to the replicas. A read on a replica right after a write can return the old state. For critical reads ('read your own writes'), read from the primary.

Pas de tout comprendre : construire une carte progressive — les 5-6 modules principaux, leurs frontières, qui parle à qui. Le détail se charge à la demande, quand un ticket vous y emmène. Même les seniors fonctionnent avec une carte grossière + des techniques de recherche. Not to understand everything: build a progressive map — the 5-6 main modules, their boundaries, who talks to whom. Details load on demand, when a ticket takes you there. Even seniors work with a rough map + search techniques.

Cloner, suivre le README à la lettre, faire tourner l'app en local et lancer les tests — en notant chaque étape manquante ou fausse (variable d'env non documentée, version implicite…). Ces notes deviennent une PR de doc. Rien d'autre le jour 1. Clone, follow the README to the letter, get the app running locally and run the tests — writing down every missing or wrong step (undocumented env var, implicit version…). Those notes become a docs PR. Nothing else on day 1.

Ils décrivent le comportement attendu avec des exemples exécutables, cas nominaux et cas limites inclus, et ils sont à jour par construction : s'ils mentaient, la CI serait rouge. Un README ou un wiki, lui, peut dériver sans que personne ne s'en aperçoive. They describe expected behavior with executable examples, nominal and edge cases included, and they're current by construction: if they lied, CI would be red. A README or wiki can drift without anyone noticing.

`git shortlog -sn -- chemin/` liste les auteurs par nombre de commits sur ce chemin ; `git blame` sur une ligne précise remonte au commit et à son auteur. On pose ensuite la question à la bonne personne, avec le contexte du commit. `git shortlog -sn -- path/` lists authors by commit count on that path; `git blame` on a specific line leads to the commit and its author. Then you ask the right person, armed with the commit's context.

Timeboxer la recherche (30-45 min), puis demander en montrant le chemin parcouru : ce qu'on a grep, les fichiers regardés, l'hypothèse actuelle. Cette forme prouve l'effort, cadre la réponse et transforme la question en signal positif plutôt qu'en aveu. Timebox the search (30-45 min), then ask while showing the path covered: what you grepped, the files checked, your current hypothesis. This form proves effort, frames the answer and turns the question into a positive signal instead of a confession.

Petite, sûre, utile : typo, étape de setup manquante dans le README, test sur un cas limite non couvert. Elle sert à traverser tout le pipeline (branche, conventions, review, CI, merge) sur un changement à risque nul — pas à briller. Small, safe, useful: a typo, a missing setup step in the README, a test on an uncovered edge case. Its purpose is to cross the whole pipeline (branch, conventions, review, CI, merge) on a zero-risk change — not to shine.

Un seul aller-retour (route → controller → service → repository → DB) révèle l'architecture réelle : les couches, les conventions de nommage, où vit la logique métier. C'est la compréhension maximale par minute investie, contrairement à la lecture linéaire. A single round trip (route → controller → service → repository → DB) reveals the real architecture: the layers, naming conventions, where business logic lives. It's the maximum understanding per minute invested, unlike linear reading.

Ne jamais supprimer ou refactorer un code « bizarre » avant d'avoir compris pourquoi il existe : contrainte métier, bug historique, dépendance externe. `git log` et `git blame` donnent souvent la raison. Proposer un grand refactoring en semaine 1 est le signal junior type. Never delete or refactor 'weird' code before understanding why it exists: business constraint, historical bug, external dependency. `git log` and `git blame` often reveal the reason. Proposing a big refactoring in week 1 is the classic junior signal.

Le mapping objet-relationnel (une ligne ↔ un objet, une clé étrangère ↔ une propriété), des requêtes typées vérifiées par le compilateur/l'IDE, et un système de migrations qui versionne le schéma comme du code. Object-relational mapping (a row ↔ an object, a foreign key ↔ a property), typed queries checked by the compiler/IDE, and a migration system that versions the schema like code.

Une requête pour charger une liste, puis une requête par élément dans la boucle qui suit. Exemple : 100 auteurs et leurs articles = 1 + 100 = 101 requêtes, soit ~500 ms à 5 ms de round-trip, contre 2 requêtes (~10 ms) avec un eager loading. One query to load a list, then one query per element in the following loop. Example: 100 authors and their posts = 1 + 100 = 101 queries, i.e. ~500 ms at 5 ms per round-trip, versus 2 queries (~10 ms) with eager loading.

Lazy charge la relation au moment de l'accès (risque : N+1 dès qu'on itère) ; eager la charge dès la requête initiale via JOIN ou WHERE IN (risque : sur-charger des données inutiles). Règle pratique : eager explicite partout où on boucle. Lazy loads the relation on access (risk: N+1 as soon as you iterate); eager loads it with the initial query via JOIN or WHERE IN (risk: over-fetching useless data). Rule of thumb: explicit eager wherever you loop.

Compter les requêtes : activer le log SQL en dev (log: ['query'] chez Prisma, echo=True chez SQLAlchemy) et regarder ce qu'un écran déclenche. Si le nombre de requêtes croît avec le nombre d'éléments affichés, c'est un N+1. En prod : APM. Count the queries: enable SQL logging in dev (log: ['query'] in Prisma, echo=True in SQLAlchemy) and watch what one screen triggers. If the query count grows with the number of displayed items, it's an N+1. In production: APM.

Elle a déjà tourné sur d'autres bases (collègues, CI, prod) : l'éditer fait diverger l'historique, les outils le détectent (checksum chez Prisma) et refusent d'avancer. Une erreur se corrige en avant, par une nouvelle migration. It has already run on other databases (colleagues, CI, production): editing it makes the history diverge, tools detect it (Prisma checksums) and refuse to proceed. Mistakes are fixed forward, with a new migration.

Expand : ajouter le nouveau (colonne nullable, double écriture) sans toucher à l'ancien. Migrate : backfill des données existantes et bascule du code vers le nouveau. Contract : supprimer l'ancien quand plus personne ne le lit. Un déploiement par phase — jamais de rename direct. Expand: add the new (nullable column, dual writes) without touching the old. Migrate: backfill existing data and switch the code to the new. Contract: remove the old once nobody reads it. One deployment per phase — never a direct rename.

Rapports et agrégations complexes, window functions, bulk updates, et les hot paths où le SQL généré est inefficace. Tous les ORM ont une trappe de sortie ($queryRaw, text(), native queries) prévue pour ça — l'ORM garde le CRUD répétitif. Complex reports and aggregations, window functions, bulk updates, and hot paths where the generated SQL is inefficient. Every ORM has an escape hatch ($queryRaw, text(), native queries) designed for this — the ORM keeps the repetitive CRUD.

Ce sont les données initiales scriptées et versionnées (comptes de test, référentiels). Le dev veut des données réalistes pour travailler, le CI un jeu minimal et déterministe pour des tests reproductibles, la prod presque rien — jamais les comptes de test. They are the scripted, versioned initial data (test accounts, reference tables). Dev wants realistic data to work with, CI a minimal deterministic set for reproducible tests, production almost nothing — never the test accounts.

Une fonction qui capture les variables de son scope lexical de définition et les garde vivantes après la fin de la fonction englobante. « Lexical » = déterminé par la position du code, pas par l'appel. La closure référence les variables elles-mêmes, pas une copie de leurs valeurs. A function that captures the variables of its lexical definition scope and keeps them alive after the enclosing function returns. "Lexical" = determined by the code's position, not by the call. The closure references the variables themselves, not a copy of their values.

var n'a pas de scope de bloc : les trois callbacks capturent la même variable i. Ils s'exécutent après la fin de la boucle, quand i vaut 3. Avec let, chaque itération crée une nouvelle liaison → 0, 1, 2. La closure capture la variable, pas sa valeur au moment de la création. var has no block scope: all three callbacks capture the same variable i. They run after the loop ends, when i equals 3. With let, each iteration creates a new binding → 0, 1, 2. A closure captures the variable, not its value at creation time.

1) État privé : un compteur dont la variable est invisible de l'extérieur (pattern module). 2) Callbacks qui se souviennent de leur contexte (handlers, debounce/throttle, memoization). 3) Les hooks React, entièrement construits sur les closures (d'où le bug de la « stale closure » dans useEffect). 1) Private state: a counter whose variable is invisible from outside (module pattern). 2) Callbacks that remember their context (handlers, debounce/throttle, memoization). 3) React hooks, built entirely on closures (hence the "stale closure" bug in useEffect).

Le moteur cherche la propriété sur l'objet lui-même ; s'il ne la trouve pas, il remonte le lien [[Prototype]] d'objet en objet jusqu'à Object.prototype puis null. C'est la chaîne de prototypes : l'héritage JS est une délégation, pas une copie. The engine looks for the property on the object itself; if not found, it follows the [[Prototype]] link from object to object up to Object.prototype and then null. That's the prototype chain: JS inheritance is delegation, not copying.

Du sucre syntaxique sur les prototypes : les méthodes sont posées sur Class.prototype (partagées par toutes les instances, pas copiées), extends câble Class.prototype.[[Prototype]] vers le parent. typeof Class renvoie « function ». Le modèle objet reste prototypal. Syntactic sugar over prototypes: methods are placed on Class.prototype (shared by all instances, not copied), extends wires Class.prototype.[[Prototype]] to the parent. typeof Class returns "function". The object model remains prototypal.

1) new f() → l'objet fraîchement créé. 2) f.call/apply/bind(ctx) → le ctx explicite. 3) obj.f() → l'objet avant le point. 4) f() appel simple → undefined en strict mode (globalThis sinon). À évaluer au site d'appel, jamais au lieu de définition. 1) new f() → the freshly created object. 2) f.call/apply/bind(ctx) → the explicit ctx. 3) obj.f() → the object before the dot. 4) plain f() → undefined in strict mode (globalThis otherwise). Evaluated at the call site, never at the definition site.

Elles n'ont pas de this propre : elles utilisent celui du scope lexical englobant, figé à l'écriture. Parfaites pour les callbacks dans une classe (setTimeout(() => this.tick())), mauvaises comme méthodes d'objet. Elles n'ont pas non plus d'arguments et ne sont pas constructibles. They have no this of their own: they use the enclosing lexical scope's this, fixed at write time. Perfect for callbacks inside a class (setTimeout(() => this.tick())), bad as object methods. They also lack arguments and are not constructible.

var est hissée ET initialisée à undefined : lisible avant sa ligne, sans erreur (bugs silencieux). let/const sont hissées mais non initialisées : y accéder avant la déclaration jette une ReferenceError — c'est la temporal dead zone, qui transforme un bug silencieux en erreur franche. var is hoisted AND initialized to undefined: readable before its line, without error (silent bugs). let/const are hoisted but uninitialized: accessing them before the declaration throws a ReferenceError — the temporal dead zone, which turns a silent bug into a loud error.

1) Clarifier les besoins (fonctionnels + non fonctionnels : volumétrie, latence, disponibilité). 2) Estimer les ordres de grandeur (req/s, stockage). 3) Dessiner le schéma simple qui répond au besoin. 4) Itérer sur les goulots d'étranglement. Et annoncer ce plan à voix haute dès le début. 1) Clarify the requirements (functional + non-functional: volume, latency, availability). 2) Estimate orders of magnitude (req/s, storage). 3) Draw the simple diagram that meets the need. 4) Iterate on the bottlenecks. And announce this plan out loud from the start.

POST /shorten : reçoit l'URL longue, la valide, renvoie 201 avec le code court. GET /:code : renvoie une redirection 301 ou 302 vers l'URL longue, ou 404 si le code n'existe pas. POST /shorten: receives the long URL, validates it, returns 201 with the short code. GET /:code: returns a 301 or 302 redirect to the long URL, or 404 if the code doesn't exist.

Compteur + base62 : simple, zéro collision, codes courts, mais prévisibles (énumérables) — corrigible par permutation secrète. Hash tronqué : pas de compteur central, même URL → même code, mais collisions dues à la troncature (paradoxe des anniversaires) → vérifier en base et retry. Counter + base62: simple, zero collisions, short codes, but predictable (enumerable) — fixable with a secret permutation. Truncated hash: no central counter, same URL → same code, but collisions from truncation (birthday paradox) → check the DB and retry.

Le 301 est mis en cache par le navigateur : les clics suivants vont directement à la cible sans repasser par le service → analytics perdues. Le 302 n'est pas mis en cache : chaque clic traverse le service et peut être compté. Si le tracking est un besoin (cas bit.ly), c'est 302. A 301 is cached by the browser: subsequent clicks go straight to the target without passing through the service → analytics lost. A 302 isn't cached: every click traverses the service and can be counted. If tracking is a requirement (bit.ly's case), it's 302.

Une table clé-valeur : code (clé primaire) → url, created_at. Aucune jointure ni transaction complexe, donc n'importe quel store convient. À ~50 Go/an et 300 lectures/s, un Postgres bien indexé suffit largement ; le NoSQL ne se justifie qu'à une échelle bien supérieure. A key-value table: code (primary key) → url, created_at. No joins or complex transactions, so any store fits. At ~50 GB/year and 300 reads/s, a well-indexed Postgres is plenty; NoSQL is only justified at a much larger scale.

En cache-aside : on lit Redis, sur miss on lit la base et on remplit le cache avec un TTL. Ça marche très bien car la popularité suit une loi de Zipf (peu d'URLs concentrent le trafic) et les URLs sont immuables — quasiment aucun problème d'invalidation. Cache-aside: read Redis, on miss read the DB and fill the cache with a TTL. It works very well because popularity follows a Zipf distribution (few URLs concentrate the traffic) and URLs are immutable — almost no invalidation problem.

Sans lui, un spammeur crée des millions de liens : phishing relayé par votre domaine, pollution de l'espace de codes, coûts de stockage. Solution : token bucket par IP ou clé API, réponse 429, plus validation stricte des URLs (schémas http/https uniquement). Without it, a spammer creates millions of links: phishing relayed through your domain, code-space pollution, storage costs. Solution: token bucket per IP or API key, 429 response, plus strict URL validation (http/https schemes only).

Le raisonnement, pas les buzzwords : clarifier avant de dessiner, poser des ordres de grandeur, justifier chaque brique par un chiffre (« un cache parce que la lecture domine »), connaître les limites de son design, et savoir commencer simple. Reasoning, not buzzwords: clarifying before drawing, putting down orders of magnitude, justifying every box with a number ("a cache because reads dominate"), knowing the design's limits, and knowing how to start simple.

Les individus et leurs interactions plus que les processus et outils ; un logiciel qui fonctionne plus qu'une doc exhaustive ; la collaboration avec le client plus que la négociation contractuelle ; l'adaptation au changement plus que le suivi d'un plan. Nuance clé : les seconds éléments ont de la valeur, on privilégie juste les premiers. Individuals and interactions over processes and tools; working software over comprehensive documentation; customer collaboration over contract negotiation; responding to change over following a plan. Key nuance: the items on the right have value, the left is just valued more.

Le Product Owner porte la vision produit et priorise le backlog (le quoi). Le Scrum Master facilite, lève les obstacles et protège l'équipe — ce n'est pas un chef de projet. L'équipe de développement s'auto-organise et décide du comment. The Product Owner carries the product vision and prioritizes the backlog (the what). The Scrum Master facilitates, removes obstacles and protects the team — not a project manager. The development team self-organizes and decides the how.

15 minutes debout, chaque jour : ce que j'ai avancé, ce sur quoi je pars, ce qui me bloque. Objectif : synchroniser l'équipe et surfacer les blocages tôt — pas rapporter au manager. Les discussions de fond se prennent à deux, après. 15 minutes standing, every day: what I moved forward, what I'm on, what blocks me. Goal: sync the team and surface blockers early — not reporting to the manager. Deep discussions happen in pairs, afterwards.

La review regarde le produit : démo du logiciel qui marche aux parties prenantes, feedback. La rétro regarde le process : l'équipe, entre elle, identifie ce qui a frotté et décide d'une ou deux actions concrètes pour le sprint suivant. The review looks at the product: demo of working software to stakeholders, feedback. The retro looks at the process: the team, among itself, identifies friction and decides on one or two concrete actions for the next sprint.

Les story points estiment la complexité relative d'une story (Fibonacci : 1, 2, 3, 5, 8…), pas des heures. La vélocité = points livrés par sprint, outil de prévision interne. Dérive : en faire une métrique de performance ou comparer les équipes → les estimations gonflent (loi de Goodhart). Story points estimate a story's relative complexity (Fibonacci: 1, 2, 3, 5, 8…), not hours. Velocity = points delivered per sprint, an internal forecasting tool. The abuse: turning it into a performance metric or comparing teams → estimates inflate (Goodhart's law).

Une checklist commune qui rend « fini » objectif : par exemple code écrit + testé + relu + mergé + déployé en staging. Sans elle, chacun a sa définition de « fini » et le sprint « terminé » explose en recette. A shared checklist that makes "finished" objective: e.g. code written + tested + reviewed + merged + deployed to staging. Without it, everyone has their own definition of "done" and the "finished" sprint blows up in acceptance testing.

Quand le flux entrant est imprévisible (support, ops, maintenance) : pas de sprint figé, flux continu avec limite de WIP, mesuré au lead time / cycle time. Scrum convient mieux au développement produit planifiable avec un backlog priorisable. When the incoming flow is unpredictable (support, ops, maintenance): no frozen sprint, continuous flow with a WIP limit, measured by lead time / cycle time. Scrum fits plannable product development with a prioritizable backlog better.

Trois réflexes : découper une tâche floue en sous-tâches d'une journée testables ; signaler un blocage tôt (au daily ou avant, jamais la veille de la démo) ; demander de l'aide au bon moment — 30 à 60 minutes de recherche sérieuse, puis solliciter en montrant ce qu'on a déjà essayé. Three reflexes: splitting a fuzzy task into one-day testable subtasks; flagging a blocker early (at the daily or before, never the eve of the demo); asking for help at the right time — 30 to 60 minutes of serious digging, then asking while showing what you already tried.

Symétrique (AES) : une seule clé partagée, très rapide (Go/s), mais problème de l'échange de la clé. Asymétrique (RSA, courbes elliptiques) : une paire publique/privée, résout l'échange de clé, mais ~1000 fois plus lent et limité à de petits messages. Symmetric (AES): a single shared key, very fast (GB/s), but the key-exchange problem. Asymmetric (RSA, elliptic curves): a public/private pair, solves key exchange, but ~1000× slower and limited to small messages.

L'asymétrique (ECDHE + certificat) sert uniquement à établir un secret commun et à authentifier le serveur ; le trafic est ensuite chiffré en symétrique (AES-GCM), mille fois plus rapide. C'est le chiffrement hybride : la sécurité de l'un, la vitesse de l'autre. Asymmetric crypto (ECDHE + certificate) is only used to establish a shared secret and authenticate the server; traffic is then encrypted symmetrically (AES-GCM), a thousand times faster. That's hybrid encryption: one's security, the other's speed.

1) ClientHello : versions, ciphers, part Diffie-Hellman éphémère. 2) ServerHello : sa part DH, son certificat, une signature de sa clé privée. 3) Chacun dérive la même clé de session sans qu'elle circule. 4) Trafic chiffré en symétrique (AES-GCM). Un seul aller-retour. 1) ClientHello: versions, ciphers, ephemeral Diffie-Hellman share. 2) ServerHello: its DH share, its certificate, a signature from its private key. 3) Both derive the same session key without it ever traveling. 4) Traffic encrypted symmetrically (AES-GCM). One single round trip.

Il authentifie le serveur (il ne chiffre rien) : il lie une clé publique à un domaine, avec des dates de validité, le tout signé par une CA. Le client remonte la chaîne de confiance (feuille → CA intermédiaire → CA racine préinstallée) pour le valider. It authenticates the server (it encrypts nothing): it binds a public key to a domain, with validity dates, all signed by a CA. The client walks the chain of trust (leaf → intermediate CA → preinstalled root CA) to validate it.

Chiffrer = clé publique du destinataire, pour la confidentialité : lui seul déchiffre. Signer = clé privée de l'émetteur sur le hash du message, pour l'authenticité et l'intégrité : tout le monde vérifie avec la clé publique. Une signature ne cache rien. Encrypt = the recipient's public key, for confidentiality: only they decrypt. Sign = the sender's private key over the message hash, for authenticity and integrity: anyone verifies with the public key. A signature hides nothing.

La garantie qu'une compromission future de la clé privée du serveur ne permet pas de déchiffrer le trafic passé. Obtenue avec des clés Diffie-Hellman éphémères (ECDHE) : chaque session a son propre secret, jeté ensuite. Obligatoire en TLS 1.3. The guarantee that a future compromise of the server's private key cannot decrypt past traffic. Achieved with ephemeral Diffie-Hellman keys (ECDHE): each session has its own secret, discarded afterwards. Mandatory in TLS 1.3.

Un hash (SHA-256) est irréversible et sans clé : on ne peut pas retrouver l'entrée, seulement tester des candidats. Le chiffrement est réversible pour qui a la clé. Usages du hash : intégrité, signatures, mots de passe (avec bcrypt/argon2, lents et salés). A hash (SHA-256) is irreversible and keyless: you can't recover the input, only test candidates. Encryption is reversible for whoever holds the key. Hash uses: integrity, signatures, passwords (with bcrypt/argon2, slow and salted).

TLS 1.3 : handshake en un seul aller-retour, forward secrecy obligatoire, suppression des algos cassés (RC4, SHA-1, échange RSA). Let's Encrypt : certificats gratuits et automatisés via le protocole ACME (renouvelés tous les 90 jours) — le HTTPS partout est devenu la norme. TLS 1.3: one-round-trip handshake, mandatory forward secrecy, removal of broken algorithms (RC4, SHA-1, RSA key exchange). Let's Encrypt: free, automated certificates via the ACME protocol (renewed every 90 days) — HTTPS everywhere became the norm.

Tableau : mémoire contiguë, accès par index O(1), cache-friendly, mais insertion/suppression au milieu en O(n). Liste chaînée : insertion/suppression O(1) si on tient déjà le nœud, mais accès et recherche O(n). En pratique le tableau dynamique gagne presque toujours grâce au cache CPU. Array: contiguous memory, O(1) index access, cache-friendly, but O(n) insertion/deletion in the middle. Linked list: O(1) insertion/deletion if you already hold the node, but O(n) access and search. In practice the dynamic array wins almost every time thanks to the CPU cache.

Pile (stack) = LIFO, push/pop au sommet : call stack, undo, DFS, parsing. File (queue) = FIFO, on entre d'un côté et sort de l'autre : files de tâches, buffers, BFS. Les deux offrent leurs opérations en O(1) — et échanger l'une pour l'autre transforme BFS en DFS. Stack = LIFO, push/pop at the top: call stack, undo, DFS, parsing. Queue = FIFO, in on one side, out on the other: task queues, buffers, BFS. Both offer O(1) operations — and swapping one for the other turns BFS into DFS.

Pour chaque nœud, tout le sous-arbre gauche est plus petit et tout le sous-arbre droit plus grand — l'invariant porte sur les sous-arbres entiers, pas seulement les enfants directs. Conséquence : le parcours in-ordre (gauche, nœud, droite) visite les valeurs dans l'ordre trié. For every node, the entire left subtree is smaller and the entire right subtree larger — the invariant covers whole subtrees, not just direct children. Consequence: the in-order traversal (left, node, right) visits the values in sorted order.

Un BST naïf dégénère en liste chaînée O(n) si on insère des valeurs déjà triées. Les arbres auto-équilibrés (AVL, rouge-noir) se rééquilibrent par rotations à chaque insertion/suppression pour garantir une hauteur en O(log n), donc recherche, insertion et suppression en O(log n) dans le pire cas. A naive BST degenerates into an O(n) linked list if you insert already-sorted values. Self-balancing trees (AVL, red-black) rebalance through rotations on each insertion/deletion to guarantee O(log n) height, hence O(log n) worst-case search, insertion and deletion.

Un arbre binaire complet où chaque parent est ≤ ses enfants (min-heap) : le minimum est à la racine en O(1), insertion et extraction en O(log n). C'est l'implémentation standard de la priority queue : Dijkstra, ordonnanceurs, top-k, fusion de k listes triées. A complete binary tree where each parent is ≤ its children (min-heap): the minimum sits at the root in O(1), insertion and extraction in O(log n). It's the standard implementation of the priority queue: Dijkstra, schedulers, top-k, merging k sorted lists.

BFS utilise une file (FIFO) et explore par niveaux : la première visite d'un sommet emprunte un chemin minimal en arêtes → plus court chemin non pondéré. DFS utilise une pile (souvent la call stack, en récursif) et plonge en profondeur : cycles, tri topologique, backtracking. BFS uses a queue (FIFO) and explores by levels: the first visit of a vertex uses a path with minimum edges → unweighted shortest path. DFS uses a stack (often the call stack, recursively) and dives deep: cycles, topological sort, backtracking.

Liste ({sommet: [voisins]}) : O(V+E) en mémoire, itération efficace sur les voisins — idéale pour les graphes creux, c'est-à-dire presque tous les cas réels. Matrice V×V : test d'arête en O(1) mais O(V²) en mémoire — pour les graphes denses ou très petits. List ({vertex: [neighbors]}): O(V+E) memory, efficient neighbor iteration — ideal for sparse graphs, i.e. almost every real-world case. V×V matrix: O(1) edge test but O(V²) memory — for dense or very small graphs.

Quand les arêtes ont des poids positifs, Dijkstra généralise BFS en remplaçant la file par une priority queue qui extrait toujours le sommet à distance minimale — plus court chemin pondéré (GPS, routage). Limite : avec des poids négatifs, ses résultats sont faux ; il faut Bellman-Ford. When edges have positive weights, Dijkstra generalizes BFS by replacing the queue with a priority queue that always extracts the minimum-distance vertex — weighted shortest path (GPS, routing). Limit: with negative weights its results are wrong; you need Bellman-Ford.

SIGTERM (15) est une demande d'arrêt propre : le processus peut l'intercepter pour fermer ses connexions, flusher ses buffers, puis sortir. SIGKILL (9) est ininterceptable : le noyau supprime le processus sans aucun cleanup. `docker stop` envoie SIGTERM, attend 10 s, puis SIGKILL — d'où l'importance de gérer SIGTERM dans une app conteneurisée. SIGTERM (15) is a clean-shutdown request: the process can catch it to close connections, flush buffers, then exit. SIGKILL (9) is uncatchable: the kernel removes the process with zero cleanup. `docker stop` sends SIGTERM, waits 10 s, then SIGKILL — hence the importance of handling SIGTERM in a containerized app.

Disques, sockets, état du noyau : tout s'expose via l'interface fichier (lire, écrire, rediriger). /proc est un filesystem virtuel : /proc/<pid>/ décrit chaque processus en cours, `cat /proc/cpuinfo` lit les CPU, /proc/meminfo la mémoire — aucune de ces « données » n'existe sur le disque. Disks, sockets, kernel state: everything is exposed through the file interface (read, write, redirect). /proc is a virtual filesystem: /proc/<pid>/ describes each running process, `cat /proc/cpuinfo` reads the CPUs, /proc/meminfo the memory — none of this "data" exists on disk.

Par fork() : le parent se clone (même code, mémoire copiée), puis le clone appelle généralement exec() pour remplacer son image par le nouveau programme. Le shell fait fork + exec pour chaque commande tapée, puis wait() pour récupérer le code de sortie de l'enfant. Through fork(): the parent clones itself (same code, copied memory), then the clone usually calls exec() to replace its image with the new program. The shell does fork + exec for every typed command, then wait() to collect the child's exit code.

Octal : r=4, w=2, x=1, un chiffre par triplet (propriétaire, groupe, autres). 755 = rwxr-xr-x : le propriétaire fait tout, les autres lisent et exécutent — typique d'un script ou d'un répertoire. 600 = rw------- : seul le propriétaire lit et écrit — obligatoire pour une clé SSH privée. Octal: r=4, w=2, x=1, one digit per triplet (owner, group, others). 755 = rwxr-xr-x: the owner does everything, others read and execute — typical for a script or directory. 600 = rw-------: only the owner reads and writes — mandatory for a private SSH key.

stdin (0), stdout (1), stderr (2). `> f` redirige stdout vers le fichier f, puis `2>&1` branche stderr sur la destination actuelle de stdout : les deux flux finissent dans f. L'ordre compte : `2>&1 > f` enverrait stderr au terminal. stdin (0), stdout (1), stderr (2). `> f` redirects stdout to file f, then `2>&1` plugs stderr into stdout's current destination: both streams end up in f. Order matters: `2>&1 > f` would send stderr to the terminal.

Chaque programme fait une seule chose bien, le texte est l'interface universelle, et on compose les programmes entre eux. Le pipe `|` l'incarne : il branche la sortie d'un programme sur l'entrée du suivant sans fichier intermédiaire — ex. `grep … | sort | uniq -c | sort -rn` pour analyser des logs. Each program does one thing well, text is the universal interface, and programs compose with each other. The pipe `|` embodies it: it plugs one program's output into the next one's input without an intermediate file — e.g. `grep … | sort | uniq -c | sort -rn` to analyze logs.

Le PATH est la liste ordonnée des répertoires où le shell cherche un exécutable quand on tape une commande sans chemin — premier trouvé, premier servi. Le répertoire courant n'y figure pas (sécurité) : il faut donc `./script.sh` pour lancer un script local. `which cmd` montre quel binaire sera exécuté. PATH is the ordered list of directories where the shell looks for an executable when you type a command without a path — first found, first served. The current directory isn't in it (security): hence `./script.sh` to run a local script. `which cmd` shows which binary will run.

Une paire clé publique/privée : la publique va dans ~/.ssh/authorized_keys du serveur, la privée ne quitte jamais votre machine. Rien à deviner par force brute, pas de secret transmis au serveur, révocation simple (retirer la clé publique), et automatisation possible (CI, déploiements) sans stocker de mot de passe. A public/private key pair: the public key goes into the server's ~/.ssh/authorized_keys, the private one never leaves your machine. Nothing to brute-force, no secret sent to the server, easy revocation (remove the public key), and automation possible (CI, deployments) without storing a password.

Le processus a son propre espace mémoire, isolé par l'OS ; le thread est un fil d'exécution à l'intérieur d'un processus, qui partage le heap (variables globales, objets) avec les autres threads mais garde sa propre pile. Threads : communication gratuite mais synchronisation obligatoire. Processus : isolation forte, communication explicite (IPC). A process has its own memory space, isolated by the OS; a thread is an execution flow inside a process, sharing the heap (globals, objects) with the other threads but keeping its own stack. Threads: free communication but mandatory synchronization. Processes: strong isolation, explicit communication (IPC).

La concurrence, c'est gérer plusieurs tâches sur la même période (elles peuvent s'entrelacer sur un seul cœur) : une question de structure. Le parallélisme, c'est les exécuter au même instant sur plusieurs cœurs : une question de matériel. Node.js est concurrent sans parallélisme JS ; un calcul découpé sur 8 cœurs est parallèle. Concurrency is dealing with several tasks over the same period (they may interleave on a single core): a matter of structure. Parallelism is executing them at the same instant on several cores: a matter of hardware. Node.js is concurrent without JS parallelism; a computation split across 8 cores is parallel.

Parce que c'est en réalité trois instructions : load (lire la valeur en mémoire), add (incrémenter le registre), store (réécrire). L'ordonnanceur peut suspendre un thread entre deux instructions : deux threads lisent la même valeur, et l'écriture de l'un écrase celle de l'autre — un incrément est perdu. Because it's actually three instructions: load (read the value from memory), add (increment the register), store (write it back). The scheduler can suspend a thread between two instructions: two threads read the same value, and one write clobbers the other — an increment is lost.

La section critique est la portion de code qui lit-modifie-écrit un état partagé. Un mutex (mutual exclusion) garantit qu'un seul thread à la fois l'exécute : les autres bloquent à l'entrée jusqu'à la libération du verrou. Règle d'or : le lock protège des données — tout accès à cet état, lectures comprises, doit passer par le même verrou. The critical section is the code portion that reads-modifies-writes shared state. A mutex (mutual exclusion) guarantees only one thread at a time executes it: the others block at the entrance until the lock is released. Golden rule: a lock protects data — every access to that state, reads included, must go through the same lock.

Conditions de Coffman : exclusion mutuelle, rétention et attente (hold & wait), pas de préemption des verrous, attente circulaire. En casser une seule suffit. Remède le plus courant : imposer un ordre global d'acquisition des locks (toujours les prendre dans le même ordre), ce qui rend l'attente circulaire impossible. The Coffman conditions: mutual exclusion, hold & wait, no lock preemption, circular wait. Breaking a single one is enough. Most common remedy: impose a global lock-acquisition order (always take locks in the same order), which makes circular wait impossible.

Une instruction matérielle indivisible (fetch_add, compare-and-swap) qu'aucun autre thread ne peut couper en deux. Pour un simple compteur ou un flag, `std::atomic` / `AtomicInteger` est plus léger qu'un mutex : pas de blocage, pas de deadlock possible. Dès que plusieurs variables doivent rester cohérentes ensemble, il faut revenir au lock. An indivisible hardware instruction (fetch_add, compare-and-swap) that no other thread can cut in half. For a simple counter or flag, `std::atomic` / `AtomicInteger` is lighter than a mutex: no blocking, no possible deadlock. As soon as several variables must stay consistent together, go back to a lock.

Le Global Interpreter Lock fait qu'un seul thread exécute du bytecode Python à la fois. Conséquence : les threads Python sont utiles pour l'I/O (le GIL est relâché pendant les attentes réseau/disque) mais n'apportent aucun gain sur du calcul pur — pour le CPU-bound, on passe par multiprocessing. The Global Interpreter Lock means only one thread executes Python bytecode at a time. Consequence: Python threads are useful for I/O (the GIL is released during network/disk waits) but bring no gain on pure computation — for CPU-bound work, use multiprocessing.

La nature de la charge. I/O-bound (le programme attend : API, DB, fichiers) → async/event loop, qui gère des milliers d'attentes sur un seul thread. CPU-bound (le programme calcule : encodage, crypto, ML) → plusieurs processus ou threads natifs, environ un par cœur. L'async n'accélère jamais un calcul. The nature of the workload. I/O-bound (the program waits: APIs, DB, files) → async/event loop, handling thousands of waits on a single thread. CPU-bound (the program computes: encoding, crypto, ML) → several processes or native threads, roughly one per core. Async never speeds up a computation.

Un vecteur dense de nombres flottants (384 à 3072 dimensions) produit par un modèle entraîné pour que deux textes proches en sens donnent des vecteurs proches. Il permet la recherche sémantique : on retrouve des textes par similarité de sens, pas par mots-clés. A dense vector of floats (384 to 3072 dimensions) produced by a model trained so that texts close in meaning yield close vectors. It enables semantic search: finding texts by similarity of meaning, not by keywords.

Avec la similarité cosinus : le cosinus de l'angle entre les deux vecteurs (1 = même direction, 0 = sans rapport). Avec des vecteurs normalisés, c'est un simple produit scalaire, et le classement est identique à celui de la distance euclidienne. With cosine similarity: the cosine of the angle between the two vectors (1 = same direction, 0 = unrelated). With normalized vectors it's a simple dot product, and the ranking matches Euclidean distance.

Indexation (offline) : documents → chunking → embedding de chaque chunk → stockage en base vectorielle avec texte et métadonnées. Requête (online) : question → embedding (même modèle) → recherche top-k par similarité → chunks injectés dans le prompt → génération par le LLM. Indexing (offline): documents → chunking → embedding of each chunk → storage in a vector database with text and metadata. Query (online): question → embedding (same model) → top-k similarity search → chunks injected into the prompt → LLM generation.

Fraîcheur (réindexer un document suffit, pas de réentraînement), coût (embeddings marginaux contre GPU + dataset), citations (sources traçables et vérifiables). Le fine-tuning sert à modifier le comportement (ton, format), pas à injecter des faits. Freshness (reindexing a document is enough, no retraining), cost (marginal embeddings versus GPUs + dataset), citations (traceable, verifiable sources). Fine-tuning is for changing behavior (tone, format), not injecting facts.

Une extension PostgreSQL qui ajoute un type vecteur, la recherche par similarité et des index HNSW/IVFFlat. À préférer par défaut : les vecteurs restent dans la base qu'on administre déjà, avec SQL et jointures. Les bases dédiées (Qdrant, Weaviate, Pinecone) ne se justifient qu'à très grande échelle. A PostgreSQL extension adding a vector type, similarity search and HNSW/IVFFlat indexes. Prefer it by default: vectors stay in the database you already run, with SQL and joins. Dedicated databases (Qdrant, Weaviate, Pinecone) only pay off at very large scale.

Le découpage des documents en morceaux avant embedding. Un découpage naïf (tous les N caractères) coupe phrases et tableaux en deux → chunks incompréhensibles et retrieval dégradé. Mieux : découper selon la structure (titres, paragraphes) avec 10-20 % de chevauchement. Splitting documents into pieces before embedding. Naive splitting (every N characters) cuts sentences and tables in half → incomprehensible chunks and degraded retrieval. Better: split along structure (headings, paragraphs) with 10-20% overlap.

L'hybride combine recherche lexicale (BM25, exacte sur les mots — attrape codes d'erreur et références) et vectorielle (sémantique), fusionnées par RRF. Le reranking re-classe les ~50 premiers candidats avec un cross-encoder plus précis mais plus lent, pour un top-5 de qualité. Hybrid combines lexical search (BM25, exact on words — catches error codes and references) and vector search (semantic), fused with RRF. Reranking re-orders the top ~50 candidates with a more precise but slower cross-encoder, yielding a high-quality top-5.

Le retrieval d'abord : sur un jeu de questions annotées, mesurer si les bons chunks remontent (recall@k). Ensuite seulement la génération : fidélité au contexte, taux de citation. Si le retrieval rate, aucun prompt ne sauvera la réponse. Retrieval first: on an annotated question set, measure whether the right chunks come back (recall@k). Only then generation: faithfulness to context, citation rate. If retrieval misses, no prompt will save the answer.

Stocké : le payload est persisté (commentaire en DB) et servi à tous les visiteurs. Réfléchi : le payload voyage dans l'URL et est renvoyé dans la page (il faut faire cliquer la victime). DOM-based : la faille est entièrement côté client, le JS injecte une donnée non fiable dans le DOM (innerHTML). Stored: the payload is persisted (comment in DB) and served to every visitor. Reflected: the payload travels in the URL and is echoed back into the page (the victim must click). DOM-based: the flaw is entirely client-side, JS injects untrusted data into the DOM (innerHTML).

innerHTML interprète la chaîne comme du HTML : un `<img src=x onerror=...>` s'exécute. Neutralisation : textContent quand on affiche du texte (le payload s'affiche sans s'exécuter) ; si on a vraiment besoin de HTML riche, sanitizer avec DOMPurify. En React, même règle pour dangerouslySetInnerHTML. innerHTML interprets the string as HTML: an `<img src=x onerror=...>` executes. Neutralization: textContent when displaying text (the payload is shown, not executed); if you genuinely need rich HTML, sanitize with DOMPurify. In React, same rule for dangerouslySetInnerHTML.

Le navigateur joint automatiquement les cookies d'un site à toute requête vers ce site. Un site malveillant fait donc soumettre (formulaire caché auto-submit) une requête vers bank.com par le navigateur d'une victime connectée : le cookie de session part avec, le serveur voit une requête authentifiée valide. L'attaquant n'exécute aucun code sur bank.com. The browser automatically attaches a site's cookies to any request headed to it. A malicious site therefore makes a logged-in victim's browser submit (hidden auto-submitted form) a request to bank.com: the session cookie goes along, and the server sees a valid authenticated request. The attacker executes no code on bank.com.

Strict : le cookie ne part jamais en contexte cross-site (même en cliquant un lien). Lax (défaut moderne) : il part uniquement sur les navigations top-level en GET. None : il part toujours, et exige Secure. Lax bloque le CSRF classique en POST — d'où la règle « jamais de mutation d'état en GET ». Strict: the cookie never travels in cross-site contexts (even when clicking a link). Lax (modern default): it only travels on top-level GET navigations. None: it always travels, and requires Secure. Lax blocks classic POST CSRF — hence the rule "never mutate state on GET".

Un assouplissement contrôlé de la same-origin policy : le serveur déclare via Access-Control-Allow-Origin quelles origines web peuvent lire ses réponses. Il est appliqué par le navigateur uniquement — curl, Postman ou un autre serveur l'ignorent. CORS protège les utilisateurs, pas l'API : la sécurité serveur reste l'authentification/autorisation. A controlled relaxation of the same-origin policy: the server declares via Access-Control-Allow-Origin which web origins may read its responses. It is enforced by the browser only — curl, Postman or another server ignore it. CORS protects users, not the API: server security remains authentication/authorization.

Une requête OPTIONS envoyée automatiquement par le navigateur avant une requête « non simple » (Content-Type JSON, headers custom, PUT/DELETE…). Le serveur y répond avec les méthodes, headers et origines autorisés (Access-Control-Allow-*). Si le preflight échoue, la vraie requête n'est jamais envoyée : c'est l'« erreur CORS » de la console. An OPTIONS request the browser automatically sends before a "non-simple" request (JSON Content-Type, custom headers, PUT/DELETE…). The server replies with the allowed methods, headers and origins (Access-Control-Allow-*). If the preflight fails, the real request is never sent: that's the console's "CORS error".

C'est une liste blanche déclarative (header HTTP) de ce que la page peut charger et exécuter : script-src, img-src, frame-ancestors… Bien configurée (sans 'unsafe-inline'), elle bloque l'exécution des scripts inline injectés : même si un payload XSS passe l'échappement, il ne s'exécute pas. Défense en profondeur, pas un remplacement de l'échappement. A declarative allowlist (HTTP header) of what the page may load and execute: script-src, img-src, frame-ancestors… Properly configured (without 'unsafe-inline'), it blocks injected inline scripts from executing: even if an XSS payload gets past escaping, it doesn't run. Defense in depth, not a replacement for escaping.

localStorage : lisible par le JS, donc n'importe quel XSS exfiltre le token. Cookie httpOnly : illisible par le JS (le XSS ne peut plus voler le token) mais envoyé automatiquement, donc exposé au CSRF — à couvrir avec SameSite + token anti-CSRF. Recommandation générale : cookie httpOnly + Secure + SameSite. Un XSS reste grave dans les deux cas. localStorage: readable by JS, so any XSS exfiltrates the token. httpOnly cookie: unreadable by JS (XSS can no longer steal the token) but sent automatically, hence exposed to CSRF — covered with SameSite + an anti-CSRF token. General recommendation: httpOnly + Secure + SameSite cookie. XSS remains serious either way.

Kafka est un log distribué append-only : lire ne détruit rien, chaque consommateur avance son propre offset dans un journal immuable conservé selon une rétention (replay possible). RabbitMQ est une file : un message consommé et acquitté est supprimé, et le routage (exchanges, bindings) y est beaucoup plus riche. Kafka is a distributed append-only log: reading destroys nothing, each consumer advances its own offset through an immutable journal kept per a retention policy (replay possible). RabbitMQ is a queue: a consumed and acked message is deleted, and routing (exchanges, bindings) is much richer.

Un topic est un flux nommé d'événements, découpé en partitions. Chaque partition est un journal ordonné et immuable ; chaque message y reçoit un offset croissant. La partition est l'unité d'ordre et de parallélisme ; l'offset est le curseur de lecture de chaque groupe de consommateurs. A topic is a named stream of events, split into partitions. Each partition is an ordered, immutable log; each message in it gets an increasing offset. The partition is the unit of ordering and parallelism; the offset is each consumer group's read cursor.

Au sein d'un groupe, chaque partition est assignée à exactement un consumer (un consumer peut avoir plusieurs partitions). Conséquence : le parallélisme maximal d'un groupe = le nombre de partitions ; les consumers excédentaires restent idle. Ajouter/retirer un consumer déclenche un rebalance. Within a group, each partition is assigned to exactly one consumer (a consumer can hold several partitions). Consequence: a group's maximum parallelism = the partition count; extra consumers sit idle. Adding/removing a consumer triggers a rebalance.

Le producteur hash la clé pour choisir la partition : tous les événements d'une même clé vont dans la même partition et y restent ordonnés. Kafka ne garantit l'ordre QUE par partition — les événements devant rester ordonnés entre eux doivent donc partager la même clé (ex. order-id). Sans clé : round-robin, aucun ordre. The producer hashes the key to pick the partition: all events with the same key go to the same partition and stay ordered there. Kafka guarantees order ONLY per partition — events that must stay ordered relative to each other must share the same key (e.g. order-id). Without a key: round-robin, no ordering.

Les messages restent dans le log jusqu'à expiration de la rétention (temps/taille), lus ou non. On peut donc remettre les offsets d'un groupe en arrière et retraiter tout l'historique : reconstruire un cache, alimenter un nouveau service, rejouer après un bug. Une queue classique supprime à la consommation : replay impossible. Messages stay in the log until retention expires (time/size), read or not. You can therefore rewind a group's offsets and reprocess the whole history: rebuild a cache, feed a new service, replay after a bug. A classic queue deletes on consumption: no replay possible.

Par défaut : at-least-once — si le consumer crash entre le traitement et le commit d'offset, le message est relivré (doublons possibles). Committer avant de traiter = at-most-once (perte possible). L'exactly-once (producteur idempotent + transactions) vaut surtout en périmètre Kafka→Kafka ; bout en bout, on vise at-least-once + consumer idempotent. By default: at-least-once — if the consumer crashes between processing and committing the offset, the message is redelivered (duplicates possible). Committing before processing = at-most-once (possible loss). Exactly-once (idempotent producer + transactions) mostly holds within Kafka→Kafka; end to end, aim for at-least-once + an idempotent consumer.

Event sourcing : stocker la séquence d'événements comme source de vérité et reconstruire l'état en les rejouant (audit complet, replay, mais complexité réelle : versionnage, projections). CQRS : séparer le modèle d'écriture (commandes → événements) du modèle de lecture (projections optimisées). On peut être event-driven sans faire d'event sourcing complet. Event sourcing: store the sequence of events as the source of truth and rebuild state by replaying them (full audit, replay, but real complexity: versioning, projections). CQRS: separate the write model (commands → events) from the read model (optimized projections). You can be event-driven without doing full event sourcing.

Faible volume, un seul consommateur, pas de besoin de replay : une table jobs en Postgres, RabbitMQ ou Redis Streams suffisent pour une fraction du coût opérationnel (cluster de brokers, monitoring, rebalances). Kafka se justifie par : gros volumes, plusieurs lecteurs indépendants, replay/rétention, streaming temps réel. Low volume, a single consumer, no replay needs: a jobs table in Postgres, RabbitMQ or Redis Streams suffice at a fraction of the operational cost (broker cluster, monitoring, rebalances). Kafka is justified by: large volumes, several independent readers, replay/retention, real-time streaming.

Une exécution de code à distance sans aucune action de l'utilisateur (zéro clic), découverte par le labo Air Security, présente simultanément dans les quatre principaux agents de code : Claude Code, OpenAI Codex, GitHub Copilot et Gemini CLI. Un plugin compromis s'exécute avec les permissions du développeur qui lance l'agent : code source local, identifiants cloud, clés SSH, dépôts internes, accès de production. C'est la première faille de chaîne d'approvisionnement de l'écosystème des agents. A remote code execution needing no user action at all (zero-click), found by the Air Security lab, present simultaneously in the four major coding agents: Claude Code, OpenAI Codex, GitHub Copilot and Gemini CLI. A compromised plugin runs with the permissions of the developer launching the agent: local source code, cloud credentials, SSH keys, internal repositories, production access. It is the first supply chain vulnerability of the agent ecosystem.

L'agent épingle un commit SHA de 40 caractères hexadécimaux et fait un git checkout dessus, mais ne vérifie jamais que l'arbre de travail correspond bien à ce commit. Or git autorise des noms de branche qui ressemblent à un hash : l'attaquant crée une branche nommée exactement comme le SHA épinglé, la déclare branche par défaut, et le checkout résout vers la branche au lieu du commit. Gemini CLI tombait par une variante, un défaut séparé dans la récupération du commit. Le correctif tient en deux lignes : comparer git rev-parse HEAD au SHA attendu après le checkout et échouer si ça diverge. The agent pins a 40-character hexadecimal commit SHA and runs git checkout on it, but never verifies that the working tree actually matches that commit. Git allows branch names that look like a hash: the attacker creates a branch named exactly like the pinned SHA, makes it the default branch, and the checkout resolves to the branch instead of the commit. Gemini CLI fell through a variant, a separate flaw in commit fetching. The fix is two lines: compare git rev-parse HEAD to the expected SHA after checkout and fail if they diverge.

Zéro clic parce que Claude Code et Codex mettent à jour les plugins installés en arrière-plan par défaut : l'attaquant publie un plugin d'apparence honnête, attend son adoption, puis modifie le dépôt amont, et la mise à jour automatique rejoue le checkout vulnérable sans intervention. Chronologie : découverte en mai 2026, signalement aux quatre éditeurs en juin. Anthropic a corrigé le 17 juin (Claude Code 2.1.179), OpenAI dans Codex 0.146.0 vérifié le 12 août, Google a annoncé le 4 août qu'il ne corrigerait pas (Gemini CLI déprécié au profit d'Antigravity) et GitHub n'avait pas publié de correctif pour Copilot à la divulgation. Zero-click because Claude Code and Codex update installed plugins in the background by default: the attacker publishes an honest-looking plugin, waits for adoption, then modifies the upstream repository, and the auto-update replays the vulnerable checkout with no user involvement. Timeline: found in May 2026, disclosed to all four vendors in June. Anthropic fixed it on June 17 (Claude Code 2.1.179), OpenAI in Codex 0.146.0 verified August 12, Google announced on August 4 that it would not patch (Gemini CLI deprecated in favour of Antigravity), and GitHub had no fix for Copilot at disclosure time.

Claude mène 26 % du travail de R&D IA d'Anthropic en août 2026, contre moins de 1 % en février. « Mener » signifie exécuter l'essentiel d'une tâche de bout en bout depuis une consigne de haut niveau, avec un humain qui supervise ; la participation dépasse 90 % du travail mais l'autonomie complète est à 0 %. L'échelle va de AL0 à AL5, définie par Epoch AI. Environ 30 000 agents travaillent en permanence, et sur plus d'un milliard de décisions en août, 1 sur 47 000 (0,002 %) a été bloquée par le monitoring en ligne. Claude leads 26% of Anthropic's AI R&D work as of August 2026, against under 1% in February. 'Leads' means completing most of a task end to end from a high-level prompt, with a human supervising; participation exceeds 90% of the work but full autonomy sits at 0%. The scale runs AL0 to AL5, defined by Epoch AI. Roughly 30,000 agents work at any given time, and out of more than a billion decisions in August, 1 in 47,000 (0.002%) was blocked by the online monitor.

1) Reproduire le bug de façon fiable ; 2) réduire au cas minimal (par dichotomie) ; 3) formuler une hypothèse falsifiable ; 4) mener une expérience en ne changeant qu'une variable à la fois ; 5) hypothèse confirmée → corriger + test de non-régression, réfutée → nouvelle hypothèse. 1) Reproduce the bug reliably; 2) reduce to a minimal case (by bisection); 3) form a falsifiable hypothesis; 4) run an experiment changing only one variable at a time; 5) hypothesis confirmed → fix + regression test, refuted → new hypothesis.

Si on change deux choses et que le bug disparaît, impossible de savoir laquelle était la cause — et on a peut-être introduit un second bug qui masque le premier. Une expérience doit pouvoir confirmer ou réfuter UNE hypothèse précise. If you change two things and the bug disappears, you can't know which one was the cause — and you may have introduced a second bug masking the first. An experiment must be able to confirm or refute ONE precise hypothesis.

C'est une recherche binaire dans l'historique Git : on marque un commit `good` et un commit `bad`, Git checkout le commit du milieu, on teste et on répond good/bad, et on converge vers le premier commit cassé en O(log n) — ~10 tests pour 1000 commits. `git bisect run <cmd>` automatise tout via le code de sortie. It's a binary search through Git history: you mark a `good` and a `bad` commit, Git checks out the midpoint, you test and answer good/bad, converging on the first broken commit in O(log n) — ~10 tests for 1000 commits. `git bisect run <cmd>` automates it via the exit code.

Debugger : explorer un état complexe à un instant T — breakpoints (y compris conditionnels), watch, step over/into, sans redéployer. printf/logs : capturer une chronologie (asynchrone, bugs intermittents) et déboguer la prod, où les logs sont le seul debugger disponible. Les deux sont complémentaires. Debugger: exploring complex state at a point in time — breakpoints (including conditional), watch, step over/into, without redeploying. printf/logs: capturing a timeline (async code, intermittent bugs) and debugging prod, where logs are the only debugger available. The two are complementary.

C'est un heisenbug : l'observation modifie l'expérience. Le debugger fige les threads et le print ralentit l'exécution, ce qui change l'ordonnancement — signature typique d'une race condition ou d'un problème de timing. Réflexe : logging léger horodaté, thread sanitizer, relire les sections critiques. It's a heisenbug: observing changes the experiment. The debugger freezes threads and the print slows execution, altering scheduling — the typical signature of a race condition or timing issue. Reflex: lightweight timestamped logging, thread sanitizer, re-read the critical sections.

Expliquer le problème à voix haute, ligne par ligne, force à verbaliser et donc à vérifier chaque hypothèse implicite (« ici cette variable vaut forcément X… ah non »). C'est en général une de ces hypothèses non vérifiées qui est fausse. D'où les questions qui se résolvent pendant qu'on les pose. Explaining the problem out loud, line by line, forces you to verbalize and therefore check every implicit assumption ("here this variable must be X… oh wait"). One of those unchecked assumptions is usually the false one. Hence questions that solve themselves while being asked.

Un cas minimal reproductible (le code le plus court qui montre le bug), le comportement attendu, le comportement observé (message d'erreur complet), ce qui a déjà été essayé, et les versions/environnement. Construire le cas minimal résout souvent le problème avant même de poser la question. A minimal reproducible example (the shortest code showing the bug), the expected behavior, the observed behavior (full error message), what was already tried, and versions/environment. Building the minimal case often solves the problem before the question is even asked.

D'abord le message d'erreur en entier (le quoi), puis parcourir les frames jusqu'à la première qui appartient à VOTRE code (le où) — les frames du framework sont du contexte, pas des suspects. Attention au sens de lecture : selon le langage, l'appel le plus profond est en haut ou en bas (Python : en bas). First the full error message (the what), then walk the frames to the first one that belongs to YOUR code (the where) — framework frames are context, not suspects. Mind the reading order: depending on the language, the deepest call is at the top or the bottom (Python: bottom).

Atomicité : débit + crédit, tout ou rien. Cohérence : les contraintes (solde >= 0) restent respectées. Isolation : personne ne voit l'état intermédiaire débité-mais-pas-crédité. Durabilité : commit acquitté = écrit dans le WAL, survit au crash. Atomicity: debit + credit, all or nothing. Consistency: constraints (balance >= 0) stay respected. Isolation: nobody sees the debited-but-not-credited intermediate state. Durability: acknowledged commit = written to the WAL, survives a crash.

Lire une valeur modifiée par une transaction qui n'a pas encore commité. Si elle rollback, on a travaillé sur une donnée qui n'a jamais existé. Empêché dès READ COMMITTED (le défaut Postgres). Reading a value modified by a transaction that hasn't committed yet. If it rolls back, you've worked on data that never existed. Prevented from READ COMMITTED up (the Postgres default).

Non-repeatable : une ligne existante relue a changé (UPDATE commité entre deux lectures). Phantom : l'ensemble des lignes matchant un critère a changé (INSERT/DELETE commité) — des lignes apparaissent ou disparaissent. REPEATABLE READ du standard bloque le premier, pas le second. Non-repeatable: an existing row re-read has changed (committed UPDATE between two reads). Phantom: the set of rows matching a predicate has changed (committed INSERT/DELETE) — rows appear or disappear. The standard's REPEATABLE READ blocks the former, not the latter.

T1 et T2 lisent solde=100, chacune calcule en mémoire (100-80 et 100-50), chacune écrit son résultat : la seconde écriture écrase la première — 130 retirés, solde final 50. Corrections : update atomique (SET solde = solde - X), SELECT FOR UPDATE, ou verrou optimiste (colonne version). T1 and T2 both read balance=100, each computes in memory (100-80 and 100-50), each writes its result: the second write overwrites the first — 130 withdrawn, final balance 50. Fixes: atomic update (SET balance = balance - X), SELECT FOR UPDATE, or optimistic locking (version column).

Chaque UPDATE crée une nouvelle version de la ligne au lieu d'écraser l'ancienne ; chaque transaction lit un snapshot cohérent des versions commitées à son début. Lecteurs et écrivains ne se bloquent jamais mutuellement ; seules deux écritures sur la même ligne se sérialisent. VACUUM recycle les versions mortes. Each UPDATE creates a new version of the row instead of overwriting the old one; each transaction reads a consistent snapshot of the versions committed at its start. Readers and writers never block each other; only two writes to the same row serialize. VACUUM recycles dead versions.

Lit la ligne et la verrouille jusqu'au COMMIT/ROLLBACK : toute transaction concurrente voulant la modifier ou la verrouiller attend. Verrou pessimiste qui ferme la fenêtre read-modify-write — l'anti-lost-update quand le calcul doit passer par l'applicatif. Reads the row and locks it until COMMIT/ROLLBACK: any concurrent transaction wanting to modify or lock it waits. A pessimistic lock closing the read-modify-write window — the anti-lost-update when the computation must go through application code.

T1 verrouille A puis attend B ; T2 verrouille B puis attend A : attente circulaire. La base le détecte et tue une des transactions (à retenter). Prévention : acquérir les verrous toujours dans le même ordre (id croissant) — plus de cycle possible — et garder les transactions courtes. T1 locks A then waits for B; T2 locks B then waits for A: circular wait. The database detects it and kills one transaction (to be retried). Prevention: always acquire locks in the same order (ascending id) — no cycle possible — and keep transactions short.

La transaction garde ses verrous et son snapshot pendant toute l'attente : connexions saturées, contention en cascade, VACUUM bloqué. Et si l'I/O réussit mais que la transaction rollback (ou l'inverse), les deux mondes divergent. I/O externe toujours hors transaction. The transaction holds its locks and snapshot for the whole wait: saturated connections, cascading contention, blocked VACUUM. And if the I/O succeeds but the transaction rolls back (or the reverse), the two worlds diverge. External I/O always outside the transaction.

« Où et quand le HTML est-il produit ? » CSR : dans le navigateur à l'exécution. SSR : sur le serveur à chaque requête. SSG : au build, une fois. ISR : au build, puis régénéré page par page en arrière-plan après expiration. "Where and when is the HTML produced?" CSR: in the browser at runtime. SSR: on the server per request. SSG: at build time, once. ISR: at build time, then regenerated page by page in the background after expiry.

Le HTML rendu côté serveur n'a aucun event listener : il est visible mais inerte. L'hydration ré-exécute les composants dans le navigateur et rattache état et événements au DOM existant. Nécessaire car l'interactivité vit dans le JS ; coûteuse car on paie le rendu deux fois. Server-rendered HTML has no event listeners: it's visible but inert. Hydration re-executes the components in the browser and reattaches state and events to the existing DOM. Necessary because interactivity lives in JS; costly because you pay for rendering twice.

Le HTML initial est une coquille vide ; le contenu n'apparaît qu'après exécution du JS. Google l'exécute mais avec délai et budget de crawl, et les aperçus de liens (Slack, réseaux sociaux) ne l'exécutent jamais. Contenu à indexer = contenu dans le HTML initial (SSR/SSG). The initial HTML is an empty shell; content only appears after JS executes. Google runs it but with delay and a crawl budget, and link previews (Slack, social networks) never run it. Content to index = content in the initial HTML (SSR/SSG).

Le SSG fige le contenu jusqu'au prochain build complet — intenable avec 50 000 pages à reconstruire pour un prix corrigé. L'ISR régénère chaque page individuellement en arrière-plan après un délai (revalidate) ou sur webhook : TTFB du statique, fraîcheur contrôlée, sans rebuild global. SSG freezes content until the next full build — untenable with 50,000 pages to rebuild for one corrected price. ISR regenerates each page individually in the background after a delay (revalidate) or on webhook: static TTFB, controlled freshness, no global rebuild.

La page est du HTML statique par défaut, sans JS ; seuls des îlots explicitement marqués interactifs (client:load, client:visible) reçoivent leur bundle et s'hydratent. On n'envoie du JS que là où il y a une interaction réelle — le contraire d'une SPA qui hydrate tout. The page is static HTML by default, with no JS; only islands explicitly marked interactive (client:load, client:visible) receive their bundle and hydrate. JS is shipped only where an actual interaction exists — the opposite of a SPA hydrating everything.

Quand le rendu client ne correspond pas au HTML serveur (new Date(), Math.random(), window.innerWidth au premier rendu) : le framework avertit et re-rend, causant flash et perte de perf. Solution : premier rendu déterministe, valeurs client-only déplacées dans un useEffect. When the client render doesn't match the server HTML (new Date(), Math.random(), window.innerWidth in the first render): the framework warns and re-renders, causing a flash and lost perf. Fix: deterministic first render, client-only values moved into a useEffect.

App derrière une authentification (dashboard, back-office, SaaS) : aucun enjeu SEO, utilisateurs récurrents avec bundle en cache, interactivité riche. Le SSR ajouterait un coût et une complexité serveur pour un premier affichage que personne n'indexe. An app behind authentication (dashboard, back-office, SaaS): no SEO stakes, recurring users with a cached bundle, rich interactivity. SSR would add server cost and complexity for a first paint nobody indexes.

Des composants qui s'exécutent uniquement côté serveur et ne s'hydratent jamais : leur code ne quitte pas le serveur, seul le résultat rendu voyage vers le client — moins de JS envoyé, l'hydration étant réservée aux composants client interactifs. Components that run only on the server and never hydrate: their code never leaves the server, only the rendered result travels to the client — less JS shipped, with hydration reserved for interactive client components.

SYN : le client propose son numéro de séquence initial. SYN-ACK : le serveur l'acquitte et propose le sien. ACK : le client confirme. Les deux côtés ont synchronisé leurs numéros de séquence ; la connexion est établie au prix d'un RTT complet avant toute donnée. SYN: the client proposes its initial sequence number. SYN-ACK: the server acknowledges it and proposes its own. ACK: the client confirms. Both sides have synchronized sequence numbers; the connection is established at the cost of a full RTT before any data.

Livraison dans l'ordre et sans doublon (numéros de séquence), retransmission des segments perdus (ACK + timeout), flow control (fenêtre du récepteur) et congestion control (adaptation au réseau). UDP n'ajoute que les ports et un checksum au-dessus d'IP. In-order, duplicate-free delivery (sequence numbers), retransmission of lost segments (ACK + timeout), flow control (receiver window) and congestion control (adapting to the network). UDP only adds ports and a checksum on top of IP.

L'échange est minuscule : une question, une réponse, qui tiennent dans un datagramme. Établir une connexion TCP (1 RTT) coûterait plus cher que l'échange lui-même ; en cas de perte, le client réessaie simplement. TCP reste utilisé pour les grandes réponses et les transferts de zone. The exchange is tiny: one question, one answer, fitting in a single datagram. Establishing a TCP connection (1 RTT) would cost more than the exchange itself; on loss, the client simply retries. TCP is still used for large responses and zone transfers.

Le quadruplet (IP source, port source, IP destination, port destination). C'est pour ça qu'un serveur peut servir des milliers de clients sur le même port 443 : chaque client a une IP/port source différent, donc un quadruplet différent. The 4-tuple (source IP, source port, destination IP, destination port). That's why a server can serve thousands of clients on the same port 443: each client has a different source IP/port, hence a different tuple.

Le routeur réécrit IP/port source des paquets sortants vers son IP publique et mémorise le mapping pour router les réponses. Conséquence : une machine derrière un NAT ne peut pas recevoir de connexion entrante spontanée — il faut une redirection de port ou des techniques STUN/TURN (WebRTC). The router rewrites outgoing packets' source IP/port to its public IP and memorizes the mapping to route replies back. Consequence: a machine behind NAT cannot receive spontaneous incoming connections — you need port forwarding or STUN/TURN techniques (WebRTC).

La bande passante est le débit du tuyau (Mo/s), la latence le temps d'un aller-retour (ms). Les petites requêtes sont dominées par la latence : 3-4 RTT (DNS, handshake TCP, TLS) avant le premier octet. Augmenter le débit n'y change rien ; il faut réduire les allers-retours (keep-alive, HTTP/2-3, CDN). Bandwidth is the pipe's throughput (MB/s), latency the time of one round trip (ms). Small requests are latency-bound: 3-4 RTTs (DNS, TCP handshake, TLS) before the first byte. More throughput changes nothing; you must cut round trips (keep-alive, HTTP/2-3, CDN).

L'émetteur sonde prudemment le réseau (slow start : débit doublé à chaque RTT, puis évitement de congestion) et réduit fortement son débit dès qu'une perte est détectée. C'est ce qui empêche l'effondrement d'Internet et explique qu'un transfert TCP n'atteint pas son débit max instantanément. The sender cautiously probes the network (slow start: rate doubled every RTT, then congestion avoidance) and sharply cuts its rate as soon as a loss is detected. It's what prevents Internet collapse and why a TCP transfer doesn't reach max throughput instantly.

ss -tlnp : qui écoute sur quels ports. ping : latence et joignabilité ICMP. traceroute : le chemin saut par saut. dig : résolution DNS. curl -w : décomposer une requête HTTP (DNS, TCP, TLS, TTFB, total). tcpdump : voir les paquets bruts. ss -tlnp: who listens on which ports. ping: ICMP latency and reachability. traceroute: the path hop by hop. dig: DNS resolution. curl -w: break an HTTP request down (DNS, TCP, TLS, TTFB, total). tcpdump: see raw packets.

Un attaquant russophone a lancé des centaines d'agents IA (propulsés par OpenAI Codex et un modèle DeepSeek) contre des serveurs d'impression PaperCut, en exploitant CVE-2026-81578 (contournement d'authentification) et CVE-2026-82078 (exécution de code à distance). Bilan : 440 instances compromises, 395 organisations dans 48 pays, dont 204 écoles et universités. Première RCE en moins de 4 heures après le début, et 11 organisations compromises en 26 secondes au pic. Signalé indépendamment par Blackpoint Cyber et GreyNoise. A Russian-speaking attacker turned hundreds of AI agents (powered by OpenAI Codex and a DeepSeek model) loose on PaperCut print servers, exploiting CVE-2026-81578 (authentication bypass) and CVE-2026-82078 (remote code execution). The toll: 440 compromised instances, 395 organizations in 48 countries, 204 of them schools and universities. First RCE in under 4 hours, and 11 organizations compromised in 26 seconds at peak. Independently reported by Blackpoint Cyber and GreyNoise.

L'outillage offensif n'avait rien de nouveau : Mimikatz, SharpHound, Certipy, Rubeus, Impacket, des charges Meterpreter en Java, tous publics depuis des années. Ce qui était nouveau, c'est que personne ne les pilotait à la main. Les agents tournaient en parallèle dans AionUi et partageaient leurs acquis via Hindsight, un service de mémoire persistante. L'IA n'a pas augmenté la sophistication de l'attaque, elle a effondré le coût marginal d'une cible supplémentaire, en supprimant le facteur limitant historique : le temps d'un humain compétent. The offensive tooling was not new: Mimikatz, SharpHound, Certipy, Rubeus, Impacket, Java Meterpreter payloads, all public for years. What was new is that nobody was driving them by hand. The agents ran in parallel inside AionUi and shared what they learned through Hindsight, a persistent memory service. AI did not raise the sophistication of the attack, it collapsed the marginal cost of one more target by removing the historic bottleneck: the time of a skilled human.

Un essai de 3 800 mots dont la thèse est « nous devons ralentir le rythme auquel nous améliorons les capacités des modèles ». Son avertissement : dans 6 à 12 mois, un essaim d'agents autonomes pourrait prendre le contrôle d'une bonne partie d'Internet via un botnet persistant, pour des centaines de milliards de dollars de dégâts. Plan en trois temps : des évaluateurs tiers embarqués avec un accès de niveau salarié (Anthropic s'y engage unilatéralement), des standards de sécurité communs entre laboratoires, puis leur extension par les États. Altman et Musk ont approuvé en quelques heures, Trump a rejeté l'appel le lendemain. A 3,800-word essay whose thesis is 'we must slow the pace at which we improve the capabilities of AI models'. His warning: within 6 to 12 months, a swarm of autonomous agents could take over much of the internet with a persistent botnet, causing hundreds of billions of dollars in damage. Three-part plan: embedded third-party evaluators with employee-level access (Anthropic committing unilaterally), common safety standards across labs, then their extension by governments. Altman and Musk agreed within hours, Trump dismissed the call the next day.

Parce que malgré une récolte d'identifiants presque généralisée (280 instances) et de secrets système ou de domaine sur 147, l'escalade complète jusqu'au domain admin a échoué dans 97 % des cas. Les agents couvrent très bien de la surface mais restent faibles sur ce qui demande du jugement. Ce sont les fondamentaux sans IA qui ont tenu : segmentation réseau, moindre privilège, comptes d'administration séparés. Les basiques n'ont pas été périmés par l'IA, ils viennent d'être validés grandeur nature. Because despite near-universal credential harvesting (280 instances) and OS or domain secrets on 147, full escalation to domain admin failed in 97% of cases. Agents cover surface very well but stay weak at anything requiring judgment. The AI-free fundamentals held: network segmentation, least privilege, separate admin accounts. The basics were not made obsolete by AI, they were validated at full scale.

Le chiffrement est réversible par définition : quiconque obtient la clé (dump, backup, admin malveillant) récupère tous les mots de passe d'un coup. On stocke un hash cryptographique, fonction à sens unique impossible à inverser. Encryption is reversible by definition: anyone who obtains the key (dump, backup, malicious admin) recovers every password at once. You store a cryptographic hash, a one-way function that cannot be inverted.

Ce sont des hashs conçus pour être rapides : un GPU en calcule des milliards par seconde, rendant brute force et dictionnaires praticables sur un dump. Il faut un algorithme volontairement lent et coûteux : bcrypt, scrypt ou argon2id. They are hashes designed to be fast: a GPU computes billions per second, making brute force and dictionaries practical on a dump. You need a deliberately slow, costly algorithm: bcrypt, scrypt or argon2id.

Valeur aléatoire unique par utilisateur ajoutée avant hashing : deux mots de passe identiques donnent des hashs différents, et les rainbow tables (tables hash → mot de passe précalculées) deviennent inutiles. Chaque hash doit être attaqué individuellement. A unique random value per user added before hashing: two identical passwords yield different hashes, and rainbow tables (precomputed hash → password tables) become useless. Every hash must be attacked individually.

Non. bcrypt le stocke en clair dans sa chaîne de sortie ($2b$12$salt+hash). Le modèle de menace suppose que l'attaquant a tout : le salt combat le précalcul, c'est la lenteur de l'algorithme qui fournit la protection. No. bcrypt stores it in plain sight in its output string ($2b$12$salt+hash). The threat model assumes the attacker has everything: the salt defeats precomputation, and the algorithm's slowness provides the protection.

Un paramètre qui contrôle la lenteur du calcul (2^cost itérations pour bcrypt, mémoire/temps pour argon2id). On vise ~100 ms par hash côté serveur : invisible pour un login, ruineux pour un attaquant. On l'augmente quand le matériel progresse. A parameter controlling how slow the computation is (2^cost iterations for bcrypt, memory/time for argon2id). Aim for ~100 ms per hash server-side: invisible for one login, ruinous for an attacker. Raise it as hardware improves.

Une comparaison naïve (===) s'arrête au premier octet différent : le temps de réponse fuit de l'information et permet de deviner un secret octet par octet. Contre-mesure : comparaison en temps constant (crypto.timingSafeEqual, bcrypt.compare). A naive comparison (===) stops at the first differing byte: response time leaks information, letting an attacker guess a secret byte by byte. Countermeasure: constant-time comparison (crypto.timingSafeEqual, bcrypt.compare).

Token aléatoire à usage unique et expirant (15-60 min), dont on stocke le hash en DB ; invalidé après usage ; réponse identique que l'email existe ou non (anti-énumération) ; on envoie un lien, jamais le mot de passe. Random single-use expiring token (15-60 min) whose hash is stored in the DB; invalidated after use; identical response whether the email exists or not (anti-enumeration); you send a link, never the password.

Plus de secret partagé : une paire de clés est générée par appareil, le serveur ne stocke que la clé publique. Rien à hasher, rien à faire fuiter, résistant au phishing — le navigateur vérifie l'origine du site. No shared secret anymore: a key pair is generated per device and the server stores only the public key. Nothing to hash, nothing to leak, phishing-resistant — the browser verifies the site's origin.

Des noms au pluriel, jamais de verbes : `GET /users/42/orders` et non `/getOrdersOfUser`. Le verbe est porté par la méthode HTTP (GET lit, POST crée, PUT remplace, PATCH modifie, DELETE supprime). Plural nouns, never verbs: `GET /users/42/orders`, not `/getOrdersOfUser`. The verb is carried by the HTTP method (GET reads, POST creates, PUT replaces, PATCH updates, DELETE removes).

401 Unauthorized = le client n'est pas authentifié (credentials absents ou invalides). 403 Forbidden = le client est authentifié mais n'a pas les droits. Bonus : certaines API renvoient 404 au lieu de 403 pour ne pas révéler l'existence d'une ressource. 401 Unauthorized = the client is not authenticated (missing or invalid credentials). 403 Forbidden = the client is authenticated but lacks permission. Bonus: some APIs return 404 instead of 403 to avoid revealing a resource exists.

Le standard des erreurs HTTP structurées : content-type `application/problem+json` avec les champs `type` (URL identifiant la catégorie d'erreur), `title`, `status`, `detail`, `instance`, plus des extensions métier. Un client peut brancher sur `type` sans parser un message texte. The standard for structured HTTP errors: `application/problem+json` content type with the fields `type` (a URL identifying the error category), `title`, `status`, `detail`, `instance`, plus business extensions. A client can branch on `type` without parsing a text message.

Performance : l'offset force la DB à lire et jeter N lignes (lent en profondeur), le cursor fait un seek d'index direct (`WHERE created_at < :cursor`). Stabilité : des insertions pendant le parcours créent doublons ou trous avec l'offset, pas avec le cursor. Contrepartie : pas de saut direct à la page N. Performance: offset forces the DB to read and discard N rows (slow at depth), a cursor does a direct index seek (`WHERE created_at < :cursor`). Stability: inserts while paging create duplicates or gaps with offset, not with a cursor. Trade-off: no direct jump to page N.

À rendre un POST rejouable sans danger. Le client envoie une clé unique par opération ; le serveur stocke `clé → réponse` et, si la même clé revient (retry après timeout), renvoie la réponse enregistrée sans réexécuter. Popularisé par Stripe pour éviter les doubles paiements. Making a POST safely replayable. The client sends a unique key per operation; the server stores `key → response` and, if the same key returns (retry after timeout), replays the recorded response without re-executing. Popularized by Stripe to prevent double charges.

Code `429 Too Many Requests` avec un header `Retry-After` (secondes ou date) indiquant quand réessayer, plus les headers informatifs `RateLimit-Limit` / `RateLimit-Remaining`. Le client applique alors un backoff exponentiel avec jitter. Status `429 Too Many Requests` with a `Retry-After` header (seconds or a date) indicating when to retry, plus the informative `RateLimit-Limit` / `RateLimit-Remaining` headers. The client then applies exponential backoff with jitter.

En signant le payload en HMAC-SHA256 avec un secret partagé, signature transmise en header et incluant un timestamp pour bloquer le rejeu. Le récepteur vérifie la signature (comparaison constante) et la fraîcheur, répond 2xx immédiatement, traite en asynchrone et déduplique par event id. By signing the payload with HMAC-SHA256 using a shared secret, the signature sent in a header and including a timestamp to block replay. The receiver verifies the signature (constant-time compare) and freshness, answers 2xx immediately, processes asynchronously and deduplicates by event id.

Uniquement sur breaking change : suppression ou renommage de champ, changement de type ou de sémantique. Ajouter un champ ou un endpoint est rétrocompatible (les clients doivent ignorer les champs inconnus). Et on maintient la v1 avec une date de fin de vie annoncée. Only on breaking changes: field removal or rename, type or semantics change. Adding a field or endpoint is backward compatible (clients must ignore unknown fields). And you keep v1 alive with an announced end-of-life date.

La fonction de hachage transforme la clé en entier, réduit modulo la capacité du tableau interne : l'index du bucket est obtenu par un simple calcul + un accès tableau, indépendamment du nombre d'éléments. « En moyenne » car les collisions peuvent allonger un bucket. The hash function turns the key into an integer, reduced modulo the internal array's capacity: the bucket index comes from a simple computation + one array access, regardless of the number of elements. "On average" because collisions can lengthen a bucket.

Le chaining : chaque bucket contient une liste (ou un arbre) des entrées en collision. L'open addressing : en cas de collision, on sonde d'autres cases du tableau (probing) — plus compact et cache-friendly, mais load factor < 1 obligatoire et suppression via tombstones. Chaining: each bucket holds a list (or tree) of colliding entries. Open addressing: on collision, probe other slots of the array — more compact and cache-friendly, but requires a load factor < 1 and deletion via tombstones.

Le ratio nombre d'éléments / nombre de buckets. Quand il dépasse un seuil (0.75 en Java, ~0.66 en CPython), la table alloue un tableau plus grand (souvent ×2) et re-hache toutes les entrées, car hash mod capacité change avec la capacité. The ratio of elements to buckets. When it crosses a threshold (0.75 in Java, ~0.66 in CPython), the table allocates a larger array (usually ×2) and rehashes every entry, because hash mod capacity changes with the capacity.

Le resize coûte O(n) mais se déclenche de plus en plus rarement (environ toutes les n insertions). Réparti sur l'ensemble des insertions, le surcoût moyen par opération reste constant — même raisonnement que pour un tableau dynamique (ArrayList, vector). The resize costs O(n) but triggers less and less often (roughly every n insertions). Spread across all insertions, the average extra cost per operation stays constant — the same reasoning as for a dynamic array (ArrayList, vector).

Un attaquant forge des milliers de clés qui collisionnent toutes (fonction de hachage connue) : chaque insertion devient O(n), le serveur qui parse un JSON ou des paramètres HTTP tombe en DoS. Défenses : hachage à graine aléatoire par processus (SipHash dans Python, Ruby, Rust) et treeification des buckets (Java 8+). An attacker forges thousands of keys that all collide (known hash function): every insertion becomes O(n) and the server parsing JSON or HTTP parameters falls to a DoS. Defenses: per-process random-seeded hashing (SipHash in Python, Ruby, Rust) and bucket treeification (Java 8+).

Une clé immuable (ou qui ne mute jamais tant qu'elle est dans la map) avec égalité et hash cohérents : a.equals(b) implique hash(a) == hash(b). Une clé mutée après insertion devient introuvable (mauvais bucket) ; en Java, redéfinir equals sans hashCode est le bug classique. An immutable key (or one that never mutates while in the map) with consistent equality and hash: a.equals(b) implies hash(a) == hash(b). A key mutated after insertion becomes unfindable (wrong bucket); in Java, overriding equals without hashCode is the classic bug.

Clés dynamiques ou non-string, besoin de .size, insertions/suppressions fréquentes, et surtout données venant de l'utilisateur (l'objet nu est vulnérable à la pollution de prototype via __proto__). L'objet reste bien pour une struct à forme fixe (config, DTO). Dynamic or non-string keys, need for .size, frequent insertions/deletions, and above all user-provided data (a bare object is vulnerable to prototype pollution via __proto__). The object remains fine for a fixed-shape struct (config, DTO).

Un seul passage : pour chaque nums[i], calculer le complément target - nums[i] ; s'il est déjà dans la map (valeur → index), retourner les deux indices, sinon insérer nums[i] → i. Chaque test et insertion est en O(1), contre O(n²) pour la double boucle naïve. A single pass: for each nums[i], compute the complement target - nums[i]; if it's already in the map (value → index), return both indices, otherwise insert nums[i] → i. Each check and insertion is O(1), versus O(n²) for the naive double loop.

Parsing HTML → DOM et parsing CSS → CSSOM ; fusion en render tree (nœuds visibles + styles calculés) ; layout (géométrie de chaque boîte) ; paint (rasterisation en pixels dans des layers) ; composite (le GPU assemble les layers). HTML parsing → DOM and CSS parsing → CSSOM; merged into the render tree (visible nodes + computed styles); layout (each box's geometry); paint (rasterization into layers); composite (the GPU assembles the layers).

Le reflow recalcule la géométrie (positions, tailles) et peut se propager à une grande partie de l'arbre ; le repaint redessine les pixels sans toucher à la géométrie. Un reflow entraîne toujours un repaint, jamais l'inverse : le reflow est l'opération la plus chère. Reflow recomputes geometry (positions, sizes) and can propagate through much of the tree; repaint redraws pixels without touching geometry. A reflow always triggers a repaint, never the other way around: reflow is the most expensive operation.

Les deux téléchargent en parallèle sans bloquer le parser. `async` exécute dès que le script est prêt, ordre non garanti (scripts indépendants). `defer` exécute après le parsing, dans l'ordre du document, juste avant DOMContentLoaded (code applicatif). `type="module"` est defer par défaut. Both download in parallel without blocking the parser. `async` executes as soon as the script is ready, order not guaranteed (independent scripts). `defer` executes after parsing, in document order, right before DOMContentLoaded (application code). `type="module"` is defer by default.

L'ensemble minimal d'étapes et de ressources bloquantes (HTML, CSS render-blocking, scripts synchrones) que le navigateur doit franchir avant le premier rendu. L'optimiser = réduire ou différer les ressources bloquantes pour afficher plus tôt. The minimal set of steps and blocking resources (HTML, render-blocking CSS, synchronous scripts) the browser must get through before the first render. Optimizing it means reducing or deferring blocking resources to display sooner.

Sans CSSOM complet, le navigateur risquerait d'afficher un flash de contenu non stylé : il attend donc les styles avant de rendre. Le CSS bloque aussi l'exécution des scripts, qui pourraient lire des styles calculés — mais pas le parser HTML, qui continue à construire le DOM. Without a complete CSSOM the browser would risk a flash of unstyled content, so it waits for styles before rendering. CSS also blocks script execution, since scripts might read computed styles — but not the HTML parser, which keeps building the DOM.

Cookies : ~4 Ko, envoyés au serveur à chaque requête, expiration configurable, peuvent être HttpOnly (invisibles pour JS). localStorage : ~5-10 Mo, persistant, jamais envoyé, portée = origine. sessionStorage : idem mais limité à l'onglet et vidé à sa fermeture. Cookies: ~4 KB, sent to the server with every request, configurable expiry, can be HttpOnly (invisible to JS). localStorage: ~5-10 MB, persistent, never sent, scoped to the origin. sessionStorage: same but limited to the tab and cleared when it closes.

Deux URLs partagent une origine si schéma + hôte + port sont identiques ; un document ne peut lire les données (DOM, storage, réponses) que de sa propre origine. CORS est le mécanisme côté serveur pour assouplir explicitement cette règle. Two URLs share an origin if scheme + host + port are identical; a document can only read data (DOM, storage, responses) from its own origin. CORS is the server-side mechanism to explicitly relax that rule.

Stabilité : un onglet qui crashe n'emporte pas le navigateur. Sécurité : le renderer exécute du code non fiable sans accès direct au disque ni au réseau (tout passe par IPC vers le browser process), et la site isolation empêche deux origines de partager leur mémoire. Performance : vrai parallélisme. Stability: a crashing tab doesn't take the browser down. Security: the renderer runs untrusted code with no direct disk or network access (everything goes through IPC to the browser process), and site isolation keeps two origins from sharing memory. Performance: real parallelism.

Trois choses : partager la connaissance (personne n'est le seul à comprendre un module — assurance contre le bus factor), garantir la cohérence du codebase (patterns, conventions, gestion d'erreurs), et améliorer la conception grâce à une deuxième paire d'yeux (API, cas limites, tests, sécurité). Three things: sharing knowledge (nobody is the only one who understands a module — insurance against the bus factor), keeping the codebase consistent (patterns, conventions, error handling), and improving design through a second pair of eyes (API, edge cases, tests, security).

Parce que les linters et formatters (ESLint, Prettier, Black, clang-format) le vérifient automatiquement en CI, sans fatigue ni débat. Un humain qui commente l'indentation gaspille le temps de deux personnes ; si l'équipe débat du style en review, il manque un outil. Because linters and formatters (ESLint, Prettier, Black, clang-format) check it automatically in CI, without fatigue or debate. A human commenting on indentation wastes two people's time; if the team argues about style in review, a tool is missing.

Comprendre l'intention : lire le titre, la description et le ticket lié avant la première ligne de diff. Puis aller du général (l'approche est-elle la bonne ?) au particulier (logique ligne à ligne, cas limites, tests). Understand the intent: read the title, the description and the linked ticket before the first line of diff. Then go from general (is the approach right?) to specific (line-by-line logic, edge cases, tests).

Un format de commentaire de review `label: sujet` (conventionalcomments.org) qui lève l'ambiguïté sur la gravité : `blocking:` (à résoudre avant merge), `question:` (besoin d'une réponse), `suggestion:` (amélioration proposée), `nit:` (détail mineur, jamais bloquant), `praise:` (souligner ce qui est bien). A review comment format `label: subject` (conventionalcomments.org) that removes ambiguity about severity: `blocking:` (must be resolved before merge), `question:` (needs an answer), `suggestion:` (proposed improvement), `nit:` (minor detail, never blocking), `praise:` (highlighting what's good).

Parce que le reviewer n'a pas tout le contexte. « Que se passe-t-il si la liste est vide ? » ouvre une discussion et laisse la porte à « c'est garanti non vide en amont » ; « gère la liste vide » présuppose que le reviewer a raison et braque l'auteur. Because the reviewer doesn't have all the context. "What happens if the list is empty?" opens a discussion and leaves room for "it's guaranteed non-empty upstream"; "handle the empty list" assumes the reviewer is right and puts the author on the defensive.

L'attention du reviewer décroche avec la taille du diff (les études SmartBear situent le décrochage vers 400 lignes) : une grosse PR est survolée et approuvée d'un « LGTM » distrait. Petite PR = review profonde, feedback rapide, moins de conflits, revert facile. Une grosse feature se découpe en PR successives. Reviewer attention drops with diff size (the SmartBear studies place the drop-off around 400 lines): a big PR gets skimmed and approved with a distracted "LGTM". Small PR = deep review, fast feedback, fewer conflicts, easy revert. A big feature gets split into successive PRs.

1) Ce n'est pas personnel : on review le code, pas la personne. 2) Répondre à tout : chaque commentaire reçoit un fix, une réponse ou un ticket, jamais un silence. 3) Le désaccord s'argumente : « je garde cette approche parce que X » est légitime ; appliquer en silence un changement qu'on juge mauvais ne l'est pas. 1) It's not personal: the code is reviewed, not the person. 2) Respond to everything: each comment gets a fix, an answer or a ticket, never silence. 3) Disagreement comes with arguments: "I'm keeping this approach because X" is legitimate; silently applying a change you believe is wrong is not.

Relire son propre diff dans l'interface de PR avant de demander une review, comme si on était le reviewer : on attrape le console.log oublié, le fichier commité par erreur, le code mort. Avec une bonne description (quoi, pourquoi, comment tester), chaque minute d'auto-review économise un aller-retour de review, donc des heures de latence. Re-reading your own diff in the PR interface before requesting a review, as if you were the reviewer: you catch the forgotten console.log, the file committed by mistake, the dead code. With a good description (what, why, how to test), every minute of self-review saves a review round-trip, hence hours of latency.

Il prédit le token suivant : à partir du texte déjà présent, il produit une distribution de probabilités sur tout son vocabulaire, un token est tiré (sampling), ajouté au texte, et le processus recommence. Toute la génération est autorégressive. It predicts the next token: from the text so far, it produces a probability distribution over its whole vocabulary, one token is drawn (sampling), appended to the text, and the process repeats. All generation is autoregressive.

Un token est un fragment de texte fréquent (mot, morceau de mot, ponctuation) converti en entier par le tokenizer (BPE). Le modèle ne voit jamais les lettres : « strawberry » arrive en fragments comme `straw`+`berry`, donc compter les « r » demande une information qu'il n'a jamais observée directement. A token is a frequent text fragment (word, word piece, punctuation) converted to an integer by the tokenizer (BPE). The model never sees letters: "strawberry" arrives as fragments like `straw`+`berry`, so counting the "r"s requires information it never directly observed.

Un vecteur de nombres représentant un token (ou un texte) tel que la proximité géométrique entre vecteurs reflète la proximité de sens — « roi » et « reine » sont voisins dans cet espace. A vector of numbers representing a token (or a text) such that geometric closeness between vectors reflects closeness in meaning — "king" and "queen" are neighbors in that space.

À chaque couche, chaque token « regarde » tous les tokens précédents et pondère leur influence selon leur pertinence pour lui : dans « le chien dort parce qu'il est fatigué », « il » donne un poids fort à « chien ». C'est un contexte pondéré, calculé dynamiquement et en parallèle sur toute la séquence — ce qui a remplacé les RNN. At each layer, every token "looks at" all previous tokens and weights their influence by relevance to itself: in "the dog sleeps because it is tired", "it" gives a strong weight to "dog". It's a weighted context, computed dynamically and in parallel over the whole sequence — which is what replaced RNNs.

Pré-entraînement : prédire le token suivant sur des trillions de tokens → un base model qui complète du texte (99 % du coût). Fine-tuning (SFT) : apprendre le format instruction → réponse sur des dialogues choisis. RLHF : aligner sur les préférences humaines via un modèle de récompense entraîné sur des classements de réponses. Pre-training: predict the next token on trillions of tokens → a base model that completes text (99% of the cost). Fine-tuning (SFT): learn the instruction → answer format on curated dialogues. RLHF: align with human preferences via a reward model trained on ranked answers.

Ils contrôlent le sampling : la température aplatit (haut = créatif/aléatoire) ou accentue (0 = quasi déterministe, toujours le token le plus probable) la distribution ; le top-p restreint le tirage au noyau de tokens couvrant p % de probabilité, coupant la longue traîne absurde. They control sampling: temperature flattens (high = creative/random) or sharpens (0 = near deterministic, always the most probable token) the distribution; top-p restricts drawing to the nucleus of tokens covering p% of probability, cutting the absurd long tail.

La quantité maximale de tokens que le modèle peut traiter en un appel (system + historique + documents + réponse). Limites : tout est re-traité à chaque appel (coût, latence), l'API est stateless (rien n'est mémorisé entre appels), et le milieu d'un long contexte est mal exploité (« lost in the middle »). The maximum number of tokens the model can process in one call (system + history + documents + answer). Limits: everything is reprocessed on every call (cost, latency), the API is stateless (nothing is remembered between calls), and the middle of a long context is poorly exploited ("lost in the middle").

L'objectif d'entraînement récompense la plausibilité de la continuation, pas sa vérité : le modèle n'a ni base de faits ni mécanisme natif du « je ne sais pas ». Une référence inventée est souvent la suite la plus probable d'une question pointue. On atténue (RAG, outils, citations) mais on ne « corrige » pas. The training objective rewards the plausibility of the continuation, not its truth: the model has no fact database and no native "I don't know" mechanism. An invented reference is often the most probable continuation of a niche question. You mitigate (RAG, tools, citations) but you don't "fix" it.

Une représentation légère de l'UI sous forme d'objets JavaScript. À chaque changement d'état, React reconstruit cet arbre (peu coûteux), le compare à l'ancien (diffing) et n'applique au DOM réel — la partie lente — que les différences. Il rend le modèle déclaratif UI = f(state) viable sans re-render complet du DOM. A lightweight representation of the UI as JavaScript objects. On every state change, React rebuilds this tree (cheap), compares it to the old one (diffing) and applies only the differences to the real DOM — the slow part. It makes the declarative UI = f(state) model viable without a full DOM re-render.

Render : React appelle les composants et produit un nouveau Virtual DOM ; phase pure et interruptible (StrictMode la double en dev pour détecter les impuretés). Commit : React applique la liste minimale de mutations au DOM réel, de façon synchrone. Ensuite le navigateur paint, puis les useEffect s'exécutent. Render: React calls the components and produces a new Virtual DOM; a pure, interruptible phase (StrictMode double-renders in dev to detect impurities). Commit: React applies the minimal list of mutations to the real DOM, synchronously. Then the browser paints, then the useEffects run.

Deux règles : si le type d'un élément change à une position donnée, tout le sous-arbre est démonté et recréé (état local perdu) ; si le type est identique, React garde le nœud, met à jour les props modifiées et descend récursivement. Dans les listes, les keys complètent le diff en donnant une identité stable aux éléments. Two rules: if an element's type changes at a given position, the whole subtree is unmounted and recreated (local state lost); if the type is the same, React keeps the node, updates the changed props and recurses down. In lists, keys complete the diff by giving elements a stable identity.

Elles donnent une identité stable à chaque élément pour que la reconciliation détecte déplacements, insertions et suppressions au lieu de comparer position par position. React peut alors déplacer le nœud DOM en conservant son état (input, focus). Key correcte : un id stable issu des données, pas l'index. They give each element a stable identity so reconciliation can detect moves, insertions and deletions instead of comparing position by position. React can then move the DOM node while preserving its state (input, focus). Correct key: a stable id from the data, not the index.

Appeler les hooks uniquement au niveau supérieur du composant (jamais dans un if, une boucle, une fonction imbriquée) et uniquement depuis un composant React ou un hook custom. Raison : React associe chaque hook à sa valeur par ordre d'appel entre deux renders ; un hook conditionnel décale la liste et corrompt tout l'état. Call hooks only at the top level of the component (never in an if, a loop or a nested function) and only from a React component or a custom hook. Reason: React matches each hook to its value by call order between renders; a conditional hook shifts the list and corrupts all the state.

Les deps disent quand relancer l'effet : à chaque render si absentes, au montage seulement si [], quand une valeur listée change sinon — toute valeur réactive lue dans l'effet doit y figurer (sinon stale closure). Le cleanup retourné s'exécute avant chaque relance et au démontage : c'est là qu'on annule fetchs, timers et subscriptions. The deps say when to re-run the effect: every render if absent, only on mount if [], whenever a listed value changes otherwise — every reactive value read inside must be listed (else stale closure). The returned cleanup runs before each re-run and on unmount: that's where you cancel fetches, timers and subscriptions.

React compare l'ancienne et la nouvelle valeur avec Object.is : muter un objet ou un tableau garde la même référence, donc React ne voit aucun changement et ne re-rend pas. Il faut créer une nouvelle valeur : setItems([...items, x]), setUser({ ...user, name }). React compares old and new values with Object.is: mutating an object or array keeps the same reference, so React sees no change and doesn't re-render. You must create a new value: setItems([...items, x]), setUser({ ...user, name }).

Dans l'ordre : lifting state up (remonter l'état dans le parent commun, passé en props) couvre la plupart des cas ; Context pour une valeur globale et peu changeante (thème, utilisateur, langue) en sachant que chaque changement re-rend tous les consommateurs ; state manager (Redux Toolkit, Zustand) ou TanStack Query quand l'état global devient complexe ou vient du serveur. In order: lifting state up (move state into the common parent, passed as props) covers most cases; Context for a global, rarely changing value (theme, user, language), knowing every change re-renders all consumers; a state manager (Redux Toolkit, Zustand) or TanStack Query when global state gets complex or comes from the server.

Cache navigateur → cache OS → resolver récursif (FAI, 1.1.1.1…). S'il n'a rien en cache, il interroge : 1) la racine « . » qui indique les serveurs du TLD, 2) le TLD (.com) qui indique les serveurs autoritaires du domaine, 3) l'autoritaire qui donne l'enregistrement final. La réponse remonte et est mise en cache partout pour TTL secondes. Browser cache → OS cache → recursive resolver (ISP, 1.1.1.1…). If it has nothing cached, it queries: 1) the root "." which points to the TLD servers, 2) the TLD (.com) which points to the domain's authoritative servers, 3) the authoritative server which returns the final record. The answer flows back and is cached everywhere for TTL seconds.

Le récursif enquête pour le compte du client : il parcourt la hiérarchie (racine → TLD → autoritaire) et met les réponses en cache. L'autoritaire détient la vérité pour sa zone et répond directement, sans interroger personne. 8.8.8.8 est récursif ; les serveurs NS de votre domaine sont autoritaires. The recursive one investigates on the client's behalf: it walks the hierarchy (root → TLD → authoritative) and caches answers. The authoritative one holds the truth for its zone and answers directly, querying no one. 8.8.8.8 is recursive; your domain's NS servers are authoritative.

Le DNS ne pousse rien : après un changement, chaque cache sert l'ancienne valeur jusqu'à expiration de son TTL, puis va chercher la nouvelle. « Attendre la propagation » = attendre l'expiration des caches. D'où la pratique : baisser le TTL avant une migration, le remonter après. DNS pushes nothing: after a change, each cache serves the old value until its TTL expires, then fetches the new one. "Waiting for propagation" = waiting for cache expiration. Hence the practice: lower the TTL before a migration, raise it back afterwards.

A : nom → adresse IPv4. AAAA : nom → adresse IPv6. CNAME : alias d'un nom vers un autre nom, résolu ensuite (indirection supplémentaire). Un nom portant un CNAME ne peut porter aucun autre enregistrement, d'où l'impossibilité du CNAME à l'apex du domaine. A: name → IPv4 address. AAAA: name → IPv6 address. CNAME: alias from one name to another, resolved next (extra indirection). A name carrying a CNAME can carry no other record, hence CNAME being impossible at the domain apex.

MX : désigne les serveurs de mail du domaine, avec une priorité. TXT : texte libre — vérifications de propriété (Google, Let's Encrypt DNS-01) et anti-usurpation email (SPF, DKIM, DMARC). NS : délègue la zone à ses serveurs autoritaires. MX: designates the domain's mail servers, with a priority. TXT: free text — ownership verifications (Google, Let's Encrypt DNS-01) and email anti-spoofing (SPF, DKIM, DMARC). NS: delegates the zone to its authoritative servers.

`*.domaine.tld` attrape tous les sous-domaines non définis explicitement et les pointe vers une même cible (ex. un VPS). Combiné à un reverse proxy (Traefik, nginx), chaque nouvelle app = un nouveau sous-domaine sans toucher à la zone DNS : le pattern « un sous-domaine par app ». `*.domain.tld` catches every subdomain not explicitly defined and points them to one target (e.g. a VPS). Combined with a reverse proxy (Traefik, nginx), each new app = a new subdomain without touching the DNS zone: the "one subdomain per app" pattern.

`dig domaine` interroge votre resolver récursif, caches compris. `dig +trace` court-circuite les caches et rejoue toute la hiérarchie depuis la racine : NS de la racine → NS du TLD → réponse de l'autoritaire. Idéal pour vérifier ce que les serveurs autoritaires servent vraiment, indépendamment des caches. `dig domain` queries your recursive resolver, caches included. `dig +trace` bypasses the caches and replays the whole hierarchy from the root: root NS → TLD NS → authoritative answer. Ideal for checking what the authoritative servers really serve, independently of caches.

DNS-over-HTTPS et DNS-over-TLS : ils chiffrent les requêtes DNS entre le client et le resolver, alors que le DNS historique circule en clair sur le port 53, lisible (et modifiable) par tout intermédiaire sur le chemin. DNS-over-HTTPS and DNS-over-TLS: they encrypt DNS queries between the client and the resolver, whereas historical DNS travels in cleartext on port 53, readable (and modifiable) by any intermediary on the path.

Nvidia aurait accepté de racheter Hugging Face pour 12,9 milliards de dollars, presque le triple de sa dernière valorisation (4,5 Md$ en 2023). Nuance essentielle : aucun accord n'est signé, le deal peut encore capoter, et ni Nvidia ni Hugging Face n'ont commenté. Toute l'info repose sur une source anonyme « ayant une connaissance directe des discussions ». Nvidia reportedly agreed to acquire Hugging Face for $12.9 billion, almost triple its last valuation ($4.5B in 2023). Essential nuance: no agreement has been signed, the deal could still fall apart, and neither Nvidia nor Hugging Face commented. The whole story rests on an anonymous source 'with direct knowledge of the talks'.

Hugging Face doit sa position à sa neutralité : plus de 13 millions de développeurs y publient et consomment les modèles ouverts de Meta, Google, Mistral, Qwen ou DeepSeek. Racheté par le fournisseur dominant du compute, le hub poserait un problème de conflit d'intérêts : mise en avant des modèles optimisés CUDA, traitement des alternatives AMD ou des puces maison des clouds. C'est la question de la neutralité d'une infrastructure critique. Hugging Face owes its position to its neutrality: more than 13 million developers publish and consume open models from Meta, Google, Mistral, Qwen or DeepSeek there. Owned by the dominant compute supplier, the hub would raise a conflict of interest problem: promotion of CUDA-optimized models, treatment of AMD alternatives or the clouds' custom chips. It is the question of critical infrastructure neutrality.

Deux RCE non authentifiées : une faille dans libheif (utilisée par sharp pour optimiser les images AVIF, une image piégée suffit, l'optimisation AVIF est désactivée en attendant le correctif amont) et CVE-2026-75604 (RCE sur les serveurs Next.js hébergés sous Windows). Correctifs : 16.3.3 et 15.5.24. Leçon : la surface d'attaque inclut les dépendances transitives, ici Next.js utilise sharp qui utilise libheif. Two unauthenticated RCEs: a flaw in libheif (used by sharp for AVIF image optimization, one crafted image is enough, AVIF optimization is disabled until the upstream fix) and CVE-2026-75604 (RCE on Windows-hosted Next.js servers). Fixes: 16.3.3 and 15.5.24. Lesson: the attack surface includes transitive dependencies, here Next.js uses sharp which uses libheif.

La fin du micro-étiquetage de masse. Lancée en 2005, la place de marché d'Amazon (plus de 500 000 workers au pic, surnommée « artificial artificial intelligence » par Bezos) a étiqueté les datasets de l'ère du machine learning. Les modèles font désormais ces tâches simples, et le travail humain s'est déplacé vers l'annotation experte, l'évaluation de réponses et le RLHF, chez Scale AI, Mercor ou Prolific. Amazon ferme aussi SageMaker Ground Truth et Augmented AI. The end of mass micro-labeling. Launched in 2005, Amazon's marketplace (over 500,000 workers at its peak, dubbed 'artificial artificial intelligence' by Bezos) labeled the datasets of the machine learning era. Models now handle those simple tasks, and human work moved to expert annotation, answer evaluation and RLHF, at Scale AI, Mercor or Prolific. Amazon is also closing SageMaker Ground Truth and Augmented AI.

Ne jamais faire confiance à l'entrée utilisateur : toute donnée venant du client (paramètres, body, headers, cookies) est potentiellement hostile et doit être validée côté serveur. La validation front n'est que de l'UX, contournable avec curl ou les DevTools. Never trust user input: any data from the client (parameters, body, headers, cookies) is potentially hostile and must be validated server-side. Front-end validation is just UX, bypassable with curl or DevTools.

L'entrée utilisateur concaténée dans la requête est interprétée comme du code SQL (ex. ' OR '1'='1' -- rend la condition toujours vraie). Parade : les requêtes préparées — la requête part figée, les valeurs sont transmises séparément et ne sont jamais interprétées. L'échappement manuel n'est pas fiable. User input concatenated into the query is interpreted as SQL code (e.g. ' OR '1'='1' -- makes the condition always true). Countermeasure: prepared statements — the query is sent frozen, values travel separately and are never interpreted. Manual escaping is not reliable.

Insecure Direct Object Reference : changer un identifiant dans l'URL (/invoices/1042 → 1043) donne accès à la ressource d'un autre utilisateur. C'est du broken access control (A01) : l'authentification est vérifiée mais pas l'autorisation. Parade : vérifier à chaque requête que la ressource appartient à l'utilisateur courant. Insecure Direct Object Reference: changing an identifier in the URL (/invoices/1042 → 1043) grants access to another user's resource. It's broken access control (A01): authentication is checked but not authorization. Defense: on every request, verify the resource belongs to the current user.

Authentification : prouver qui vous êtes (login, session, token). Autorisation : vérifier ce à quoi vous avez droit (cette facture est-elle à vous ?). L'IDOR est l'exemple type d'une autorisation oubliée alors que l'authentification est en place. Authentication: proving who you are (login, session, token). Authorization: checking what you're entitled to (is this invoice yours?). IDOR is the textbook example of authorization forgotten while authentication is in place.

L'injection côté client : du contenu utilisateur rendu comme HTML/JS s'exécute dans le navigateur des autres utilisateurs (vol de session, actions à leur insu). Parades : échapper à l'affichage (défaut de React/Vue — ne pas contourner avec innerHTML/dangerouslySetInnerHTML sur de la donnée utilisateur) et une Content Security Policy en défense en profondeur. Client-side injection: user content rendered as HTML/JS executes in other users' browsers (session theft, actions on their behalf). Defenses: escape on output (React/Vue default — don't bypass with innerHTML/dangerouslySetInnerHTML on user data) and a Content Security Policy as defense in depth.

Server-Side Request Forgery : l'attaquant fait faire au serveur une requête vers une cible que lui seul peut atteindre — services internes, localhost, métadonnées cloud (169.254.169.254, credentials AWS). Parade : allowlist de destinations et blocage des plages IP privées. Server-Side Request Forgery: the attacker makes the server issue a request to a target only the server can reach — internal services, localhost, cloud metadata (169.254.169.254, AWS credentials). Defense: destination allowlist and blocking private IP ranges.

Les hasher (jamais les chiffrer, jamais en clair) avec un algorithme lent par conception : bcrypt ou argon2, avec sel. MD5 et SHA1 sont proscrits car trop rapides (brute force facile). Un hash est irréversible : on ne « décrypte » pas un mot de passe, on compare des hashes. Hash them (never encrypt, never cleartext) with an algorithm slow by design: bcrypt or argon2, with a salt. MD5 and SHA1 are banned because they're too fast (easy brute force). A hash is irreversible: you don't "decrypt" a password, you compare hashes.

Credentials par défaut sur une console d'admin ; stack traces détaillées renvoyées au client en production ; ports/services de debug exposés ; bucket S3 public ; CORS trop permissif. Parade générale : durcir les défauts, fermer ce qui n'est pas utilisé, headers de sécurité. Default credentials on an admin console; detailed stack traces returned to the client in production; exposed debug ports/services; public S3 bucket; overly permissive CORS. General defense: harden defaults, close what isn't used, security headers.

Le B-tree est un arbre équilibré à nœuds très larges : une page de 8 Ko contient des centaines de clés, donc l'arbre a une hauteur de 3-4 même pour des millions de lignes. Une recherche descend simplement l'arbre nœud par nœud au lieu de lire toute la table (O(n)). A B-tree is a balanced tree with very wide nodes: an 8 KB page holds hundreds of keys, so the tree is only 3-4 levels tall even for millions of rows. A lookup just walks down the tree node by node instead of reading the whole table (O(n)).

Un index sur (a, b) est trié par a puis b, comme un annuaire (nom, prénom). Il sert pour les requêtes filtrant sur a, ou sur a et b — mais pas sur b seul : sans le préfixe gauche, l'ordre de tri de l'index est inutilisable. An index on (a, b) is sorted by a then b, like a phone book (last name, first name). It serves queries filtering on a, or on a and b — but not on b alone: without the left prefix, the index's sort order is unusable.

Un index qui contient toutes les colonnes demandées par la requête (clause INCLUDE en PostgreSQL). La base répond en lisant uniquement l'index, sans jamais toucher la table : c'est l'Index Only Scan, le scan le plus rapide. An index containing every column the query asks for (INCLUDE clause in PostgreSQL). The database answers by reading only the index, never touching the table: that's the Index Only Scan, the fastest scan there is.

1) Une fonction appliquée à la colonne (WHERE lower(email) = …) sans index fonctionnel. 2) LIKE '%terme' : pas de préfixe fixe, l'arbre trié ne sert à rien. 3) Faible sélectivité (booléen à 50/50) : le planner préfère lire la table. Aussi : types incompatibles, statistiques périmées. 1) A function applied to the column (WHERE lower(email) = …) without a functional index. 2) LIKE '%term': no fixed prefix, the sorted tree is useless. 3) Low selectivity (a 50/50 boolean): the planner prefers reading the table. Also: incompatible types, stale statistics.

Chaque INSERT/UPDATE/DELETE doit mettre à jour tous les index de la table : les écritures ralentissent, les pages se scindent, l'index se fragmente, et chaque index consomme disque et cache. Un index jamais interrogé est une taxe pure. Every INSERT/UPDATE/DELETE must update all the table's indexes: writes slow down, pages split, the index fragments, and each index consumes disk and cache. An index nobody queries is a pure tax.

EXPLAIN montre le plan choisi par le planner avec des coûts estimés, sans exécuter. EXPLAIN ANALYZE exécute réellement la requête et ajoute temps et nombres de lignes réels. L'écart estimé/réel révèle des statistiques périmées. Attention : ANALYZE exécute vraiment un UPDATE/DELETE (→ BEGIN/ROLLBACK). EXPLAIN shows the planner's chosen plan with estimated costs, without executing. EXPLAIN ANALYZE actually runs the query and adds real times and row counts. The estimated/actual gap reveals stale statistics. Careful: ANALYZE really executes an UPDATE/DELETE (→ BEGIN/ROLLBACK).

1NF : valeurs atomiques, pas de listes dans une colonne. 2NF : aucune colonne ne dépend d'une partie seulement d'une clé composite. 3NF : aucune dépendance transitive — une colonne non-clé ne dépend pas d'une autre colonne non-clé (ex. customer_city stockée dans orders). 1NF: atomic values, no lists inside a column. 2NF: no column depends on only part of a composite key. 3NF: no transitive dependency — a non-key column doesn't depend on another non-key column (e.g. customer_city stored in orders).

1 requête charge N lignes (100 commandes), puis 1 requête part pour chaque ligne (100 clients) : N+1 allers-retours au lieu de 2. Classique avec les ORM et le lazy loading. Correction : un JOIN ou l'eager loading (select_related, includes, JOIN FETCH). Détection : les logs SQL. 1 query loads N rows (100 orders), then 1 query fires for each row (100 customers): N+1 round trips instead of 2. Classic with ORMs and lazy loading. Fix: a JOIN or eager loading (select_related, includes, JOIN FETCH). Detection: SQL logs.

Les opérations lentes (réseau, timers, disque) sont déléguées à l'environnement (Web APIs du navigateur, libuv en Node) qui travaille en coulisses. À la fin, le callback est mis en file d'attente et l'event loop l'exécute quand la call stack est vide. Le thread JS ne fait qu'entrelacer du code court. Slow operations (network, timers, disk) are delegated to the environment (browser Web APIs, libuv in Node) working behind the scenes. On completion, the callback is queued and the event loop runs it when the call stack is empty. The JS thread only interleaves short pieces of code.

1) Exécuter le code synchrone jusqu'à vider la call stack. 2) Vider ENTIÈREMENT la file des microtasks (promises, await), y compris celles créées en route. 3) Prendre UNE macrotask (setTimeout, I/O, événement). 4) Recommencer. 1) Run synchronous code until the call stack is empty. 2) Drain the microtask queue ENTIRELY (promises, await), including microtasks created along the way. 3) Take ONE macrotask (setTimeout, I/O, event). 4) Repeat.

fn devient une macrotask : elle attend la fin de tout le code synchrone en cours ET le vidage complet des microtasks. Le délai passé à setTimeout est un minimum avant mise en file, jamais une garantie d'exécution à l'heure dite. fn becomes a macrotask: it waits for all current synchronous code to finish AND the microtask queue to fully drain. The delay passed to setTimeout is a minimum before queueing, never a guarantee of on-time execution.