[
  {
    "slug": "dev-web",
    "name": "Développement Web",
    "emoji": "🌐",
    "order": 1,
    "chapters": [
      {
        "slug": "fondements",
        "name": "Fondements du Web",
        "emoji": "🌐",
        "order": 1,
        "cards": [
          {
            "term": "Internet",
            "definition": "Réseau informatique mondial, « réseau de réseaux », qui permet l'échange d'informations entre machines distantes. Internet est l'infrastructure sur laquelle s'appuient de nombreux services.",
            "example": null
          },
          {
            "term": "Web (WWW)",
            "definition": "Une application d'Internet : un ensemble de documents reliés entre eux par des liens hypertextes. Internet est l'infrastructure, le Web est un service qui l'utilise.",
            "example": null
          },
          {
            "term": "Client",
            "definition": "Programme (souvent un navigateur) qui initie la communication en envoyant une requête. Le client parle toujours en premier.",
            "example": null
          },
          {
            "term": "Serveur",
            "definition": "Programme à l'écoute des requêtes : il les reçoit, les traite et renvoie une réponse.",
            "example": null
          },
          {
            "term": "Persistance",
            "definition": "Capacité à stocker et retrouver des données de manière durable.",
            "example": null
          },
          {
            "term": "SGBD",
            "definition": "Système de Gestion de Base de Données : logiciel qui stocke, organise et sécurise les données.",
            "example": null
          },
          {
            "term": "Base relationnelle (SQL)",
            "definition": "Modèle de stockage structuré en tables reliées par des relations explicites (MySQL, PostgreSQL, SQLite…).",
            "example": null
          },
          {
            "term": "NoSQL",
            "definition": "« Not Only SQL » : autres modèles de stockage que le relationnel (documents, clé–valeur, colonnes, indexation), par exemple MongoDB ou Redis.",
            "example": null
          },
          {
            "term": "Architecture 3-tiers",
            "definition": "Organisation d'une application en trois couches : Présentation ↔ Métier ↔ Données.",
            "example": null
          },
          {
            "term": "Protocole",
            "definition": "Langage de communication normalisé entre machines.",
            "example": null
          },
          {
            "term": "TCP / UDP",
            "definition": "Protocoles bas niveau de transmission : TCP assure une transmission fiable ; UDP est plus rapide mais tolérant à la perte de données.",
            "example": null
          },
          {
            "term": "HTTP / HTTPS",
            "definition": "Protocoles applicatifs d'échange du Web. HTTPS est la version chiffrée qui sécurise les échanges.",
            "example": null
          },
          {
            "term": "Langages côté client / côté serveur",
            "definition": "Côté client (navigateur) : HTML, CSS, JavaScript. Côté serveur : PHP, Java, Python, C#, Ruby… Le navigateur n'exécute jamais le code serveur, il n'en reçoit que le résultat.",
            "example": null
          }
        ]
      },
      {
        "slug": "html",
        "name": "HTML — Structure sémantique",
        "emoji": "📄",
        "order": 2,
        "cards": [
          {
            "term": "HTML",
            "definition": "HyperText Markup Language : langage de balisage qui structure le contenu d'un document web. Ce n'est pas un langage de programmation.",
            "example": null
          },
          {
            "term": "Balise (tag)",
            "definition": "Marque indiquant la nature et le rôle sémantique d'un contenu.",
            "example": null
          },
          {
            "term": "Balise en paire",
            "definition": "Balise possédant une partie ouvrante et une partie fermante entourant un contenu.",
            "example": "<p>...</p>"
          },
          {
            "term": "Balise orpheline / vide",
            "definition": "Balise sans contenu ni fermeture, qui se suffit à elle-même.",
            "example": "<br>, <img>"
          },
          {
            "term": "Attribut",
            "definition": "Information complémentaire ajoutée à une balise, toujours écrite entre guillemets.",
            "example": "<img src=\"...\" alt=\"...\">"
          },
          {
            "term": "DOCTYPE",
            "definition": "Déclaration en tête de document indiquant au navigateur quelles règles appliquer. En HTML5, elle est minimale.",
            "example": "<!DOCTYPE html>"
          },
          {
            "term": "Métadonnées",
            "definition": "Informations non visibles mais essentielles à la page : encodage des caractères, langue, viewport.",
            "example": "<meta charset=\"utf-8\">"
          },
          {
            "term": "Sémantique",
            "definition": "Utiliser des balises qui décrivent le rôle du contenu (header, nav, main, article, footer…) plutôt que de simples conteneurs neutres.",
            "example": null
          },
          {
            "term": "W3C",
            "definition": "World Wide Web Consortium : organisme qui définit les standards du web.",
            "example": null
          },
          {
            "term": "Validateur W3C",
            "definition": "Outil en ligne qui vérifie la conformité du code HTML aux standards (validator.w3.org).",
            "example": null
          },
          {
            "term": "Structure minimale d'une page HTML5",
            "definition": "Squelette de base d'un document : déclaration DOCTYPE, élément html avec sa langue, une section head (métadonnées, titre, liens) et une section body (contenu visible).",
            "example": "<!DOCTYPE html>\n<html lang=\"fr\">\n<head>\n  <meta charset=\"utf-8\">\n  <title>Titre</title>\n</head>\n<body></body>\n</html>"
          },
          {
            "term": "Imbrication stricte",
            "definition": "Règle voulant qu'une balise ouverte soit fermée avant sa balise parente ; les balises ne doivent jamais se chevaucher.",
            "example": null
          },
          {
            "term": "Balises sémantiques principales",
            "definition": "Éléments décrivant le rôle d'une zone de page : header (en-tête), nav (navigation), main (contenu principal unique), section (section thématique), article (contenu autonome), aside (contenu complémentaire), footer (pied de page).",
            "example": null
          },
          {
            "term": "div",
            "definition": "Conteneur générique sans aucune signification sémantique, à n'utiliser qu'en dernier recours quand aucune balise sémantique ne convient.",
            "example": null
          },
          {
            "term": "Titres h1 à h6",
            "definition": "Balises définissant la hiérarchie des titres de la page, de h1 (le plus important) à h6. On ne met qu'un seul h1 par page.",
            "example": null
          },
          {
            "term": "Attribut alt",
            "definition": "Texte alternatif obligatoire sur une image, décrivant son contenu pour l'accessibilité et en cas de non-affichage.",
            "example": "<img src=\"chat.png\" alt=\"Un chat\">"
          },
          {
            "term": "rel=\"noopener\"",
            "definition": "Attribut à ajouter sur un lien ouvrant un nouvel onglet (target=\"_blank\") pour des raisons de sécurité.",
            "example": "<a href=\"...\" target=\"_blank\" rel=\"noopener\">"
          },
          {
            "term": "Script avec defer",
            "definition": "Le script est placé dans le head avec l'attribut defer, ce qui en diffère l'exécution après le chargement du DOM ; pratique recommandée plutôt que de placer le script en fin de body.",
            "example": "<script src=\"main.js\" defer></script>"
          },
          {
            "term": "Formulaire HTML",
            "definition": "Élément form (avec action et method) regroupant des champs de saisie (label, input, textarea) et un bouton d'envoi pour transmettre des données.",
            "example": "<form method=\"post\">\n  <label for=\"e\">Email</label>\n  <input type=\"email\" id=\"e\" required>\n</form>"
          },
          {
            "term": "Validation HTML native",
            "definition": "Contrôles de saisie fournis par le navigateur (champ required, type email…). Utile pour l'expérience utilisateur, mais ne remplace jamais une validation côté serveur.",
            "example": null
          },
          {
            "term": "DOM",
            "definition": "Document Object Model : représentation interne de la page construite en mémoire par le navigateur. L'inspecteur affiche ce DOM réel, qui peut différer de la source HTML.",
            "example": null
          }
        ]
      },
      {
        "slug": "css",
        "name": "CSS — Mise en forme & layout",
        "emoji": "🎨",
        "order": 3,
        "cards": [
          {
            "term": "CSS",
            "definition": "Cascading Style Sheets : langage de présentation qui met en forme un document HTML.",
            "example": null
          },
          {
            "term": "Sélecteur",
            "definition": "Partie d'une règle CSS qui cible les éléments à styler (élément, classe, id, combinaison).",
            "example": ".section-title { ... }"
          },
          {
            "term": "Déclaration",
            "definition": "Couple propriété: valeur formant l'instruction de style appliquée par une règle.",
            "example": "color: blue;"
          },
          {
            "term": "Cascade",
            "definition": "Mécanisme qui détermine quelle règle s'applique en cas de conflit, en tenant compte de l'ordre, de la spécificité et de !important.",
            "example": null
          },
          {
            "term": "Héritage",
            "definition": "Transmission de certaines propriétés du parent à l'enfant (couleur, police) ; d'autres ne sont pas héritées (margin, padding, border).",
            "example": null
          },
          {
            "term": "Spécificité",
            "definition": "Poids d'un sélecteur qui décide quelle règle l'emporte. Hiérarchie : type < classe < id < style inline. On la calcule comme un triplet (a, b, c) : a = nombre d'ID, b = nombre de classes/attributs/pseudo-classes, c = nombre d'éléments/pseudo-éléments, comparé de gauche à droite.",
            "example": "p → (0,0,1) ; .nav a → (0,1,1) ; #header a → (1,0,1)"
          },
          {
            "term": "!important",
            "definition": "Marqueur qui force une déclaration à l'emporter sur tout le reste, sauf un autre !important. À réserver à des cas exceptionnels car il masque le vrai problème de spécificité.",
            "example": null
          },
          {
            "term": "Box model",
            "definition": "Modèle de la boîte décrivant un élément en quatre couches : content + padding + border + margin.",
            "example": null
          },
          {
            "term": "box-sizing",
            "definition": "Propriété définissant ce qui est inclus dans width/height. La valeur border-box inclut le padding et la bordure dans la largeur, ce qui facilite les calculs.",
            "example": "*, *::before, *::after { box-sizing: border-box; }"
          },
          {
            "term": "Flux normal",
            "definition": "Disposition par défaut des éléments : les blocs s'empilent verticalement, les éléments inline s'enchaînent dans le texte.",
            "example": null
          },
          {
            "term": "display",
            "definition": "Propriété définissant le mode d'affichage d'un élément : block (largeur 100 %, saut de ligne), inline (dans le texte, width/height ignorés), inline-block (inline respectant width/height), none (retiré du flux), flex / grid (modèles avancés).",
            "example": null
          },
          {
            "term": "Flexbox",
            "definition": "Modèle de mise en page (display: flex) qui aligne et répartit les éléments selon un axe principal et un axe secondaire.",
            "example": ".layout { display: flex; gap: 1rem; }"
          },
          {
            "term": "flex-direction",
            "definition": "Propriété Flexbox du conteneur définissant le sens de l'axe principal : row (défaut), column, row-reverse ou column-reverse.",
            "example": null
          },
          {
            "term": "justify-content",
            "definition": "Propriété Flexbox alignant les éléments sur l'axe principal : flex-start, center, flex-end, space-between, space-around, space-evenly.",
            "example": null
          },
          {
            "term": "align-items",
            "definition": "Propriété Flexbox alignant les éléments sur l'axe secondaire : stretch (défaut), flex-start, center, flex-end, baseline.",
            "example": null
          },
          {
            "term": "flex (sur l'item)",
            "definition": "Propriété d'un enfant flex définissant comment il occupe l'espace. flex: 1 est un raccourci de flex-grow:1; flex-shrink:1; flex-basis:0 ; un enfant flex: 2 prend deux fois plus de place qu'un flex: 1 voisin.",
            "example": ".main { flex: 2; } .aside { flex: 1; }"
          },
          {
            "term": "gap",
            "definition": "Propriété définissant l'espace entre les enfants d'un conteneur flex (ou grid).",
            "example": "gap: 1.5rem;"
          },
          {
            "term": "Centrage avec Flexbox",
            "definition": "Pour centrer parfaitement un élément, on combine sur le conteneur flex justify-content: center (axe principal) et align-items: center (axe secondaire).",
            "example": ".parent { display: flex; justify-content: center; align-items: center; }"
          },
          {
            "term": "Media query",
            "definition": "Règle CSS conditionnelle (@media) qui applique des styles selon le contexte : largeur, orientation, type d'écran…",
            "example": "@media (min-width: 768px) { .layout { flex-direction: row; } }"
          },
          {
            "term": "Responsive design",
            "definition": "Approche consistant à adapter la présentation d'une page à la taille de l'écran.",
            "example": null
          },
          {
            "term": "Mobile-first",
            "definition": "Stratégie partant d'une base pensée pour le mobile, enrichie progressivement pour les grands écrans à l'aide de media queries en min-width.",
            "example": null
          },
          {
            "term": "Pseudo-élément",
            "definition": "Élément virtuel créé en CSS (::before, ::after), qui n'existe pas dans le HTML mais peut être stylé.",
            "example": "a::after { content: \"↗\"; }"
          },
          {
            "term": "Unités CSS",
            "definition": "Mesures de tailles : px (absolue, précise), % (relative au parent), rem (relative à la racine, scalable pour typo et espacements), vw/vh (relatives au viewport, 1vw = 1 % de la largeur d'écran).",
            "example": "max-width: 60rem;"
          },
          {
            "term": "Sélecteurs combinés",
            "definition": "Façons de cibler des éléments selon leur relation : descendant (espace), enfant direct (>), frère adjacent (+), frères suivants (~), cumul de conditions (sans espace) et sélecteur universel (*).",
            "example": "p span {} ; .blue > span {} ; h2 + p {} ; h2 ~ p {}"
          }
        ]
      },
      {
        "slug": "js-bases",
        "name": "JavaScript — Bases du langage",
        "emoji": "⚡",
        "order": 4,
        "cards": [
          {
            "term": "JavaScript",
            "definition": "Langage interprété côté client (navigateur) qui apporte de la logique et de l'interactivité aux pages web. Aucun lien technique avec Java (seulement historique).",
            "example": null
          },
          {
            "term": "ECMAScript",
            "definition": "Standard officiel qui définit le langage JavaScript.",
            "example": null
          },
          {
            "term": "Moteur JavaScript",
            "definition": "Programme qui exécute le code JS. Exemples : V8 (Chrome/Edge), SpiderMonkey (Firefox), JavaScriptCore (Safari).",
            "example": null
          },
          {
            "term": "Runtime",
            "definition": "Environnement d'exécution du JavaScript : le moteur plus les APIs du navigateur (DOM, événements, timers, réseau…).",
            "example": null
          },
          {
            "term": "Variable",
            "definition": "Espace nommé en mémoire contenant une valeur. Déclarée avec const (par défaut) ou let si la valeur doit changer.",
            "example": "let age = 20; const name = \"Alice\";"
          },
          {
            "term": "Typage dynamique",
            "definition": "Le type d'une variable est déterminé à l'exécution et non à la déclaration ; il peut donc changer au cours du programme.",
            "example": null
          },
          {
            "term": "Types primitifs",
            "definition": "Types de base de JavaScript : number, string, boolean, null et undefined.",
            "example": null
          },
          {
            "term": "Fonction",
            "definition": "Bloc nommé qui reçoit des paramètres, exécute un traitement et peut retourner une valeur. Idéalement une seule responsabilité, un nom explicite et peu d'effets de bord.",
            "example": "function add(a, b) { return a + b; }"
          },
          {
            "term": "Arrow function (fonction fléchée)",
            "definition": "Syntaxe moderne et compacte de fonction, avec return implicite si une seule expression. Elle n'a pas son propre this (elle hérite du this parent), ce qui est très utile dans les callbacks.",
            "example": "const add = (a, b) => a + b;"
          },
          {
            "term": "Objet littéral",
            "definition": "Structure { clé: valeur, … } regroupant des données et des comportements (méthodes).",
            "example": "const user = { name: \"Alice\", greet() {} };"
          },
          {
            "term": "this",
            "definition": "Référence à l'objet courant dans une méthode. Une fonction classique a son propre this ; une arrow function hérite du this du contexte parent.",
            "example": "greet() { console.log(this.name); }"
          },
          {
            "term": "Module",
            "definition": "Fichier JS isolé qui exporte et importe ses éléments, permettant de structurer le code. Chargé via <script type=\"module\">.",
            "example": "import { greet } from \"./utils.js\";"
          },
          {
            "term": "Sensibilité à la casse",
            "definition": "JavaScript distingue les majuscules des minuscules : age et Age sont deux identifiants différents.",
            "example": null
          },
          {
            "term": "Template literal",
            "definition": "Chaîne délimitée par des accents graves permettant l'interpolation avec ${...} et l'écriture multiligne.",
            "example": "`Bonjour ${name}`"
          },
          {
            "term": "Destructuring (déstructuration)",
            "definition": "Syntaxe ES6 qui extrait des valeurs d'un objet ou d'un tableau vers des variables nommées.",
            "example": "const { name, age } = user;"
          },
          {
            "term": "Spread / Rest (...)",
            "definition": "L'opérateur spread étale un tableau ou un objet (clone, fusion) ; en paramètre de fonction (rest) il regroupe N arguments dans un tableau.",
            "example": "const arr2 = [...arr1, 4, 5];"
          },
          {
            "term": "Optional chaining (?.)",
            "definition": "Opérateur qui accède à une propriété imbriquée sans erreur : renvoie undefined si un maillon de la chaîne est null ou undefined.",
            "example": "user?.address?.city"
          },
          {
            "term": "Nullish coalescing (??)",
            "definition": "Opérateur qui retourne l'opérande de droite uniquement si celui de gauche est null ou undefined.",
            "example": "const v = input ?? \"défaut\";"
          },
          {
            "term": "Shorthand properties",
            "definition": "Raccourci d'objet permettant d'écrire { x } au lieu de { x: x } quand la clé porte le même nom que la variable.",
            "example": "const point = { x, y };"
          },
          {
            "term": "map",
            "definition": "Méthode de tableau qui transforme chaque élément et retourne un nouveau tableau (sans modifier l'original).",
            "example": "nums.map(n => n * 2);"
          },
          {
            "term": "filter",
            "definition": "Méthode de tableau qui retourne un nouveau tableau contenant seulement les éléments passant un test.",
            "example": "nums.filter(n => n % 2 === 0);"
          },
          {
            "term": "find",
            "definition": "Méthode de tableau qui retourne le premier élément satisfaisant la condition de test.",
            "example": "nums.find(n => n > 3);"
          },
          {
            "term": "reduce",
            "definition": "Méthode de tableau qui accumule les éléments en une seule valeur via une fonction et un accumulateur.",
            "example": "nums.reduce((acc, n) => acc + n, 0);"
          },
          {
            "term": "forEach",
            "definition": "Méthode de tableau qui exécute une fonction pour chaque élément, sans retourner de nouveau tableau.",
            "example": "nums.forEach(n => console.log(n));"
          },
          {
            "term": "some / every",
            "definition": "Méthodes de tableau renvoyant un booléen : some teste si au moins un élément passe le test, every si tous le passent.",
            "example": "nums.some(n => n > 4);"
          },
          {
            "term": "console.log",
            "definition": "Méthode d'affichage dans la console du navigateur, utilisée pour le débogage. console.error affiche un message d'erreur.",
            "example": "console.log(\"Message\");"
          },
          {
            "term": "alert / confirm / prompt",
            "definition": "Fonctions d'interaction synchrones et bloquantes du navigateur (message, confirmation, saisie). Utilisées surtout pédagogiquement.",
            "example": "prompt(\"Entrez votre nom\");"
          }
        ]
      },
      {
        "slug": "js-dom-events",
        "name": "JavaScript — DOM & Événements",
        "emoji": "🖱️",
        "order": 5,
        "cards": [
          {
            "term": "Prototype",
            "definition": "Objet servant de modèle à un autre objet. En JavaScript, un objet est créé à partir d'un autre objet (modèle historique), et non d'une classe.",
            "example": "const chien = Object.create(animal);"
          },
          {
            "term": "Chaîne de prototypes",
            "definition": "Suite d'objets parcourue pour rechercher une propriété ou une méthode : objet → son prototype → prototype du prototype → … → null.",
            "example": null
          },
          {
            "term": "DOM (Document Object Model)",
            "definition": "Représentation interne, sous forme d'arbre d'objets, de la page HTML que le navigateur construit en mémoire. JavaScript modifie cette représentation, pas le fichier HTML.",
            "example": null
          },
          {
            "term": "Nœud",
            "definition": "Élément de l'arbre DOM : chaque balise HTML correspond à un nœud.",
            "example": null
          },
          {
            "term": "window",
            "definition": "Objet global du navigateur représentant la fenêtre.",
            "example": null
          },
          {
            "term": "document",
            "definition": "Objet représentant le document HTML chargé, point d'entrée pour manipuler le DOM.",
            "example": null
          },
          {
            "term": "NodeList",
            "definition": "Liste d'éléments renvoyée par querySelectorAll.",
            "example": "document.querySelectorAll(\".classe\");"
          },
          {
            "term": "HTMLCollection",
            "definition": "Liste d'éléments renvoyée par getElementsByClassName ou getElementsByTagName.",
            "example": null
          },
          {
            "term": "Référence DOM",
            "definition": "Variable JS pointant vers un objet DOM (et non vers son texte ou son contenu).",
            "example": "const p = document.querySelector(\"p\");"
          },
          {
            "term": "getElementById",
            "definition": "Méthode de sélection qui retourne l'unique élément portant l'id donné. Très rapide.",
            "example": "document.getElementById(\"id\");"
          },
          {
            "term": "querySelector / querySelectorAll",
            "definition": "Méthodes modernes de sélection par sélecteur CSS : querySelector retourne le premier élément, querySelectorAll retourne une NodeList.",
            "example": "document.querySelector(\"#id\");"
          },
          {
            "term": "textContent",
            "definition": "Propriété pour lire ou définir le contenu textuel d'un élément (sans interprétation HTML).",
            "example": "element.textContent = \"Nouveau texte\";"
          },
          {
            "term": "innerHTML",
            "definition": "Propriété qui lit ou définit le contenu HTML d'un élément. À risque d'attaque XSS si on y insère des données utilisateur.",
            "example": "element.innerHTML = \"<strong>HTML</strong>\";"
          },
          {
            "term": "classList",
            "definition": "Propriété permettant d'ajouter, retirer ou tester des classes CSS sur un élément (à préférer aux styles inline).",
            "example": "element.classList.add(\"active\");"
          },
          {
            "term": "setAttribute / getAttribute",
            "definition": "Méthodes pour définir ou lire la valeur d'un attribut HTML d'un élément.",
            "example": "img.setAttribute(\"src\", \"img/new.png\");"
          },
          {
            "term": "createElement",
            "definition": "Méthode du document qui crée un nouvel élément DOM, ensuite inséré dans l'arbre (appendChild, append, prepend…).",
            "example": "const li = document.createElement(\"li\");"
          },
          {
            "term": "appendChild / append / prepend",
            "definition": "Méthodes d'insertion d'un élément dans le DOM : appendChild et append ajoutent à la fin, prepend au début.",
            "example": "liste.appendChild(li);"
          },
          {
            "term": "remove",
            "definition": "Méthode supprimant un élément du DOM.",
            "example": "li.remove();"
          },
          {
            "term": "Événement",
            "definition": "Signal envoyé par le navigateur quand une action se produit (clic, saisie, chargement…).",
            "example": null
          },
          {
            "term": "addEventListener",
            "definition": "Méthode qui attache un écouteur à un élément pour réagir à un événement. À préférer à l'attribut onclick car elle respecte la séparation HTML/JS.",
            "example": "button.addEventListener('click', handler);"
          },
          {
            "term": "Callback",
            "definition": "Fonction passée à addEventListener, exécutée quand l'événement survient. Une fonction nommée est plus lisible et réutilisable qu'une anonyme.",
            "example": null
          },
          {
            "term": "Objet event",
            "definition": "Objet automatiquement fourni au callback, contenant toutes les informations sur l'événement (type, cible, etc.).",
            "example": "function (event) { console.log(event.type); }"
          },
          {
            "term": "target",
            "definition": "Propriété de l'objet event désignant l'élément exact sur lequel l'action a réellement eu lieu.",
            "example": "event.target"
          },
          {
            "term": "currentTarget",
            "definition": "Propriété de l'objet event désignant l'élément sur lequel l'écouteur est attaché (qui peut différer de target lors d'un clic sur un enfant).",
            "example": "event.currentTarget"
          },
          {
            "term": "data-* / dataset",
            "definition": "Attributs HTML personnalisés data-* accessibles en JavaScript via la propriété dataset (data-index devient dataset.index).",
            "example": "event.target.dataset.index"
          },
          {
            "term": "Comportement par défaut",
            "definition": "Action automatique déclenchée par le navigateur lors d'un événement (un submit recharge la page, un lien navigue…).",
            "example": null
          },
          {
            "term": "preventDefault",
            "definition": "Méthode de l'objet event qui bloque le comportement par défaut du navigateur. Elle ne bloque pas la propagation.",
            "example": "event.preventDefault();"
          },
          {
            "term": "Propagation / bubbling",
            "definition": "Mécanisme par lequel un événement remonte des éléments enfants vers les parents dans le DOM. L'événement traverse trois phases : capture, cible, puis bubbling.",
            "example": null
          },
          {
            "term": "stopPropagation",
            "definition": "Méthode de l'objet event qui empêche l'événement de continuer à remonter vers les éléments parents.",
            "example": "event.stopPropagation();"
          },
          {
            "term": "Délégation d'événements",
            "definition": "Technique consistant à placer un seul écouteur sur un parent pour gérer plusieurs enfants. Plus performante et fonctionne sur les éléments créés dynamiquement.",
            "example": null
          },
          {
            "term": "État (state)",
            "definition": "Données décrivant la situation actuelle de l'application. L'état est la source de vérité ; le DOM n'est que ce que l'utilisateur voit. Les deux doivent rester distincts.",
            "example": null
          },
          {
            "term": "Structuration du code (État / Logique / Rendu)",
            "definition": "Séparation des responsabilités en trois rôles : gérer les données (état), appliquer les règles (logique pure sans DOM), et mettre à jour l'affichage (rendu).",
            "example": null
          },
          {
            "term": "Scope",
            "definition": "Portée d'une variable : globale, de fonction ou de bloc. let et const respectent le scope de bloc, contrairement à var.",
            "example": null
          },
          {
            "term": "IIFE",
            "definition": "Immediately Invoked Function Expression : fonction exécutée immédiatement après sa définition, utilisée pour encapsuler du code et n'exposer que ce que l'on souhaite.",
            "example": "const app = (() => { return { init }; })();"
          },
          {
            "term": "Événement input",
            "definition": "Événement déclenché à chaque modification d'un champ (frappe, collage, suppression), utile pour le suivi en temps réel.",
            "example": null
          },
          {
            "term": "Événement change",
            "definition": "Événement déclenché après validation d'un champ (perte de focus, sélection finale), utile pour listes déroulantes et cases à cocher.",
            "example": null
          },
          {
            "term": "Événement submit",
            "definition": "Événement déclenché lors de la soumission d'un formulaire ; souvent couplé à preventDefault pour gérer l'envoi en JavaScript.",
            "example": "form.addEventListener(\"submit\", e => e.preventDefault());"
          },
          {
            "term": "Drag & Drop",
            "definition": "Glisser-déposer : suite d'événements dragstart, dragover, drop et dragend. Le preventDefault sur dragover est obligatoire pour autoriser le drop.",
            "example": "<div draggable=\"true\">"
          },
          {
            "term": "Canvas",
            "definition": "Surface de dessin bitmap : les éléments dessinés ne sont pas des nœuds HTML. Le rendu n'est pas recalculé automatiquement, le développeur gère la mise à jour visuelle.",
            "example": null
          },
          {
            "term": "Contexte de dessin",
            "definition": "Objet retourné par canvas.getContext(\"2d\") fournissant les méthodes graphiques (fillRect, beginPath…).",
            "example": "const ctx = canvas.getContext(\"2d\");"
          }
        ]
      },
      {
        "slug": "js-async",
        "name": "JavaScript — Asynchrone & Fetch",
        "emoji": "🔄",
        "order": 6,
        "cards": [
          {
            "term": "Synchrone",
            "definition": "Mode d'exécution où les instructions se déroulent dans l'ordre, chacune attendant la fin de la précédente.",
            "example": null
          },
          {
            "term": "Asynchrone",
            "definition": "Mode où certaines tâches sont déléguées et leur callback exécuté plus tard, sans bloquer le reste du programme.",
            "example": null
          },
          {
            "term": "Call Stack",
            "definition": "Pile d'exécution dans laquelle JavaScript exécute le code. JS est mono-thread : une seule chose s'exécute à la fois.",
            "example": null
          },
          {
            "term": "Web APIs",
            "definition": "Fonctionnalités fournies par le navigateur en dehors du moteur JS : setTimeout, événements, réseau, etc.",
            "example": null
          },
          {
            "term": "Callback Queue",
            "definition": "File d'attente des callbacks prêts à être exécutés une fois leur tâche asynchrone terminée.",
            "example": null
          },
          {
            "term": "Event Loop",
            "definition": "Mécanisme qui place le premier callback de la file d'attente dans la pile d'exécution quand celle-ci est vide.",
            "example": "setTimeout(() => {}, 0);"
          },
          {
            "term": "setTimeout / setInterval",
            "definition": "Fonctions du navigateur qui exécutent un callback après un délai (setTimeout, une fois) ou de façon répétée (setInterval, arrêté par clearInterval).",
            "example": "setTimeout(() => {}, 2000);"
          },
          {
            "term": "try / catch",
            "definition": "Structure interceptant les erreurs (exceptions) : le bloc try tente l'exécution, le bloc catch traite l'erreur. La suite du programme continue ensuite.",
            "example": "try { JSON.parse(x); } catch (e) {}"
          },
          {
            "term": "localStorage",
            "definition": "Stockage clé/valeur persistant par domaine, côté navigateur. Ne stocke que des chaînes, taille limitée (~5 Mo), non sécurisé pour les données sensibles. getItem renvoie null si la clé n'existe pas.",
            "example": "localStorage.setItem(\"nom\", \"Alice\");"
          },
          {
            "term": "JSON",
            "definition": "JavaScript Object Notation : format textuel standard pour représenter des données structurées.",
            "example": null
          },
          {
            "term": "Sérialisation",
            "definition": "Conversion d'un objet JavaScript en chaîne de caractères, notamment pour le stockage.",
            "example": "JSON.stringify(todos);"
          },
          {
            "term": "Désérialisation",
            "definition": "Reconstruction d'un objet JavaScript à partir d'une chaîne de caractères.",
            "example": "JSON.parse(data);"
          },
          {
            "term": "Client / Serveur",
            "definition": "Le client envoie une requête, le serveur la traite et renvoie une réponse. Le client parle toujours en premier.",
            "example": null
          },
          {
            "term": "HTTP",
            "definition": "HyperText Transfer Protocol : protocole applicatif d'échange du Web. Il est stateless (sans mémoire d'une requête à l'autre).",
            "example": null
          },
          {
            "term": "Verbe HTTP",
            "definition": "Méthode indiquant l'action demandée : GET (lire), POST (créer), PUT (remplacer), PATCH (modifier partiellement), DELETE (supprimer).",
            "example": null
          },
          {
            "term": "Code de statut",
            "definition": "Nombre renvoyé par le serveur indiquant le résultat d'une requête : 200 OK, 201 Created, 204 No Content, 400 Bad Request, 401 Unauthorized, 403 Forbidden, 404 Not Found, 422 Unprocessable Entity, 500 Internal Server Error.",
            "example": null
          },
          {
            "term": "Idempotence",
            "definition": "Une méthode est idempotente si envoyer plusieurs fois la même requête produit le même état final qu'un seul envoi. Cela concerne l'état du serveur, pas la réponse : GET, PUT et DELETE sont idempotents, POST ne l'est pas.",
            "example": null
          },
          {
            "term": "PUT vs POST",
            "definition": "POST crée une ressource avec un identifiant choisi par le serveur (non idempotent) ; PUT crée ou remplace une ressource à une URI connue du client (idempotent).",
            "example": null
          },
          {
            "term": "Promise",
            "definition": "Objet représentant un résultat futur. Trois états : pending, puis fulfilled (résolue) ou rejected (rejetée) ; une fois résolue ou rejetée, l'état est définitif. On l'exploite avec then et catch.",
            "example": "promesse.then(r => {}).catch(e => {});"
          },
          {
            "term": "async / await",
            "definition": "Syntaxe permettant d'écrire du code asynchrone comme du code synchrone. await suspend l'exécution jusqu'à la résolution d'une Promise ; la gestion d'erreurs se fait avec try/catch.",
            "example": "const data = await response.json();"
          },
          {
            "term": "Fetch API",
            "definition": "API native pour effectuer des requêtes HTTP, basée sur les Promises. Attention : fetch ne met pas en erreur les codes 4xx/5xx, il faut tester response.ok.",
            "example": "fetch(\"/api/todos\").then(r => r.json());"
          },
          {
            "term": "NPM",
            "definition": "Node Package Manager : gestionnaire de packages JavaScript, permettant d'installer des dépendances localement ou globalement.",
            "example": "npm install nom-du-package"
          },
          {
            "term": "JSON Server",
            "definition": "Outil qui crée automatiquement une API REST complète (GET, POST, PUT, PATCH, DELETE) à partir d'un simple fichier JSON.",
            "example": "json-server --watch db.json"
          }
        ]
      },
      {
        "slug": "php",
        "name": "PHP — Serveur, POO & MVC",
        "emoji": "🐘",
        "order": 7,
        "cards": [
          {
            "term": "PHP",
            "definition": "Langage serveur interprété (HyperText Preprocessor) qui génère du HTML. Il n'est jamais exécuté côté client : le navigateur ne reçoit que le HTML final.",
            "example": null
          },
          {
            "term": "LAMP / WAMP",
            "definition": "Pile logicielle classique d'hébergement PHP : Linux (ou Windows) + Apache + MySQL + PHP.",
            "example": null
          },
          {
            "term": "Superglobales",
            "definition": "Tableaux automatiquement disponibles partout dans le code. Toutes leurs données doivent être considérées comme non fiables.",
            "example": "$_GET, $_POST, $_SESSION, $_COOKIE, $_SERVER, $_FILES"
          },
          {
            "term": "Session",
            "definition": "Mécanisme conservant des données côté serveur entre plusieurs requêtes d'un même utilisateur. On ne stocke jamais de mot de passe en session.",
            "example": "session_start(); $_SESSION['user_id'] = 12;"
          },
          {
            "term": "Stateless (HTTP)",
            "definition": "Le protocole HTTP n'a aucune mémoire d'une requête à l'autre : chaque requête est indépendante.",
            "example": null
          },
          {
            "term": "POO",
            "definition": "Programmation orientée objet : on définit des classes (le modèle) à partir desquelles on crée des objets (les instances).",
            "example": null
          },
          {
            "term": "Encapsulation",
            "definition": "Cacher l'état interne d'un objet en rendant ses attributs privés et en y accédant via des getters et setters, qui servent de points de contrôle.",
            "example": null
          },
          {
            "term": "Constructeur",
            "definition": "Méthode appelée automatiquement à l'instanciation d'un objet pour l'initialiser.",
            "example": "public function __construct(int $id) { $this->id = $id; }"
          },
          {
            "term": "Visibilité",
            "definition": "Niveau d'accès d'un membre de classe : public (partout), protected (classe et enfants) ou private (classe seule).",
            "example": null
          },
          {
            "term": "Héritage",
            "definition": "Relation « est un » par laquelle une classe enfant étend une classe parente (mot-clé extends) et en réutilise les membres. Une classe n'a qu'un seul parent.",
            "example": "class Admin extends User { }"
          },
          {
            "term": "Classe abstraite",
            "definition": "Classe qui ne peut pas être instanciée directement et qui peut déclarer des méthodes abstraites que les classes enfants doivent implémenter.",
            "example": "abstract class Animal { abstract public function crier(): string; }"
          },
          {
            "term": "Interface",
            "definition": "Contrat sans implémentation listant des méthodes qu'une classe doit fournir (mot-clé implements). Une classe peut en implémenter plusieurs.",
            "example": "class Product implements Comparable { }"
          },
          {
            "term": "Membre statique",
            "definition": "Membre (attribut ou méthode) lié à la classe elle-même et non à une instance, accessible via self:: ou le nom de la classe.",
            "example": "static"
          },
          {
            "term": "MVC",
            "definition": "Modèle / Vue / Contrôleur : design pattern de séparation des responsabilités d'une application.",
            "example": null
          },
          {
            "term": "Modèle (MVC)",
            "definition": "Couche responsable des données, de la logique métier et de l'accès à la base de données. Toute interaction avec la BDD doit y passer.",
            "example": null
          },
          {
            "term": "Vue (MVC)",
            "definition": "Couche chargée uniquement de l'affichage. Elle ne contient ni logique métier ni SQL.",
            "example": null
          },
          {
            "term": "Contrôleur (MVC)",
            "definition": "Orchestrateur qui reçoit la requête, appelle les modèles et transmet les données à la vue. Il ne fait pas de SQL lui-même.",
            "example": null
          },
          {
            "term": "Front Controller",
            "definition": "Point d'entrée unique (index.php) par lequel passent toutes les requêtes et qui centralise initialisation, sécurité et routage.",
            "example": null
          },
          {
            "term": "Routing",
            "definition": "Traduction d'une URL en appel d'un contrôleur, d'une action et de paramètres.",
            "example": "/user/edit/12 → UserController::edit(id=12)"
          },
          {
            "term": "PSR",
            "definition": "PHP Standards Recommendations : conventions communes de l'écosystème PHP (PSR-1 base, PSR-12 style, PSR-4 autoload).",
            "example": null
          },
          {
            "term": "Namespace",
            "definition": "Espace de noms qui structure les classes et évite les conflits de noms.",
            "example": null
          },
          {
            "term": "Autoloading",
            "definition": "Chargement automatique d'une classe à sa première utilisation, en suivant une convention nom de classe ↔ chemin (PSR-4), sans require manuel.",
            "example": null
          },
          {
            "term": "include / require",
            "definition": "Instructions d'inclusion de fichier : include n'émet qu'un warning si le fichier manque et le script continue, tandis que require provoque une erreur fatale. require_once évite en plus les inclusions multiples.",
            "example": null
          }
        ]
      },
      {
        "slug": "pdo",
        "name": "PHP — PDO & Bases de données",
        "emoji": "🗄️",
        "order": 8,
        "cards": [
          {
            "term": "Persistance",
            "definition": "Stockage durable des données, par opposition aux variables ou à la session qui sont temporaires.",
            "example": null
          },
          {
            "term": "Base relationnelle",
            "definition": "Base où les données sont structurées en tables (lignes × colonnes) reliées entre elles par des relations.",
            "example": null
          },
          {
            "term": "Clé primaire",
            "definition": "Identifiant unique d'une ligne d'une table, généralement auto-incrémenté.",
            "example": null
          },
          {
            "term": "Contraintes",
            "definition": "Règles garantissant la cohérence des données d'une table, comme NOT NULL, UNIQUE ou PRIMARY KEY.",
            "example": null
          },
          {
            "term": "PDO",
            "definition": "PHP Data Objects : interface unifiée d'accès aux SGBD relationnels depuis PHP.",
            "example": "new PDO('mysql:host=localhost;dbname=app_db;charset=utf8', $user, $pwd)"
          },
          {
            "term": "DSN",
            "definition": "Data Source Name : chaîne de caractères décrivant la connexion à la base (type de SGBD, hôte, nom de base, jeu de caractères).",
            "example": "mysql:host=localhost;dbname=app_db;charset=utf8"
          },
          {
            "term": "Requête préparée",
            "definition": "Requête qui sépare la structure SQL des valeurs, transmises ensuite séparément. C'est la protection de référence contre l'injection SQL.",
            "example": "$stmt = $pdo->prepare('SELECT * FROM users WHERE email = :email'); $stmt->execute(['email' => $email]);"
          },
          {
            "term": "Transaction",
            "definition": "Groupe de requêtes qui doivent réussir ensemble (tout ou rien) : on valide avec commit ou on annule entièrement avec rollBack en cas d'erreur.",
            "example": "$pdo->beginTransaction(); ... $pdo->commit(); // sinon $pdo->rollBack();"
          },
          {
            "term": "lastInsertId",
            "definition": "Méthode PDO renvoyant l'identifiant auto-incrémenté de la dernière ligne insérée.",
            "example": "$newId = $pdo->lastInsertId();"
          },
          {
            "term": "Modes de fetch",
            "definition": "Façons de récupérer les résultats : fetch() lit une ligne, fetchAll() toutes les lignes et fetchColumn() une seule valeur (utile pour COUNT). Le format se règle via FETCH_ASSOC, FETCH_OBJ ou FETCH_NUM.",
            "example": "$users = $stmt->fetchAll(PDO::FETCH_ASSOC);"
          },
          {
            "term": "CRUD",
            "definition": "Les quatre opérations de base sur les données : Create, Read, Update, Delete.",
            "example": null
          },
          {
            "term": "ORM",
            "definition": "Object-Relational Mapping : couche d'abstraction au-dessus de PDO qui mappe une table à une classe, une ligne à une instance et une colonne à un attribut, en générant le SQL automatiquement.",
            "example": null
          },
          {
            "term": "Authentification",
            "definition": "Vérifier qui est l'utilisateur (prouver son identité).",
            "example": null
          },
          {
            "term": "Autorisation",
            "definition": "Vérifier ce que l'utilisateur a le droit de faire. Être connecté ne signifie pas avoir tous les droits.",
            "example": null
          },
          {
            "term": "Hash",
            "definition": "Empreinte non réversible d'un mot de passe : on ne peut pas retrouver le mot de passe à partir du hash. En PHP on utilise password_hash et password_verify.",
            "example": "$hash = password_hash($password, PASSWORD_DEFAULT);"
          }
        ]
      },
      {
        "slug": "api-rest",
        "name": "API REST",
        "emoji": "🔌",
        "order": 9,
        "cards": [
          {
            "term": "API",
            "definition": "Application Programming Interface : interface permettant à un logiciel d'utiliser les fonctionnalités ou les données d'un autre, sans connaître son fonctionnement interne.",
            "example": null
          },
          {
            "term": "REST",
            "definition": "Representational State Transfer : un style d'architecture (et non un langage ou une bibliothèque) pour concevoir des services web.",
            "example": null
          },
          {
            "term": "Ressource",
            "definition": "Objet ou ensemble d'objets manipulé par l'API (étudiant, produit, commande…).",
            "example": null
          },
          {
            "term": "Représentation",
            "definition": "Forme sous laquelle une ressource est renvoyée, le plus souvent en JSON.",
            "example": null
          },
          {
            "term": "URI",
            "definition": "Identifiant d'une ressource. Par convention on utilise des noms au pluriel et jamais de verbes, l'action étant portée par la méthode HTTP.",
            "example": "/students/37"
          },
          {
            "term": "RESTful",
            "definition": "Qualifie une API qui respecte strictement les principes REST.",
            "example": null
          },
          {
            "term": "Stateless (REST)",
            "definition": "Le serveur ne conserve aucun état entre deux requêtes : chaque requête doit contenir tout le nécessaire pour être traitée.",
            "example": null
          },
          {
            "term": "Les 6 contraintes REST",
            "definition": "Principes de l'architecture REST : client-serveur, sans état, cache, système en couches, interface uniforme et, facultativement, code à la demande.",
            "example": null
          },
          {
            "term": "Interface uniforme",
            "definition": "Contrainte REST : identification des ressources par URI, manipulation via des représentations, messages auto-descriptifs et liens d'actions (HATEOAS).",
            "example": null
          },
          {
            "term": "HATEOAS",
            "definition": "Hypermedia As The Engine Of Application State : le serveur fournit dans ses réponses les liens vers les actions possibles.",
            "example": null
          },
          {
            "term": "Conventions d'URI",
            "definition": "Bonnes pratiques de nommage : noms au pluriel pour les collections, identifiant pour un élément, sous-ressources imbriquées et filtres via query string. Pas de verbes dans l'URI.",
            "example": "/students/37, /products/12/reviews, /students?group=A"
          },
          {
            "term": "Méthodes HTTP",
            "definition": "Verbes indiquant l'action sur une ressource, en correspondance avec le CRUD : GET (lire), POST (créer), PUT (remplacer), PATCH (modifier partiellement), DELETE (supprimer).",
            "example": "GET /students/37, DELETE /students/37"
          },
          {
            "term": "Idempotence",
            "definition": "Propriété d'une méthode pour laquelle rejouer la requête ne change pas l'état final. GET, PUT et DELETE sont idempotents ; POST ne l'est pas (deux POST créent deux ressources).",
            "example": null
          },
          {
            "term": "Codes de statut HTTP",
            "definition": "Nombres indiquant le résultat d'une requête. En API on distingue notamment 200 (OK), 201 (créé), 400 (requête invalide), 401/403 (auth/droits), 404 (introuvable), 422 (données invalides) et 405 (méthode non autorisée).",
            "example": "http_response_code(201);"
          },
          {
            "term": "JSON (représentation)",
            "definition": "Format texte le plus courant pour échanger des représentations en REST. Règles strictes : clés entre guillemets doubles, pas de virgule finale, pas de commentaires, pas de guillemets simples.",
            "example": null
          },
          {
            "term": "Token",
            "definition": "Chaîne servant à prouver l'identité de l'appelant, placée dans l'en-tête Authorization.",
            "example": "Authorization: Bearer ..."
          },
          {
            "term": "HTTPS",
            "definition": "Transport chiffré obligatoire pour une API afin de protéger les données et les jetons d'authentification en transit.",
            "example": null
          },
          {
            "term": "Postman / Insomnia",
            "definition": "Outils permettant d'envoyer des requêtes à une API et de la tester manuellement, sans interface graphique dédiée.",
            "example": null
          },
          {
            "term": "OpenAPI / Swagger",
            "definition": "Format et outils pour décrire et documenter une API de façon structurée, testable et partageable. La documentation fait partie du contrat de l'API.",
            "example": null
          }
        ]
      },
      {
        "slug": "securite",
        "name": "Sécurité Web",
        "emoji": "🔒",
        "order": 10,
        "cards": [
          {
            "term": "Surface d'attaque",
            "definition": "Ensemble des points d'entrée d'une application : formulaires, URL, cookies, JSON, en-têtes, fichiers, routes API… Toutes les données reçues doivent être considérées comme non fiables.",
            "example": null
          },
          {
            "term": "Validation",
            "definition": "Vérifier qu'une donnée reçue est acceptable (format, type, valeur). La validation serveur est obligatoire ; la validation côté client n'améliore que l'UX et ne protège pas.",
            "example": "filter_var($email, FILTER_VALIDATE_EMAIL)"
          },
          {
            "term": "Nettoyage",
            "definition": "Transformer une donnée pour la normaliser, par exemple en supprimant les espaces superflus.",
            "example": "trim($_POST['name'] ?? '')"
          },
          {
            "term": "Échappement",
            "definition": "Neutraliser, au moment de l'affichage, les caractères qui pourraient être interprétés comme du code.",
            "example": "htmlspecialchars($name, ENT_QUOTES, 'UTF-8')"
          },
          {
            "term": "Injection SQL",
            "definition": "Attaque qui modifie la structure d'une requête SQL via une donnée utilisateur, typiquement par concaténation. On s'en protège avec des requêtes préparées.",
            "example": null
          },
          {
            "term": "XSS",
            "definition": "Cross-Site Scripting : exécution de code injecté dans une page, qui survient quand on affiche une donnée utilisateur comme du HTML. On s'en protège en échappant à l'affichage (htmlspecialchars, textContent).",
            "example": null
          },
          {
            "term": "Types de XSS",
            "definition": "Trois variantes : stockée (le code injecté est enregistré, par ex. en BDD, et atteint tous les visiteurs), réfléchie (une valeur d'URL est affichée sans échappement) et DOM-based (entièrement côté navigateur, via innerHTML avec des paramètres d'URL).",
            "example": null
          },
          {
            "term": "CSRF",
            "definition": "Cross-Site Request Forgery : forcer un utilisateur connecté à émettre une requête non voulue, le navigateur envoyant automatiquement son cookie de session. Règle : GET ne doit jamais modifier l'état.",
            "example": null
          },
          {
            "term": "Token CSRF",
            "definition": "Valeur aléatoire générée côté serveur, insérée dans les formulaires puis vérifiée pour confirmer l'origine d'une action sensible.",
            "example": "$_SESSION['csrf_token'] = bin2hex(random_bytes(32));"
          },
          {
            "term": "hash_equals",
            "definition": "Fonction PHP de comparaison de chaînes résistante aux attaques temporelles, utilisée pour vérifier un token CSRF.",
            "example": "if (!hash_equals($_SESSION['csrf_token'], $token)) { http_response_code(403); exit; }"
          },
          {
            "term": "Contrôle d'autorisation",
            "definition": "Vérification, côté serveur et au moment de l'action, que l'utilisateur a le droit d'agir sur la ressource visée. Les requêtes préparées ne remplacent pas ce contrôle, et masquer un bouton côté UI ne protège rien.",
            "example": "DELETE FROM comments WHERE id = :id AND user_id = :user_id"
          },
          {
            "term": "Gestion des erreurs",
            "definition": "En développement, on affiche des détails et des logs verbeux ; en production, l'utilisateur ne voit qu'un message générique et les détails techniques vont dans les logs, sans fuite d'information sensible.",
            "example": "error_log($e->getMessage()); http_response_code(500);"
          },
          {
            "term": "Défense en profondeur",
            "definition": "Empiler plusieurs protections complémentaires afin que, si l'une échoue, une autre limite les dégâts (validation, requêtes préparées, échappement, auth, autorisation, CSRF, codes HTTP, erreurs maîtrisées).",
            "example": null
          }
        ]
      }
    ]
  },
  {
    "slug": "dev-mobile-rest",
    "name": "Dev Mobile & REST",
    "emoji": "📱",
    "order": 2,
    "chapters": [
      {
        "slug": "mobile-intro",
        "name": "Introduction au Mobile",
        "emoji": "📱",
        "order": 1,
        "cards": [
          {
            "term": "Application native",
            "definition": "Application développée spécifiquement pour une plateforme (Android ou iOS) avec son langage dédié, offrant performances maximales, accès complet aux API système et UX optimale, mais au prix d'un double développement et d'une dépendance à la plateforme.",
            "example": null
          },
          {
            "term": "Application multiplateforme",
            "definition": "Application dont le code est partagé entre plusieurs plateformes via un framework (Flutter, React Native…). Permet un code unique, une équipe unique et un time-to-market rapide, mais avec des performances légèrement réduites et des API plus restreintes.",
            "example": null
          },
          {
            "term": "PWA (Progressive Web App)",
            "definition": "Site web responsive installable, doté d'un mode hors-ligne et d'un accès à des API web modernes, exécuté dans un conteneur natif.",
            "example": null
          },
          {
            "term": "BaaS (Backend as a Service)",
            "definition": "Backend clé en main fourni par un tiers (ex. Firebase), évitant de développer et d'héberger son propre serveur.",
            "example": null
          },
          {
            "term": "Material Design",
            "definition": "Système de règles de design visuel de Google pour les interfaces Android (composants, thèmes clair/sombre, accessibilité).",
            "example": null
          },
          {
            "term": "Hot Reload",
            "definition": "Rechargement instantané du code dans l'application en cours d'exécution, sans la redémarrer ni perdre son état.",
            "example": null
          },
          {
            "term": "Flutter",
            "definition": "Framework multiplateforme de Google utilisant le langage Dart, avec ses propres widgets, son moteur de rendu, le Hot Reload et des performances proches du natif.",
            "example": null
          },
          {
            "term": "React Native",
            "definition": "Framework multiplateforme de Meta utilisant JavaScript/React, qui s'appuie sur des composants natifs, un style façon CSS et le Hot Reload.",
            "example": null
          },
          {
            "term": "Ionic / Angular",
            "definition": "Framework multiplateforme reposant sur les standards web (HTML/CSS/TypeScript), avec des composants prêts à l'emploi et un support PWA.",
            "example": null
          },
          {
            "term": "Kotlin Multiplatform",
            "definition": "Technologie de JetBrains permettant de partager la logique métier entre plateformes tout en conservant une UI native propre à chacune.",
            "example": null
          },
          {
            "term": "4 piliers d'une solution mobile",
            "definition": "Quatre domaines à maîtriser pour toute app mobile : l'UI (composants, layouts, navigation, thèmes), l'UX (performance, ergonomie, accessibilité, hors-ligne), les Données (stockage local, état, cache, synchronisation) et le Backend (API REST, temps réel, sécurité, réseau).",
            "example": null
          },
          {
            "term": "Xcode",
            "definition": "IDE d'Apple pour le développement iOS, disponible uniquement sur macOS, incluant le simulateur iOS.",
            "example": null
          },
          {
            "term": "SDK (Software Development Kit)",
            "definition": "Ensemble d'outils, d'API et de bibliothèques de développement ; le SDK Android est organisé par niveau d'API.",
            "example": null
          },
          {
            "term": "API Level",
            "definition": "Numéro de version de l'API Android utilisé pour cibler les fonctionnalités du système (ex. API 24 = Android 7.0).",
            "example": null
          },
          {
            "term": "Android Studio",
            "definition": "IDE officiel d'Android, basé sur IntelliJ IDEA, avec émulateur intégré.",
            "example": null
          },
          {
            "term": "Gradle",
            "definition": "Système de build et de gestion des dépendances d'Android, qui supporte le Kotlin DSL.",
            "example": null
          },
          {
            "term": "AVD (Android Virtual Device)",
            "definition": "Émulateur d'appareil Android, créé et géré via l'AVD Manager (profil + image système).",
            "example": null
          },
          {
            "term": "ADB (Android Debug Bridge)",
            "definition": "Outil en ligne de commande permettant de communiquer avec un appareil physique ou un émulateur (installation, logs, shell).",
            "example": "adb devices"
          },
          {
            "term": "APK",
            "definition": "Fichier d'installation d'une application Android.",
            "example": null
          },
          {
            "term": "Logcat",
            "definition": "Système de journalisation (logs) d'Android, consultable en temps réel.",
            "example": "adb logcat"
          },
          {
            "term": "Android",
            "definition": "Système d'exploitation mobile open-source basé sur le noyau Linux et développé par Google ; il détient environ 72 % du marché en 2025.",
            "example": null
          }
        ]
      },
      {
        "slug": "kotlin",
        "name": "Kotlin — Le langage",
        "emoji": "🎯",
        "order": 2,
        "cards": [
          {
            "term": "Kotlin",
            "definition": "Langage créé par JetBrains, tournant sur la JVM et 100 % interopérable avec Java. Officiel pour Android depuis 2019 et recommandé, il réduit fortement le boilerplate.",
            "example": null
          },
          {
            "term": "JVM (Java Virtual Machine)",
            "definition": "Machine virtuelle exécutant le bytecode Java/Kotlin.",
            "example": null
          },
          {
            "term": "Boilerplate",
            "definition": "Code répétitif et verbeux nécessaire mais sans valeur métier ; Kotlin le réduit fortement.",
            "example": null
          },
          {
            "term": "val / var",
            "definition": "Déclarations de variables : val pour une variable immuable (≈ final), var pour une variable mutable. En Kotlin, le type se place après le nom.",
            "example": "val name: String = \"John\"; var age: Int = 25"
          },
          {
            "term": "Inférence de type",
            "definition": "Capacité du compilateur à déduire le type d'une variable sans déclaration explicite.",
            "example": "val message = \"Hello\""
          },
          {
            "term": "Null safety",
            "definition": "Système de types distinguant les valeurs nullables (?) des non-nullables (le défaut) pour éviter les NullPointerException, détectées dès la compilation.",
            "example": null
          },
          {
            "term": "Type nullable (?)",
            "definition": "Type pouvant contenir la valeur null, signalé par un point d'interrogation après le type.",
            "example": "var nullableName: String? = null"
          },
          {
            "term": "Safe call (?.)",
            "definition": "Opérateur appelant un membre seulement si l'objet n'est pas null, et retournant null sinon.",
            "example": "nullableName?.length"
          },
          {
            "term": "Opérateur Elvis (?:)",
            "definition": "Opérateur fournissant une valeur par défaut lorsque l'expression de gauche est null.",
            "example": "nullableName?.length ?: 0"
          },
          {
            "term": "Assertion non-null (!!)",
            "definition": "Opérateur affirmant qu'une valeur n'est pas null ; il lève une exception si elle l'est.",
            "example": "nullableName!!.length"
          },
          {
            "term": "Data class",
            "definition": "Classe générant automatiquement equals, hashCode, toString, copy et la destructuration, idéale pour porter des données.",
            "example": "data class Person(val name: String, val age: Int)"
          },
          {
            "term": "Destructuration",
            "definition": "Décomposition d'un objet en plusieurs variables en une seule instruction.",
            "example": "val (name, age) = person"
          },
          {
            "term": "companion object",
            "definition": "Objet lié à une classe contenant ses membres « statiques » (équivalent de static) ; @JvmStatic l'expose proprement à Java.",
            "example": null
          },
          {
            "term": "object (singleton)",
            "definition": "Déclaration créant une unique instance d'une classe (singleton).",
            "example": null
          },
          {
            "term": "open / override",
            "definition": "En Kotlin, les classes et méthodes sont final par défaut : le mot-clé open autorise l'héritage ou la redéfinition, et override est obligatoire et explicite pour redéfinir un membre.",
            "example": null
          },
          {
            "term": "Visibilité",
            "definition": "Modificateurs d'accès en Kotlin, public par défaut ; les autres sont private, protected et internal.",
            "example": null
          },
          {
            "term": "Bloc init",
            "definition": "Bloc d'initialisation exécuté à la construction de l'objet, complément du constructeur primaire déclaré dans l'en-tête de la classe.",
            "example": null
          },
          {
            "term": "Délégation (by)",
            "definition": "Mécanisme déléguant l'implémentation d'une interface ou d'une propriété à un autre objet via le mot-clé by.",
            "example": null
          },
          {
            "term": "Backing field (field)",
            "definition": "Champ implicite stockant la valeur d'une propriété, accessible dans ses accesseurs (get/set) via le mot-clé field.",
            "example": null
          },
          {
            "term": "Propriété calculée",
            "definition": "Propriété sans champ de stockage dont la valeur est recalculée à chaque accès via un getter personnalisé.",
            "example": "val kelvin get() = celsius + 273.15"
          },
          {
            "term": "lateinit",
            "definition": "Modificateur permettant l'initialisation différée d'une propriété non-nullable.",
            "example": null
          },
          {
            "term": "by lazy",
            "definition": "Initialisation paresseuse d'une propriété, exécutée une seule fois au premier accès.",
            "example": "val v: String by lazy { \"computed once\" }"
          },
          {
            "term": "Expression body",
            "definition": "Syntaxe définissant une fonction ou propriété en une seule ligne avec le signe égal, sans bloc ni return.",
            "example": "fun add(a: Int, b: Int) = a + b"
          },
          {
            "term": "Extension function",
            "definition": "Fonction ajoutée à une classe existante sans la modifier ni en hériter.",
            "example": "fun String.addHello() = \"Hello $this\""
          },
          {
            "term": "Smart cast",
            "definition": "Conversion de type automatique opérée par le compilateur après une vérification de type (is).",
            "example": null
          },
          {
            "term": "when",
            "definition": "Structure conditionnelle expressive remplaçant le switch ; elle peut tester des types et retourner une valeur.",
            "example": null
          },
          {
            "term": "Coroutine",
            "definition": "Mécanisme d'asynchrone léger permettant d'écrire du code non bloquant de façon séquentielle (launch, scopes, dispatchers).",
            "example": null
          },
          {
            "term": "suspend",
            "definition": "Modificateur d'une fonction pouvant être suspendue puis reprise sans bloquer le thread.",
            "example": "suspend fun load() { delay(1000) }"
          },
          {
            "term": "Flow",
            "definition": "Flux de données asynchrone émettant plusieurs valeurs au fil du temps, produites avec emit et consommées avec collect.",
            "example": null
          },
          {
            "term": "Scope functions",
            "definition": "Fonctions standard exécutant un bloc dans le contexte d'un objet : let (valeurs nullables), run et with (grouper des opérations), apply (configuration) et also (effets de bord).",
            "example": null
          },
          {
            "term": "Collections Kotlin",
            "definition": "Bibliothèque distinguant collections mutables et immuables et offrant des opérations fonctionnelles comme map, filter, groupBy et maxBy.",
            "example": null
          },
          {
            "term": "Sealed class",
            "definition": "Classe à hiérarchie restreinte dont toutes les sous-classes sont connues et déclarées dans le même fichier ; idéale pour modéliser un résultat Success / Error.",
            "example": null
          },
          {
            "term": "Gestion d'erreurs Kotlin",
            "definition": "En Kotlin, try est une expression qui retourne une valeur, les exceptions sont non vérifiées, et le type Result permet d'encapsuler succès ou échec.",
            "example": null
          },
          {
            "term": "Interface",
            "definition": "Type pouvant contenir des propriétés abstraites et des méthodes par défaut, mais sans état (aucun champ) ; l'implémentation multiple est autorisée.",
            "example": null
          },
          {
            "term": "Généricité",
            "definition": "Écriture de code paramétré par un type pour le rendre réutilisable et typé, avec contraintes possibles (ex. <T : Number>) et star-projection (*).",
            "example": "class Box<T>(var content: T)"
          },
          {
            "term": "Variance (in / out)",
            "definition": "Mécanisme contrôlant le sens d'utilisation d'un type générique : out = covariance (producteur), in = contravariance (consommateur).",
            "example": null
          },
          {
            "term": "reified",
            "definition": "Paramètre de type générique dont le type réel reste disponible à l'exécution, utilisable avec une fonction inline.",
            "example": null
          },
          {
            "term": "Interopérabilité Java ↔ Kotlin",
            "definition": "Capacité de Kotlin et Java à s'appeler mutuellement dans un même projet, bidirectionnellement et sans wrapper grâce au bytecode commun ; annotations utiles : @JvmStatic, @JvmField, @JvmOverloads, @JvmName.",
            "example": null
          },
          {
            "term": "Platform Type",
            "definition": "Type provenant de Java dont la nullabilité est inconnue côté Kotlin, et donc potentiellement source de NullPointerException.",
            "example": null
          },
          {
            "term": "main()",
            "definition": "Fonction servant de point d'entrée d'un programme Kotlin, avec ou sans paramètre args: Array<String>.",
            "example": null
          },
          {
            "term": "kotlinc",
            "definition": "Compilateur Kotlin en ligne de commande, qui peut produire un JAR exécutable et génère un fichier *Kt.class pour les fonctions top-level.",
            "example": "kotlinc Main.kt -include-runtime -d Main.jar"
          },
          {
            "term": "Ktor",
            "definition": "Framework Kotlin client/serveur HTTP, qui utilise kotlinx.serialization pour gérer le JSON.",
            "example": null
          }
        ]
      },
      {
        "slug": "android",
        "name": "Android — Composants & Architecture",
        "emoji": "🤖",
        "order": 3,
        "cards": [
          {
            "term": "Activity",
            "definition": "Composant fondamental représentant un écran unique avec interface utilisateur et point d'entrée de l'interaction ; une seule est active à la fois et la MainActivity est déclarée dans le manifeste.",
            "example": null
          },
          {
            "term": "Back stack",
            "definition": "Pile gérant l'historique des activités et permettant la navigation arrière.",
            "example": null
          },
          {
            "term": "Intent",
            "definition": "Message permettant de lancer un composant ou de communiquer entre composants et applications, avec passage de données possible.",
            "example": "Intent(this, SecondActivity::class.java)"
          },
          {
            "term": "Intent explicite / implicite",
            "definition": "Un intent explicite cible un composant précis (navigation intra-app) ; un intent implicite décrit une action générique dont le système choisit le gestionnaire.",
            "example": null
          },
          {
            "term": "Fragment",
            "definition": "Portion réutilisable et modulaire d'interface vivant à l'intérieur d'une Activity, avec son propre cycle de vie lié à l'hôte ; ajoutable/supprimable dynamiquement, idéal pour les interfaces responsive.",
            "example": null
          },
          {
            "term": "Service",
            "definition": "Composant exécutant des opérations longues en arrière-plan, sans interface utilisateur.",
            "example": null
          },
          {
            "term": "Foreground / Background service",
            "definition": "Un service foreground affiche une notification visible (ex. lecteur de musique) ; un service background est invisible à l'utilisateur (ex. synchronisation).",
            "example": null
          },
          {
            "term": "WorkManager",
            "definition": "API recommandée pour planifier des tâches en arrière-plan, notamment périodiques.",
            "example": null
          },
          {
            "term": "Broadcast Receiver",
            "definition": "Composant réagissant à des événements système ou applicatifs diffusés (connectivité, batterie faible, redémarrage…).",
            "example": null
          },
          {
            "term": "Content Provider",
            "definition": "Interface standardisée de partage de données structurées entre applications, via URI, opérations CRUD et permissions.",
            "example": null
          },
          {
            "term": "ViewModel",
            "definition": "Composant conservant les données liées à l'UI et survivant aux changements de configuration comme la rotation d'écran.",
            "example": null
          },
          {
            "term": "Changement de configuration",
            "definition": "Événement (ex. rotation d'écran) qui détruit et recrée l'Activity.",
            "example": null
          },
          {
            "term": "Cycle de vie (lifecycle)",
            "definition": "Suite d'états et de callbacks gérés par le système pour un composant : onCreate → onStart → onResume → [Active] → onPause → onStop → onDestroy, avec onRestart après onStop en cas de retour au premier plan.",
            "example": null
          },
          {
            "term": "onCreate",
            "definition": "Callback de cycle de vie appelé à la création de l'Activity, où l'on initialise l'UI et les ViewModels.",
            "example": null
          },
          {
            "term": "onResume",
            "definition": "Callback de cycle de vie indiquant que l'Activity est au premier plan et interactive.",
            "example": null
          },
          {
            "term": "onPause",
            "definition": "Callback de cycle de vie appelé quand l'Activity n'est plus au premier plan ; on y effectue une sauvegarde légère.",
            "example": null
          },
          {
            "term": "onStop",
            "definition": "Callback de cycle de vie appelé quand l'Activity n'est plus visible ; on y réalise une sauvegarde complète et on libère les ressources lourdes.",
            "example": null
          },
          {
            "term": "MVVM (Model-View-ViewModel)",
            "definition": "Architecture séparant les données et la logique (Model), la logique de présentation (ViewModel) et l'interface (View) ; le ViewModel ne connaît pas la View, ce qui améliore la testabilité et permet la liaison de données.",
            "example": null
          },
          {
            "term": "MVC (Model-View-Controller)",
            "definition": "Architecture où le Controller gère directement les interactions entre la View et le Model.",
            "example": null
          },
          {
            "term": "AndroidManifest.xml",
            "definition": "Fichier décrivant l'application au système Android (composants, permissions, point d'entrée) ; il contient la balise <application> et les déclarations d'<activity>.",
            "example": null
          },
          {
            "term": "Intent-filter",
            "definition": "Déclaration dans le manifeste indiquant à quels Intents un composant peut répondre ; un filtre action.MAIN + category.LAUNCHER désigne le point d'entrée affiché dans le lanceur.",
            "example": null
          },
          {
            "term": "LiveData",
            "definition": "Conteneur de données observable et conscient du cycle de vie.",
            "example": null
          },
          {
            "term": "XML Layouts",
            "definition": "Approche traditionnelle de construction d'UI Android en XML, avec séparation UI/logique, éditeur visuel et structure hiérarchique.",
            "example": null
          }
        ]
      },
      {
        "slug": "compose",
        "name": "Jetpack Compose",
        "emoji": "🧩",
        "order": 4,
        "cards": [
          {
            "term": "Jetpack",
            "definition": "Ensemble de bibliothèques Android modernes recommandées par Google.",
            "example": null
          },
          {
            "term": "Jetpack Compose",
            "definition": "Toolkit UI déclaratif et moderne pour Android, écrit en Kotlin, offrant un code concis, une preview en temps réel et des composants Material Design (Column, Text, Button…).",
            "example": null
          },
          {
            "term": "@Composable",
            "definition": "Annotation marquant une fonction qui décrit une partie de l'interface dans Jetpack Compose.",
            "example": "@Composable fun Greeting(name: String) { Text(\"Hello $name\") }"
          },
          {
            "term": "UI déclarative",
            "definition": "Paradigme où l'on décrit quoi afficher en fonction de l'état, plutôt que comment modifier la vue impérativement.",
            "example": null
          },
          {
            "term": "State (état)",
            "definition": "Données dont dépend l'affichage ; leur modification déclenche la mise à jour automatique de l'UI (recomposition).",
            "example": null
          },
          {
            "term": "Recomposition",
            "definition": "Réexécution des fonctions @Composable concernées pour mettre à jour l'UI lorsqu'un état dont elles dépendent change.",
            "example": null
          },
          {
            "term": "Modifier",
            "definition": "Objet configurant l'apparence et le comportement d'un composant Compose (taille, marges, remplissage…).",
            "example": "Modifier.fillMaxSize().padding(16.dp)"
          }
        ]
      },
      {
        "slug": "stockage",
        "name": "Stockage & Données",
        "emoji": "🗄️",
        "order": 5,
        "cards": [
          {
            "term": "Persistance",
            "definition": "Conservation des données au-delà de la session de l'application (entre sessions, en mode hors-ligne, pour la personnalisation).",
            "example": null
          },
          {
            "term": "Stockage court terme vs persistant",
            "definition": "Le stockage court terme conserve les données en mémoire (variables, Bundle d'instance, cache) ; le stockage persistant survit à la fermeture via SharedPreferences, fichiers, bases de données (SQLite/Room) ou cloud.",
            "example": null
          },
          {
            "term": "Stockage local vs cloud",
            "definition": "Le stockage local est immédiat, hors-ligne et gratuit mais limité à l'appareil et perdu à la désinstallation ; le cloud offre synchronisation multi-appareils et sauvegarde automatique mais nécessite internet, induit des coûts et de la latence.",
            "example": null
          },
          {
            "term": "SharedPreferences",
            "definition": "Stockage simple de paires clé-valeur primitives, adapté aux petites quantités de données comme les paramètres et les états d'UI.",
            "example": "sharedPref.edit().putString(\"username\", \"JohnDoe\").apply()"
          },
          {
            "term": "DataStore",
            "definition": "Successeur de SharedPreferences basé sur les coroutines Kotlin, donc asynchrone par défaut (pas de blocage du thread UI), fortement typé, avec lecture via Flow et migrations intégrées.",
            "example": null
          },
          {
            "term": "Preferences / Proto DataStore",
            "definition": "Deux variantes de DataStore : Preferences DataStore stocke des paires clé-valeur, Proto DataStore stocke des objets typés définis via Protocol Buffers.",
            "example": null
          },
          {
            "term": "Protocol Buffers",
            "definition": "Format de sérialisation binaire typé développé par Google.",
            "example": null
          },
          {
            "term": "Sandbox",
            "definition": "Espace isolé et privé réservé à une application.",
            "example": null
          },
          {
            "term": "Stockage interne",
            "definition": "Espace de fichiers privé à l'application (/data/data/[package]/files/), ne nécessitant aucune permission et supprimé à la désinstallation.",
            "example": "openFileOutput(\"note.txt\", Context.MODE_PRIVATE)"
          },
          {
            "term": "Stockage externe",
            "definition": "Espace partagé du stockage : la partie publique est visible et requiert des permissions, la partie spécifique à l'app (/Android/data/[package]/) n'en requiert pas.",
            "example": null
          },
          {
            "term": "Scoped Storage",
            "definition": "Modèle d'accès restreint au stockage externe, introduit avec Android 10 et obligatoire depuis Android 11, où l'accès aux médias passe par MediaStore.",
            "example": null
          },
          {
            "term": "MediaStore",
            "definition": "API d'accès standardisé aux fichiers médias (images, audio, vidéo) via un ContentProvider.",
            "example": null
          },
          {
            "term": "SQLite",
            "definition": "Moteur de base de données relationnelle léger embarqué dans Android.",
            "example": null
          },
          {
            "term": "Room",
            "definition": "Bibliothèque Jetpack d'abstraction de SQLite (ORM) offrant des requêtes vérifiées à la compilation, moins de boilerplate, l'intégration de LiveData/Flow/Coroutines et des migrations simplifiées.",
            "example": null
          },
          {
            "term": "ORM (Object-Relational Mapping)",
            "definition": "Technique reliant les objets du code et les tables d'une base de données.",
            "example": null
          },
          {
            "term": "Entité (@Entity)",
            "definition": "Classe Kotlin annotée @Entity représentant une table de la base de données dans Room.",
            "example": "@Entity(tableName = \"workouts\") data class Workout(...)"
          },
          {
            "term": "DAO (@Dao)",
            "definition": "Data Access Object : interface annotée @Dao définissant les méthodes d'accès aux données (CRUD et requêtes).",
            "example": null
          },
          {
            "term": "Database (@Database)",
            "definition": "Classe abstraite annotée @Database reliant les DAO et constituant le point d'entrée d'une base de données Room.",
            "example": null
          },
          {
            "term": "CRUD",
            "definition": "Les quatre opérations de base sur les données : Create, Read, Update, Delete.",
            "example": null
          },
          {
            "term": "Migration de schéma",
            "definition": "Mise à jour de la structure d'une base de données sans perte de données.",
            "example": null
          },
          {
            "term": "Firebase",
            "definition": "Plateforme cloud (BaaS) de Google offrant base de données, authentification et autres services.",
            "example": null
          },
          {
            "term": "Realtime Database / Cloud Firestore",
            "definition": "Bases de données cloud de Firebase : Realtime Database fonctionne en temps réel, Cloud Firestore est une base NoSQL orientée documents.",
            "example": null
          },
          {
            "term": "Firebase Authentication",
            "definition": "Service Firebase de gestion des utilisateurs (inscription, connexion, identité).",
            "example": null
          },
          {
            "term": "NoSQL",
            "definition": "Famille de bases de données non relationnelles (documents, clé-valeur, graphes…).",
            "example": null
          },
          {
            "term": "API REST",
            "definition": "Architecture client-serveur sans état utilisant HTTP (GET/POST/PUT/DELETE) et des formats comme JSON ; côté Android, libs Retrofit, OkHttp et Volley.",
            "example": null
          },
          {
            "term": "JSON",
            "definition": "Format texte léger d'échange de données structurées.",
            "example": null
          },
          {
            "term": "Stateless",
            "definition": "Sans conservation d'état entre les requêtes, caractéristique de REST.",
            "example": null
          },
          {
            "term": "Retrofit / OkHttp / Volley",
            "definition": "Bibliothèques Android d'appels réseau HTTP.",
            "example": null
          },
          {
            "term": "WebSocket",
            "definition": "Protocole de communication bidirectionnelle permanente à faible latence, adapté au temps réel et au collaboratif.",
            "example": null
          },
          {
            "term": "GraphQL",
            "definition": "Langage de requête d'API (créé par Facebook) où le client spécifie précisément les données voulues, évitant le sur-chargement et le sous-chargement ; libs Apollo, graphql-kotlin.",
            "example": null
          },
          {
            "term": "Offline-first",
            "definition": "Stratégie privilégiant le stockage local (ex. Room en principal), synchronisé avec le cloud lorsqu'une connexion est disponible, avec gestion des conflits.",
            "example": null
          },
          {
            "term": "Repository pattern",
            "definition": "Couche intermédiaire centralisant l'accès aux différentes sources de données, rendant celles-ci interchangeables et séparant les responsabilités.",
            "example": null
          },
          {
            "term": "Cache",
            "definition": "Stockage temporaire de données pour accélérer les accès et réduire le trafic réseau.",
            "example": null
          }
        ]
      },
      {
        "slug": "reseau",
        "name": "Réseau TCP/IP",
        "emoji": "🌍",
        "order": 6,
        "cards": [
          {
            "term": "TCP/IP",
            "definition": "Pile de protocoles réseau organisée en 4 couches : Application (HTTP, FTP, SMTP, DNS), Transport (TCP, UDP), Internet (IP, ICMP, ARP) et Accès réseau (Ethernet, WiFi, PPP).",
            "example": null
          },
          {
            "term": "Modèle OSI",
            "definition": "Modèle de référence théorique en 7 couches (Application, Présentation, Session, Transport, Réseau, Liaison, Physique), souvent mis en correspondance avec les 4 couches du modèle TCP/IP.",
            "example": null
          },
          {
            "term": "TCP",
            "definition": "Protocole de transport fiable et orienté connexion, garantissant la livraison ordonnée des données.",
            "example": null
          },
          {
            "term": "UDP",
            "definition": "Protocole de transport rapide sans connexion ni garantie de livraison, adapté aux échanges où la vitesse prime sur la fiabilité.",
            "example": null
          },
          {
            "term": "IP",
            "definition": "Protocole de la couche Internet assurant l'adressage et le routage des paquets entre machines.",
            "example": null
          },
          {
            "term": "IPv4",
            "definition": "Adressage IP sur 32 bits (4 octets, notation x.x.x.x). Plages privées 10.0.0.0/8, 172.16.0.0/12, 192.168.0.0/16 ; adresses spéciales 127.0.0.1 (localhost), 0.0.0.0 (any), 255.255.255.255 (broadcast). Les adresses publiques mondiales sont épuisées.",
            "example": null
          },
          {
            "term": "IPv6",
            "definition": "Adressage IP sur 128 bits (8 groupes de 16 bits, notation raccourcie comme ::1 pour localhost), conçu pour répondre à l'épuisement des adresses IPv4.",
            "example": null
          },
          {
            "term": "Masque de sous-réseau",
            "definition": "Valeur qui sépare la partie réseau et la partie hôte d'une adresse IP ; en notation CIDR, /24 équivaut à 255.255.255.0.",
            "example": null
          },
          {
            "term": "CIDR",
            "definition": "Notation abrégée des masques de sous-réseau indiquant le nombre de bits réseau (ex. /24).",
            "example": null
          },
          {
            "term": "DNS",
            "definition": "Domain Name System : système qui traduit les noms de domaine en adresses IP.",
            "example": null
          },
          {
            "term": "Port",
            "definition": "Numéro sur 16 bits (0–65535) identifiant une application sur une machine. 0–1023 : services bien connus (80/443 HTTP/HTTPS, 22 SSH) ; 1024–49151 : enregistrés ; 49152–65535 : dynamiques/temporaires.",
            "example": null
          },
          {
            "term": "Socket",
            "definition": "Point de communication réseau défini par le couple adresse IP + port. En Java : Socket (client) et ServerSocket (serveur), avec des classes utiles comme InetAddress et NetworkInterface.",
            "example": null
          },
          {
            "term": "Encapsulation",
            "definition": "Ajout successif des en-têtes de chaque couche autour des données : Données HTTP → Segment TCP → Paquet IP → Trame Ethernet.",
            "example": null
          }
        ]
      },
      {
        "slug": "rest-http",
        "name": "REST & HTTP",
        "emoji": "🔌",
        "order": 7,
        "cards": [
          {
            "term": "REST",
            "definition": "REpresentational State Transfer : style d'architecture d'API client/serveur, sans état, offrant un accès distant à des ressources via une interface commune construite en HTTP. Ce n'est pas une norme mais une philosophie.",
            "example": null
          },
          {
            "term": "RESTful",
            "definition": "Qualifie une API conforme à la philosophie REST.",
            "example": null
          },
          {
            "term": "Ressource",
            "definition": "Entité manipulée par l'API, identifiée par une URI. Bonnes pratiques : noms au pluriel sans verbes (/Persons, /Persons/1) et identifiant placé dans le chemin.",
            "example": "/Persons/1"
          },
          {
            "term": "URI / URL",
            "definition": "L'URI identifie une ressource ; l'URL est une URI qui indique en plus un moyen d'accès à la ressource.",
            "example": null
          },
          {
            "term": "Endpoint",
            "definition": "Point d'accès d'une API REST défini par le couple verbe HTTP + URL.",
            "example": null
          },
          {
            "term": "Stateless",
            "definition": "Sans état : le serveur ne conserve aucun état de session entre les requêtes, ce qui permet de fonctionner avec proxies et caches de façon transparente.",
            "example": null
          },
          {
            "term": "HATEOAS",
            "definition": "Hypermedia As The Engine Of Application State : principe où les réponses contiennent les liens (relations IANA self, first, previous, next, last) guidant la navigation dans l'hypermédia.",
            "example": null
          },
          {
            "term": "Méthode safe",
            "definition": "Verbe HTTP qui ne modifie pas l'état du serveur (GET, HEAD, OPTIONS).",
            "example": null
          },
          {
            "term": "Idempotent",
            "definition": "Verbe HTTP dont N appels produisent le même effet qu'un seul appel (GET, PUT, DELETE).",
            "example": null
          },
          {
            "term": "GET",
            "definition": "Verbe HTTP servant à lire une ressource ou une collection. Safe et idempotent.",
            "example": null
          },
          {
            "term": "HEAD",
            "definition": "Verbe HTTP identique à GET mais sans le corps (en-têtes seuls). Safe et idempotent.",
            "example": null
          },
          {
            "term": "POST",
            "definition": "Verbe HTTP servant à créer une ressource sans en fournir l'identifiant. Ni safe ni idempotent.",
            "example": null
          },
          {
            "term": "PUT",
            "definition": "Verbe HTTP réalisant une mise à jour complète de la ressource (ou sa création avec identifiant fourni). Idempotent.",
            "example": null
          },
          {
            "term": "DELETE",
            "definition": "Verbe HTTP servant à supprimer une ressource. Idempotent.",
            "example": null
          },
          {
            "term": "OPTIONS",
            "definition": "Verbe HTTP listant les actions possibles sur une ressource. Safe et idempotent.",
            "example": null
          },
          {
            "term": "PATCH",
            "definition": "Verbe HTTP réalisant une mise à jour partielle d'une ressource (RFC 5789). Ni safe ni idempotent.",
            "example": null
          },
          {
            "term": "Content-Type / Accept",
            "definition": "En-têtes HTTP indiquant respectivement le format de données envoyé (Content-Type) et le format attendu en réponse (Accept).",
            "example": null
          },
          {
            "term": "Internet Media Type (MIME)",
            "definition": "Identifiant standard d'un format de données utilisé dans les en-têtes HTTP (ex. text/plain, application/json, application/xml).",
            "example": "application/json"
          },
          {
            "term": "Code HTTP",
            "definition": "Code numérique de retour indiquant le résultat d'une requête : 2xx succès, 4xx erreur client, 5xx erreur serveur.",
            "example": null
          },
          {
            "term": "200 OK",
            "definition": "Code de succès générique indiquant que la requête a abouti.",
            "example": null
          },
          {
            "term": "201 Created",
            "definition": "Code de succès indiquant qu'une ressource a été créée (typiquement après un POST), avec souvent un en-tête Location.",
            "example": null
          },
          {
            "term": "204 No Content",
            "definition": "Code de succès sans corps de réponse, par exemple après un DELETE.",
            "example": null
          },
          {
            "term": "206 Partial Content",
            "definition": "Code indiquant un résultat partiel, utilisé notamment pour la pagination.",
            "example": null
          },
          {
            "term": "304 Not Modified",
            "definition": "Code indiquant que la ressource n'a pas changé et que la version en cache reste utilisable.",
            "example": null
          },
          {
            "term": "400 Bad Request",
            "definition": "Code d'erreur client indiquant une requête invalide.",
            "example": null
          },
          {
            "term": "401 Unauthorized",
            "definition": "Code d'erreur client indiquant qu'une authentification est requise.",
            "example": null
          },
          {
            "term": "403 Forbidden",
            "definition": "Code d'erreur client indiquant un utilisateur authentifié mais non autorisé à accéder à la ressource.",
            "example": null
          },
          {
            "term": "404 Not Found",
            "definition": "Code d'erreur client indiquant que la ressource demandée n'existe pas.",
            "example": null
          },
          {
            "term": "500 Internal Server Error",
            "definition": "Code d'erreur générique signalant un problème côté serveur.",
            "example": null
          },
          {
            "term": "Query string",
            "definition": "Paramètres passés dans l'URL après le ? servant au filtrage, au tri et à la pagination.",
            "example": "/Persons?page=2&page_size=10&sort=name"
          },
          {
            "term": "Pagination",
            "definition": "Découpage d'une grande collection en pages, généralement piloté via des paramètres de query string (page, page_size).",
            "example": null
          },
          {
            "term": "Projection de champs",
            "definition": "Sélection des champs renvoyés pour une ressource via la query string afin d'alléger la réponse.",
            "example": "/Persons/1?fields=email,firstname"
          },
          {
            "term": "Versionnement d'API",
            "definition": "Gestion de versions distinctes d'une API en préfixant l'URL (ex. /api/v1/..., /api/v2/...).",
            "example": null
          },
          {
            "term": "Échange REST",
            "definition": "Un échange REST est un échange HTTP : requête (verbe + URL + version + en-tête + corps) et réponse (code + en-tête + corps éventuel, parfois encapsulé dans une enveloppe).",
            "example": null
          },
          {
            "term": "Outils de test REST",
            "definition": "Outils permettant d'émettre des requêtes pour tester une API : curl (ligne de commande), Postman et RestClient.",
            "example": null
          },
          {
            "term": "HttpURLConnection",
            "definition": "Client HTTP natif de Java utilisé pour les appels REST dans les cas simples.",
            "example": null
          },
          {
            "term": "Client Jakarta REST",
            "definition": "Client REST de l'API Jakarta (ex-JAX-RS), fluide et recommandé en entreprise, par opposition au client HTTP natif ou aux clients asynchrones et Quarkus.",
            "example": null
          },
          {
            "term": "Client asynchrone",
            "definition": "Client REST non bloquant et haute performance (non-blocking I/O, back-pressure), favorisant scalabilité et résilience.",
            "example": null
          },
          {
            "term": "ClientBuilder",
            "definition": "Factory de l'API cliente Jakarta REST permettant de créer un Client en configurant timeout, features et providers.",
            "example": null
          },
          {
            "term": "Interface Client",
            "definition": "Interface principale du client Jakarta REST, qui crée des WebTarget.",
            "example": null
          },
          {
            "term": "WebTarget",
            "definition": "Représentation d'une cible (URI) côté client Jakarta REST permettant la construction fluide des URLs et des paramètres.",
            "example": "client.target(url).path(\"{id}\")"
          },
          {
            "term": "Entity.entity",
            "definition": "Méthode cliente Jakarta REST qui encapsule les données à envoyer avec leur type MIME (POST/PUT).",
            "example": "Entity.entity(data, MediaType.APPLICATION_JSON)"
          },
          {
            "term": "GenericType",
            "definition": "Classe permettant de gérer les types génériques lors de la désérialisation côté client (ex. une liste typée).",
            "example": "GenericType<List<Book>>"
          },
          {
            "term": "ProcessingException",
            "definition": "Exception du client Jakarta REST signalant un problème réseau ou d'entrée/sortie.",
            "example": null
          },
          {
            "term": "WebApplicationException",
            "definition": "Exception représentant une erreur HTTP 4xx/5xx, utilisable côté client comme côté serveur JAX-RS.",
            "example": null
          },
          {
            "term": "ResponseProcessingException",
            "definition": "Exception du client Jakarta REST survenant lors de la désérialisation de la réponse.",
            "example": null
          }
        ]
      },
      {
        "slug": "jaxrs",
        "name": "JAX-RS / Jakarta",
        "emoji": "☕",
        "order": 8,
        "cards": [
          {
            "term": "Jakarta RESTful Web Services (JAX-RS)",
            "definition": "Standard Java pour créer des serveurs et des clients REST ; version étudiée 3.1.",
            "example": null
          },
          {
            "term": "Jersey",
            "definition": "Implémentation de référence de JAX-RS (sérialisation JSON via Jackson, XML via JAXB).",
            "example": null
          },
          {
            "term": "Grizzly",
            "definition": "Serveur web Java léger utilisé dans le cours pour héberger l'application de démonstration.",
            "example": null
          },
          {
            "term": "Application (JAX-RS)",
            "definition": "Côté serveur, composant qui configure les packages scannés pour découvrir les ressources.",
            "example": "new ResourceConfig().packages(...)"
          },
          {
            "term": "Ressource JAX-RS",
            "definition": "Classe annotée @Path dont une instance est créée par requête puis détruite.",
            "example": null
          },
          {
            "term": "@Path",
            "definition": "Annotation définissant le chemin URL d'une ressource ou d'une méthode, avec possibilité d'expression régulière sur les segments.",
            "example": "@Path(\"{id: [0-9]+}\")"
          },
          {
            "term": "@Produces",
            "definition": "Annotation indiquant le ou les types MIME renvoyés par une méthode (plusieurs possibles).",
            "example": "@Produces(MediaType.APPLICATION_JSON)"
          },
          {
            "term": "@Consumes",
            "definition": "Annotation indiquant le ou les types MIME acceptés dans le corps d'une requête (PUT/POST).",
            "example": null
          },
          {
            "term": "@PathParam",
            "definition": "Annotation injectant dans un paramètre de méthode un segment de l'URL déclaré dans le @Path.",
            "example": "@PathParam(\"id\")"
          },
          {
            "term": "@QueryParam",
            "definition": "Annotation injectant un paramètre de la query string dans un paramètre de méthode.",
            "example": "@QueryParam(\"page\")"
          },
          {
            "term": "@HeaderParam",
            "definition": "Annotation injectant la valeur d'un en-tête HTTP dans un paramètre de méthode.",
            "example": null
          },
          {
            "term": "@FormParam",
            "definition": "Annotation injectant la valeur d'un champ de formulaire dans un paramètre de méthode.",
            "example": null
          },
          {
            "term": "@DefaultValue",
            "definition": "Annotation fournissant la valeur par défaut d'un paramètre injecté lorsqu'il est absent.",
            "example": null
          },
          {
            "term": "@BeanParam",
            "definition": "Annotation regroupant plusieurs paramètres d'une requête dans un seul objet.",
            "example": null
          },
          {
            "term": "Response",
            "definition": "Objet représentant une réponse HTTP (statut, en-têtes, corps), construit manuellement côté serveur ou encapsulant la réponse côté client.",
            "example": "Response.status(...).entity(...).build()"
          },
          {
            "term": "MessageBodyWriter / Reader",
            "definition": "Composants JAX-RS convertissant automatiquement un objet Java en corps HTTP (Writer) et inversement le corps reçu en objet Java (Reader).",
            "example": null
          },
          {
            "term": "@Provider",
            "definition": "Annotation marquant une classe qui étend JAX-RS : conversion de données, traitement d'exceptions ou filtres.",
            "example": null
          },
          {
            "term": "ExceptionMapper",
            "definition": "Provider transformant automatiquement une exception Java en réponse HTTP (Response), remplaçant les try/catch dispersés.",
            "example": null
          },
          {
            "term": "Filtre (Container Request/Response Filter)",
            "definition": "Intercepteur exécuté avant le traitement d'une requête (ContainerRequestFilter, ex. sécurité) ou après (ContainerResponseFilter), par exemple pour ajuster le code de statut.",
            "example": null
          },
          {
            "term": "WADL",
            "definition": "Langage de description spécifique aux API REST ; Jersey génère automatiquement /application.wadl si JAXB est présent.",
            "example": null
          },
          {
            "term": "WSDL",
            "definition": "Langage de description de services Web, plus orienté SOAP que REST.",
            "example": null
          }
        ]
      },
      {
        "slug": "serialisation",
        "name": "Sérialisation XML / JSON",
        "emoji": "🔄",
        "order": 9,
        "cards": [
          {
            "term": "Sérialisation / désérialisation",
            "definition": "Conversion d'un objet Java en format texte (XML ou JSON) et inversement.",
            "example": null
          },
          {
            "term": "XML",
            "definition": "Format de données balisé, standard W3C : verbeux mais riche.",
            "example": null
          },
          {
            "term": "JSON",
            "definition": "Format texte léger d'échange de données structurées, standard ECMA-404, devenu le format de facto des API REST.",
            "example": null
          },
          {
            "term": "JAXB (Jakarta XML Binding)",
            "definition": "API standard de mapping XML ↔ Java par annotations (module jersey-media-jaxb).",
            "example": null
          },
          {
            "term": "Marshalling / Unmarshalling",
            "definition": "Conversion Java → XML (marshalling) et XML → Java (unmarshalling), réalisée via un JAXBContext.",
            "example": null
          },
          {
            "term": "@XmlRootElement",
            "definition": "Annotation JAXB déclarant qu'une classe correspond à un élément XML racine.",
            "example": null
          },
          {
            "term": "@XmlAccessorType",
            "definition": "Annotation JAXB indiquant que les annotations de mapping portent sur les champs (utile avec Lombok).",
            "example": null
          },
          {
            "term": "@XmlAttribute",
            "definition": "Annotation JAXB représentant une propriété sous forme d'attribut XML plutôt que d'élément.",
            "example": null
          },
          {
            "term": "@XmlElement",
            "definition": "Annotation JAXB représentant une propriété sous forme d'élément XML.",
            "example": null
          },
          {
            "term": "@XmlTransient",
            "definition": "Annotation JAXB excluant une propriété de la sérialisation XML.",
            "example": null
          },
          {
            "term": "@XmlElementWrapper",
            "definition": "Annotation JAXB ajoutant un élément parent englobant une collection.",
            "example": null
          },
          {
            "term": "@XmlValue",
            "definition": "Annotation JAXB désignant le contenu textuel direct de l'élément (une seule propriété par classe).",
            "example": null
          },
          {
            "term": "Constructeur sans paramètre (JAXB)",
            "definition": "Constructeur sans argument, de visibilité au plus protected, obligatoire pour permettre à JAXB de reconstruire l'objet lors de l'unmarshalling.",
            "example": null
          },
          {
            "term": "XSD",
            "definition": "Schéma décrivant la structure d'un document XML ; JAXB peut le générer via un SchemaOutputResolver.",
            "example": null
          },
          {
            "term": "Jackson",
            "definition": "Bibliothèque de (dé)sérialisation JSON (et d'autres formats), plus complète que JSON-B (polymorphisme, collections Eclipse) ; module jersey-media-json-jackson.",
            "example": null
          },
          {
            "term": "ObjectMapper",
            "definition": "Classe centrale de Jackson réalisant la (dé)sérialisation via readValue et writeValue ; son usage est automatique sous JAX-RS.",
            "example": null
          },
          {
            "term": "JSON-B",
            "definition": "Standard officiel Java de binding JSON.",
            "example": null
          },
          {
            "term": "@JsonProperty",
            "definition": "Annotation Jackson définissant le nom d'une propriété JSON.",
            "example": null
          },
          {
            "term": "@JsonPropertyOrder",
            "definition": "Annotation Jackson fixant l'ordre des propriétés dans le JSON produit.",
            "example": null
          },
          {
            "term": "@JsonIgnore",
            "definition": "Annotation Jackson excluant une propriété de la sérialisation ; @JsonIgnoreProperties permet d'en ignorer plusieurs.",
            "example": null
          },
          {
            "term": "@JsonInclude",
            "definition": "Annotation Jackson contrôlant l'inclusion ou l'exclusion des valeurs nulles ou par défaut.",
            "example": null
          },
          {
            "term": "@JsonRootName",
            "definition": "Annotation Jackson définissant le nom de l'élément wrapper englobant l'objet.",
            "example": null
          },
          {
            "term": "@JsonValue",
            "definition": "Annotation Jackson désignant la méthode unique qui fournit le contenu sérialisé de l'objet.",
            "example": null
          },
          {
            "term": "Type polymorphe",
            "definition": "Propriété pouvant contenir différents sous-types, gérée avec @JsonTypeInfo, @JsonSubTypes et @JsonTypeName.",
            "example": null
          },
          {
            "term": "@JsonIdentityInfo",
            "definition": "Annotation Jackson gérant les références cycliques entre objets pour éviter la boucle infinie de sérialisation.",
            "example": null
          },
          {
            "term": "@JsonBackReference / @JsonManagedReference",
            "definition": "Annotations Jackson gérant les références unidirectionnelles entre objets liés.",
            "example": null
          },
          {
            "term": "@JsonView",
            "definition": "Annotation Jackson permettant de définir différentes vues de sérialisation d'un même objet.",
            "example": null
          },
          {
            "term": "JSON-LD / Hydra",
            "definition": "Extensions de JSON : JSON-LD pour les données sémantiques et Hydra, vocabulaire d'API au-dessus de JSON-LD, compatible HATEOAS.",
            "example": null
          },
          {
            "term": "YAML",
            "definition": "Format de sérialisation lisible, alternative à JSON/XML, que Jackson sait également produire.",
            "example": null
          }
        ]
      },
      {
        "slug": "securite-rest",
        "name": "Sécurité des services REST",
        "emoji": "🔒",
        "order": 10,
        "cards": [
          {
            "term": "TLS / SSL",
            "definition": "Protocole de chiffrement sécurisant les échanges réseau.",
            "example": null
          },
          {
            "term": "HTTPS",
            "definition": "HTTP transporté sur TLS : valide l'identité du serveur (certificats) et garantit confidentialité et intégrité des échanges.",
            "example": null
          },
          {
            "term": "Certificat",
            "definition": "Document signé attestant l'identité d'un serveur ; un certificat auto-signé n'est pas validé par une autorité reconnue.",
            "example": null
          },
          {
            "term": "Keystore (.jks)",
            "definition": "Fichier Java stockant clés et certificats, utilisé pour sécuriser directement un serveur (ex. Grizzly).",
            "example": null
          },
          {
            "term": "Reverse proxy",
            "definition": "Serveur placé en façade qui relaie les requêtes vers le serveur applicatif et peut assurer la terminaison TLS (ex. nginx, Traefik).",
            "example": null
          },
          {
            "term": "HTTP/2",
            "definition": "Version performante du protocole HTTP apportant notamment le multiplexage des échanges.",
            "example": null
          },
          {
            "term": "Authentification",
            "definition": "Vérification de l'identité d'un utilisateur, reposant idéalement sur une gestion des mots de passe hashés.",
            "example": null
          },
          {
            "term": "Autorisation",
            "definition": "Vérification des droits d'accès d'un utilisateur déjà authentifié.",
            "example": null
          },
          {
            "term": "Basic Authentication",
            "definition": "Mécanisme transmettant les identifiants encodés en Base64 dans l'en-tête Authorization ; utilisé ici pour obtenir un token.",
            "example": "Authorization: Basic ..."
          },
          {
            "term": "JWT (JSON Web Token)",
            "definition": "Token cryptographique signé par le serveur contenant des claims et à durée de vie limitée, envoyé à chaque requête via l'en-tête Authorization.",
            "example": "Authorization: Bearer <token>"
          },
          {
            "term": "JJWT",
            "definition": "Bibliothèque Java de manipulation des JWT (création, signature, vérification).",
            "example": "Jwts.parser().verifyWith(KEY)...parseSignedClaims(token)"
          },
          {
            "term": "RBAC (Role-Based Access Control)",
            "definition": "Contrôle d'accès fondé sur les rôles attribués aux utilisateurs ; embarqué dans le JWT, il cumule authentification et autorisation, un changement de droits ne s'appliquant qu'à l'expiration du token.",
            "example": null
          },
          {
            "term": "Claim",
            "definition": "Information (rôle, identité, expiration) contenue dans un JWT.",
            "example": null
          }
        ]
      },
      {
        "slug": "quarkus",
        "name": "Quarkus & Architecture",
        "emoji": "⚡",
        "order": 11,
        "cards": [
          {
            "term": "Quarkus",
            "definition": "Framework Java cloud-native pour microservices, optimisé pour un démarrage rapide et une faible empreinte mémoire.",
            "example": null
          },
          {
            "term": "Dev mode",
            "definition": "Mode de développement Quarkus avec rechargement à chaud, exposant aussi Swagger UI (/q/swagger-ui) et une console dev (/q/dev).",
            "example": "./mvnw quarkus:dev"
          },
          {
            "term": "Image native (GraalVM)",
            "definition": "Binaire compilé en amont offrant un démarrage très rapide et une très faible empreinte mémoire.",
            "example": null
          },
          {
            "term": "JIB",
            "definition": "Outil de construction d'images Docker sans Dockerfile.",
            "example": null
          },
          {
            "term": "Testcontainers",
            "definition": "Bibliothèque lançant des conteneurs (ex. PostgreSQL) le temps des tests, par exemple via ./mvnw clean verify.",
            "example": null
          },
          {
            "term": "CDI (Contexts and Dependency Injection)",
            "definition": "Mécanisme d'injection de dépendances utilisé dans Quarkus.",
            "example": "@Inject"
          },
          {
            "term": "Architecture 3-tiers",
            "definition": "Séparation en couches présentation (Resource = contrôleur), métier (Service) et persistance (Repository).",
            "example": null
          },
          {
            "term": "Séparation des responsabilités",
            "definition": "Découpage du code en couches distinctes : API, DTO, Mapper, domaine, persistance et service.",
            "example": null
          },
          {
            "term": "DTO (Data Transfer Object)",
            "definition": "Objet d'échange qui découple le contrat d'API du modèle de données interne, garantissant la stabilité du contrat et empêchant les entités de fuiter dans l'API.",
            "example": null
          },
          {
            "term": "Mapper",
            "definition": "Composant convertissant les entités en DTO et inversement.",
            "example": null
          },
          {
            "term": "Entité (JPA)",
            "definition": "Classe Java mappée sur une table de base de données.",
            "example": null
          },
          {
            "term": "ID technique / clé métier",
            "definition": "L'ID technique (ex. Long id) est la clé primaire interne en base, jamais exposée ; la clé métier (ex. String sku) est l'identifiant public de la ressource.",
            "example": null
          },
          {
            "term": "Repository pattern",
            "definition": "Abstraction centralisant l'accès aux données, réalisée soit en JPA standard (EntityManager + JPQL), soit avec Hibernate Panache (PanacheRepository).",
            "example": null
          },
          {
            "term": "JPA / JPQL",
            "definition": "JPA est l'API de persistance Java ; JPQL est son langage de requêtes orienté objet.",
            "example": null
          },
          {
            "term": "EntityManager",
            "definition": "Gestionnaire JPA du contexte de persistance, utilisé pour les opérations de lecture/écriture en base.",
            "example": null
          },
          {
            "term": "Hibernate Panache",
            "definition": "Surcouche Quarkus simplifiant l'accès aux données (CRUD sans boilerplate), avec des requêtes concises.",
            "example": "list(\"stock > 0\")"
          },
          {
            "term": "Modèle anémique / riche",
            "definition": "Le modèle anémique est une entité réduite aux données seules ; le modèle riche est un objet métier auto-validant et immuable (souvent un Record sans dépendance framework).",
            "example": null
          },
          {
            "term": "Java Record",
            "definition": "Classe immuable et concise, idéale pour un modèle de domaine pur, capable de s'auto-valider via un constructeur compact.",
            "example": null
          },
          {
            "term": "Bean Validation",
            "definition": "Validation déclarative des données en entrée à l'aide d'annotations de contraintes.",
            "example": "@Valid"
          },
          {
            "term": "OpenAPI / Swagger UI",
            "definition": "Spécification (OpenAPI) et interface de documentation interactive (Swagger UI) d'une API.",
            "example": null
          },
          {
            "term": "MicroProfile Rest Client",
            "definition": "Client REST déclaratif servant de contrat d'API, utilisé notamment pour les tests (BDD/Gherkin).",
            "example": null
          },
          {
            "term": "Configuration externalisée",
            "definition": "Configuration séparée du code via application.properties, profils (ex. %test) et variables d'environnement.",
            "example": null
          },
          {
            "term": "Prometheus / Grafana",
            "definition": "Prometheus collecte les métriques (ex. endpoint /metrics) et Grafana les visualise sous forme de tableaux de bord.",
            "example": null
          },
          {
            "term": "Traefik",
            "definition": "Reverse proxy et routeur assurant la terminaison TLS devant les services.",
            "example": null
          },
          {
            "term": "Maven",
            "definition": "Outil de build et de gestion des dépendances Java, configuré via le fichier pom.xml.",
            "example": null
          }
        ]
      }
    ]
  }
]