{
  "schemaVersion": "1.0.0",
  "language": "en",
  "attribution": "Tech Dictionary contributors",
  "license": {
    "spdx": "CC-BY-4.0",
    "url": "https://creativecommons.org/licenses/by/4.0/"
  },
  "categories": [
    {
      "id": "computer-basics",
      "name": "Computer basics",
      "shortName": "Basics",
      "description": "The bits, bytes, and boxes underneath it all.",
      "color": "teal"
    },
    {
      "id": "programming",
      "name": "Programming",
      "shortName": "Code",
      "description": "How we tell computers what to do.",
      "color": "blue"
    },
    {
      "id": "web",
      "name": "Web development",
      "shortName": "Web",
      "description": "The ingredients that make websites work.",
      "color": "purple"
    },
    {
      "id": "data",
      "name": "Data & databases",
      "shortName": "Data",
      "description": "Storing, finding, and making sense of information.",
      "color": "amber"
    },
    {
      "id": "ai",
      "name": "AI & machine learning",
      "shortName": "AI",
      "description": "Models that learn patterns, and the limits to remember.",
      "color": "pink"
    },
    {
      "id": "devops",
      "name": "Cloud & DevOps",
      "shortName": "Cloud",
      "description": "Getting software out into the world and keeping it running.",
      "color": "blue"
    },
    {
      "id": "security",
      "name": "Security",
      "shortName": "Security",
      "description": "Keeping systems, people, and secrets safe.",
      "color": "pink"
    },
    {
      "id": "networking",
      "name": "Networks",
      "shortName": "Networks",
      "description": "How computers talk across a room or around the world.",
      "color": "teal"
    },
    {
      "id": "tools",
      "name": "Developer tools",
      "shortName": "Tools",
      "description": "The everyday kit for building together.",
      "color": "purple"
    },
    {
      "id": "product",
      "name": "Product & design",
      "shortName": "Product",
      "description": "Making things people can actually use.",
      "color": "amber"
    }
  ],
  "terms": [
    {
      "id": "ab-test",
      "term": "A/B test",
      "aliases": [
        "split test",
        "experimentation"
      ],
      "category": "product",
      "level": "intermediate",
      "tags": [
        "product"
      ],
      "definition": "An experiment that compares randomly assigned groups exposed to different variants.",
      "analogy": "Two versions entering a fair contest, with users rather than opinions keeping score.",
      "example": "An experiment compares two onboarding flows on completion rate.",
      "caveat": "Valid conclusions need an appropriate design, sample, and analysis.",
      "related": [
        "iteration",
        "kpi"
      ],
      "sources": [
        {
          "title": "GOV.UK: User research in live",
          "url": "https://www.gov.uk/service-manual/user-research/user-research-in-live"
        }
      ]
    },
    {
      "id": "access-token",
      "term": "Access token",
      "aliases": [
        "OAuth access token"
      ],
      "category": "security",
      "level": "intermediate",
      "tags": [
        "security"
      ],
      "definition": "A credential a client presents to access protected resources within granted permissions and a limited lifetime.",
      "analogy": "A timed gym pass that opens the approved rooms, not the owner's office.",
      "example": "A client sends Authorization: Bearer <access-token> to an API over HTTPS.",
      "caveat": "Access tokens need not be JWTs. A bearer token can be used by whoever obtains it, so protect it and validate it.",
      "related": [
        "refresh-token",
        "jwt",
        "authorization"
      ],
      "sources": [
        {
          "title": "RFC 6749: Access Token",
          "url": "https://www.rfc-editor.org/rfc/rfc6749#section-1.4"
        }
      ]
    },
    {
      "id": "accessibility",
      "term": "Accessibility",
      "aliases": [
        "a11y",
        "accessible design"
      ],
      "category": "product",
      "level": "beginner",
      "tags": [
        "product"
      ],
      "definition": "Designing and building so people with diverse abilities can perceive and use a product.",
      "analogy": "Making the front door usable for more people, instead of offering a mysterious side quest.",
      "example": "Keyboard users should be able to reach and operate every search control.",
      "caveat": "Accessibility is ongoing work across content, design, and implementation.",
      "related": [
        "ui",
        "semantic-html"
      ],
      "sources": [
        {
          "title": "W3C accessibility fundamentals",
          "url": "https://www.w3.org/WAI/fundamentals/accessibility-intro/"
        }
      ]
    },
    {
      "id": "acid",
      "term": "ACID",
      "aliases": [
        "atomicity consistency isolation durability"
      ],
      "category": "data",
      "level": "advanced",
      "tags": [
        "data"
      ],
      "definition": "Four transaction properties: atomicity, consistency, isolation, and durability.",
      "analogy": "The database's promise to avoid half-finished, chaotic bookkeeping.",
      "example": "A committed bank transfer should not vanish after a restart.",
      "caveat": "ACID consistency concerns data rules; it is not the same as distributed replica consistency.",
      "related": [
        "transaction",
        "database"
      ],
      "sources": [
        {
          "title": "PostgreSQL documentation",
          "url": "https://www.postgresql.org/docs/current/"
        },
        {
          "title": "Google ML Glossary",
          "url": "https://developers.google.com/machine-learning/glossary"
        }
      ]
    },
    {
      "id": "ai-agent",
      "term": "AI agent",
      "aliases": [
        "agent",
        "agentic AI"
      ],
      "category": "ai",
      "level": "intermediate",
      "tags": [
        "ai"
      ],
      "definition": "A system that observes a situation and selects actions toward a goal, sometimes using models and tools.",
      "analogy": "An assistant with a to-do list and tool access, who still needs sensible boundaries.",
      "example": "An agent can look up an issue, propose a fix, and run checks.",
      "caveat": "Autonomy and capabilities vary; 'agent' has no single universal implementation.",
      "related": [
        "api",
        "reinforcement-learning"
      ],
      "sources": [
        {
          "title": "Google ML Glossary",
          "url": "https://developers.google.com/machine-learning/glossary"
        }
      ]
    },
    {
      "id": "ajax",
      "term": "Ajax",
      "aliases": [
        "AJAX",
        "Asynchronous JavaScript and XML"
      ],
      "category": "web",
      "level": "beginner",
      "tags": [
        "web"
      ],
      "definition": "A technique for exchanging data with a server and updating part of a page without a full page reload.",
      "analogy": "Replacing one dish on the table instead of rebuilding the restaurant after every order.",
      "example": "A search field fetches matching terms and updates the result list while the page stays open.",
      "caveat": "Despite the name, Ajax can use JSON rather than XML. It is a technique, not one specific library or transport API.",
      "related": [
        "fetch-api",
        "xmlhttprequest",
        "json"
      ],
      "sources": [
        {
          "title": "MDN: Ajax",
          "url": "https://developer.mozilla.org/en-US/docs/Glossary/AJAX"
        }
      ]
    },
    {
      "id": "algorithm",
      "term": "Algorithm",
      "aliases": [],
      "category": "programming",
      "level": "beginner",
      "tags": [
        "programming"
      ],
      "definition": "A sequence of steps for solving a problem or performing a task.",
      "analogy": "A recipe for your computer, with fewer inspirational life stories.",
      "example": "To find the largest number, compare each number with the biggest so far.",
      "caveat": "An algorithm can be described without writing code.",
      "related": [
        "data-structure",
        "big-o"
      ],
      "sources": [
        {
          "title": "Python language tutorial",
          "url": "https://docs.python.org/3/tutorial/"
        },
        {
          "title": "MDN Glossary",
          "url": "https://developer.mozilla.org/en-US/docs/Glossary"
        }
      ]
    },
    {
      "id": "api",
      "term": "API",
      "aliases": [
        "Application Programming Interface"
      ],
      "category": "web",
      "level": "beginner",
      "tags": [
        "web"
      ],
      "definition": "A defined way for one piece of software to request capabilities or data from another.",
      "analogy": "A restaurant menu for programs: it tells them what they can order without revealing the kitchen wiring.",
      "example": "GET /api/terms?q=react is one operation in a web API for searching terms.",
      "caveat": "An API need not use HTTP or even a network; a library's exported functions also form an API.",
      "related": [
        "endpoint",
        "http",
        "library"
      ],
      "sources": [
        {
          "title": "MDN: API",
          "url": "https://developer.mozilla.org/en-US/docs/Glossary/API"
        }
      ]
    },
    {
      "id": "api-driven-component",
      "term": "API-driven component",
      "aliases": [
        "API driven component",
        "data-driven component"
      ],
      "category": "web",
      "level": "intermediate",
      "tags": [
        "web",
        "react"
      ],
      "definition": "A UI component whose displayed data or behavior is supplied through an API, directly or through a data-loading layer.",
      "analogy": "A menu board that checks the kitchen before promising everyone unlimited cake.",
      "example": "A TermList receives API search results and shows loading, success, empty, and error states.",
      "caveat": "This is a descriptive phrase, not a specific React API. Keep networking, cancellation, and presentation boundaries intentional.",
      "related": [
        "react-component",
        "api",
        "fetch-api",
        "state-management"
      ],
      "sources": [
        {
          "title": "API-driven component — reference and documentation",
          "url": "https://react.dev/learn/synchronizing-with-effects#fetching-data"
        }
      ]
    },
    {
      "id": "array",
      "term": "Array",
      "aliases": [
        "JavaScript array",
        "arrays"
      ],
      "category": "programming",
      "level": "beginner",
      "tags": [
        "programming",
        "javascript"
      ],
      "definition": "An ordered JavaScript collection whose elements can be accessed with zero-based indexes.",
      "analogy": "A row of numbered lockers where the first locker insists its number is zero.",
      "example": "const terms = ['API', 'React']; terms[0] returns 'API'.",
      "caveat": "JavaScript arrays can mix value types and change length. They are objects, and many methods mutate them in place.",
      "related": [
        "object",
        "mutation",
        "data-structure"
      ],
      "sources": [
        {
          "title": "MDN: Array",
          "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array"
        }
      ]
    },
    {
      "id": "artificial-intelligence",
      "term": "Artificial intelligence",
      "aliases": [
        "AI"
      ],
      "category": "ai",
      "level": "beginner",
      "tags": [
        "ai"
      ],
      "definition": "A broad field of building systems that perform tasks associated with intelligence.",
      "analogy": "Teaching computers useful tricks without assuming they secretly want a promotion.",
      "example": "An AI system might classify photos or plan a route.",
      "caveat": "Different capabilities do not imply human-like understanding.",
      "related": [
        "machine-learning",
        "generative-ai"
      ],
      "sources": [
        {
          "title": "Google ML Glossary",
          "url": "https://developers.google.com/machine-learning/glossary"
        }
      ]
    },
    {
      "id": "assertion",
      "term": "Assertion",
      "aliases": [
        "test assertion",
        "assert"
      ],
      "category": "tools",
      "level": "beginner",
      "tags": [
        "tools"
      ],
      "definition": "A check that states an expected condition and reports a failure when it is not met.",
      "analogy": "The test's moment of truth: 'I expected tea; this appears to be a stapler.'",
      "example": "expect(results).toHaveLength(3); asserts that a search returned three entries.",
      "caveat": "An assertion checks one claim, not overall correctness. Choose checks that express behavior rather than freezing incidental implementation details.",
      "related": [
        "jest",
        "unit-test",
        "test-suite"
      ],
      "sources": [
        {
          "title": "Assertion — reference and documentation",
          "url": "https://jestjs.io/docs/expect"
        }
      ]
    },
    {
      "id": "asset",
      "term": "Asset",
      "aliases": [
        "web asset",
        "static asset"
      ],
      "category": "web",
      "level": "beginner",
      "tags": [
        "web"
      ],
      "definition": "A resource used by an application, such as an image, stylesheet, script, font, or media file.",
      "analogy": "The website's luggage: some bags contain fonts, others contain a suspiciously large hero image.",
      "example": "A page loads /styles.css, /logo.svg, and /app.js to provide its appearance and behavior.",
      "caveat": "Assets may load through HTML, CSS, or JavaScript, immediately or later. Not every resource is listed in the document's head.",
      "related": [
        "html",
        "css",
        "cdn"
      ],
      "sources": [
        {
          "title": "MDN: Asset",
          "url": "https://developer.mozilla.org/en-US/docs/Learn_web_development/Core/Performance/What_is_web_performance"
        }
      ]
    },
    {
      "id": "async-function",
      "term": "async function",
      "aliases": [
        "async",
        "async keyword",
        "async/await",
        "await"
      ],
      "category": "programming",
      "level": "intermediate",
      "tags": [
        "programming",
        "javascript"
      ],
      "definition": "A JavaScript function declared with async that always returns a promise and can use await to pause its own execution for a result.",
      "analogy": "A waiter who can leave your table while an order is pending without closing the restaurant.",
      "example": "async function load() { const r = await fetch('/api/terms'); return r.json(); } returns a promise.",
      "caveat": "await pauses that function, not the entire runtime. async does not move CPU-heavy code to another thread; top-level await is supported in modules.",
      "related": [
        "async",
        "promise",
        "fetch-api"
      ],
      "sources": [
        {
          "title": "MDN: async function",
          "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/async_function"
        }
      ]
    },
    {
      "id": "async",
      "term": "Asynchronous",
      "aliases": [
        "asynchrony",
        "asynchronous operation"
      ],
      "category": "programming",
      "level": "intermediate",
      "tags": [
        "programming",
        "javascript"
      ],
      "definition": "Describes work whose result can arrive later without requiring the caller to block until it completes.",
      "analogy": "Order coffee, do another task, and return when your name is shouted with creative spelling.",
      "example": "A browser can handle user input while an asynchronous network request is pending.",
      "caveat": "Asynchronous does not automatically mean parallel or run on a new thread. Long synchronous JavaScript can still block the UI.",
      "related": [
        "async-function",
        "promise",
        "callback",
        "io"
      ],
      "sources": [
        {
          "title": "MDN: Asynchronous",
          "url": "https://developer.mozilla.org/en-US/docs/Learn_web_development/Extensions/Async_JS/Introducing"
        }
      ]
    },
    {
      "id": "attention",
      "term": "Attention",
      "aliases": [
        "self-attention"
      ],
      "category": "ai",
      "level": "advanced",
      "tags": [
        "ai"
      ],
      "definition": "A mechanism that computes weighted combinations of information according to its relevance.",
      "analogy": "Math deciding which parts of the conversation deserve the loudest microphone.",
      "example": "Self-attention can connect a pronoun to earlier context in a sequence.",
      "caveat": "Attention weights are not a complete explanation of a model's reasoning.",
      "related": [
        "transformer",
        "context-window"
      ],
      "sources": [
        {
          "title": "Attention Is All You Need",
          "url": "https://arxiv.org/abs/1706.03762"
        }
      ]
    },
    {
      "id": "authentication",
      "term": "Authentication",
      "aliases": [
        "authn",
        "login"
      ],
      "category": "security",
      "level": "beginner",
      "tags": [
        "security"
      ],
      "definition": "Checking that someone or something is who it claims to be.",
      "analogy": "The door asking 'who are you?' before doing anything else.",
      "example": "A service verifies a user's password or security key.",
      "caveat": "Proving identity does not establish permission for every action.",
      "related": [
        "authorization",
        "mfa"
      ],
      "sources": [
        {
          "title": "OWASP Cheat Sheet Series",
          "url": "https://cheatsheetseries.owasp.org/"
        }
      ]
    },
    {
      "id": "authorization",
      "term": "Authorization",
      "aliases": [
        "authz",
        "permissions"
      ],
      "category": "security",
      "level": "beginner",
      "tags": [
        "security"
      ],
      "definition": "Checking whether an identity is allowed to perform an action or access a resource.",
      "analogy": "You have an office badge; that still does not give you the CEO's snack drawer.",
      "example": "A server checks whether a user may delete a project.",
      "caveat": "Authorization must be enforced where the protected action occurs.",
      "related": [
        "authentication",
        "least-privilege"
      ],
      "sources": [
        {
          "title": "OWASP Cheat Sheet Series",
          "url": "https://cheatsheetseries.owasp.org/"
        }
      ]
    },
    {
      "id": "babel",
      "term": "Babel",
      "aliases": [
        "Babel.js"
      ],
      "category": "tools",
      "level": "intermediate",
      "tags": [
        "tools",
        "javascript"
      ],
      "definition": "A JavaScript compiler toolchain that can transform newer syntax and JSX into JavaScript suitable for configured target environments.",
      "analogy": "A translator helping modern JavaScript chat with browsers that missed a few language classes.",
      "example": "A build uses @babel/preset-react to transform JSX and @babel/preset-env to target supported browsers.",
      "caveat": "Babel does not always output ES5. Syntax transforms and missing runtime APIs are different problems; APIs may need polyfills.",
      "related": [
        "transpiler",
        "babel-preset",
        "jsx",
        "es6"
      ],
      "sources": [
        {
          "title": "Babel — reference and documentation",
          "url": "https://babeljs.io/docs/"
        }
      ]
    },
    {
      "id": "babel-preset",
      "term": "Babel preset",
      "aliases": [
        "Babel presets"
      ],
      "category": "tools",
      "level": "intermediate",
      "tags": [
        "tools",
        "javascript"
      ],
      "definition": "A reusable bundle of Babel plugins and configuration for a particular transformation goal.",
      "analogy": "A combo meal of compiler settings, hopefully without an unwanted side of legacy browser support.",
      "example": "@babel/preset-react configures JSX-related transforms; @babel/preset-env selects transforms based on targets.",
      "caveat": "A preset is configuration, not the Babel runtime. Its options and installed plugins determine what code is transformed.",
      "related": [
        "babel",
        "transpiler",
        "jsx"
      ],
      "sources": [
        {
          "title": "Babel preset — reference and documentation",
          "url": "https://babeljs.io/docs/presets"
        }
      ]
    },
    {
      "id": "backend",
      "term": "Backend",
      "aliases": [
        "back-end",
        "back end"
      ],
      "category": "web",
      "level": "beginner",
      "tags": [
        "web"
      ],
      "definition": "The server-side part of an application that handles work such as business rules, data access, and authorization.",
      "analogy": "The kitchen and stockroom making sure the attractive menu can actually be fulfilled.",
      "example": "A Node.js API verifies permissions, reads a database, and returns matching dictionary entries.",
      "caveat": "A hidden endpoint is not a security boundary. Validate requests and enforce authorization on the server.",
      "related": [
        "frontend",
        "server",
        "database"
      ],
      "sources": [
        {
          "title": "MDN: Backend",
          "url": "https://developer.mozilla.org/en-US/docs/Learn_web_development/Extensions/Server-side/First_steps/Introduction"
        }
      ]
    },
    {
      "id": "backslash",
      "term": "Backslash",
      "aliases": [
        "reverse solidus"
      ],
      "category": "programming",
      "level": "beginner",
      "tags": [
        "programming",
        "javascript"
      ],
      "definition": "The character \\ used in JavaScript strings to introduce escape sequences and in some systems as a path separator.",
      "analogy": "A tiny leaning bouncer telling the next character, 'You are entering in disguise.'",
      "example": "In JavaScript, '\\n' represents a newline, while '\\\\' represents one literal backslash.",
      "caveat": "A backslash is not a forward slash /. Its meaning depends on the language or context, and nested escaping may require extra care.",
      "related": [
        "string",
        "javascript",
        "windows"
      ],
      "sources": [
        {
          "title": "MDN: Backslash",
          "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Lexical_grammar#string_literals"
        }
      ]
    },
    {
      "id": "backup",
      "term": "Backup",
      "aliases": [
        "restore",
        "recovery"
      ],
      "category": "devops",
      "level": "beginner",
      "tags": [
        "devops"
      ],
      "definition": "A separate copy of data kept so it can be recovered after loss or damage.",
      "analogy": "A spare parachute, whose usefulness depends on whether it actually opens.",
      "example": "A team restores a database from a recent backup during a recovery test.",
      "caveat": "A backup strategy needs tested restoration and appropriate retention.",
      "related": [
        "database",
        "migration"
      ],
      "sources": [
        {
          "title": "Docker documentation",
          "url": "https://docs.docker.com/get-started/"
        },
        {
          "title": "AWS cloud concepts",
          "url": "https://aws.amazon.com/what-is/cloud-computing/"
        }
      ]
    },
    {
      "id": "bandwidth",
      "term": "Bandwidth",
      "aliases": [
        "network capacity"
      ],
      "category": "networking",
      "level": "beginner",
      "tags": [
        "networking"
      ],
      "definition": "The data-carrying capacity of a connection over time.",
      "analogy": "How many lanes the road has, not how fast the first car arrives.",
      "example": "A link rated at 100 Mbps has a stated capacity in bits per second.",
      "caveat": "Actual throughput may be lower than rated bandwidth.",
      "related": [
        "latency",
        "bit"
      ],
      "sources": [
        {
          "title": "MDN Glossary",
          "url": "https://developer.mozilla.org/en-US/docs/Glossary"
        }
      ]
    },
    {
      "id": "behavior-driven-style",
      "term": "Behavior-driven style",
      "aliases": [
        "BDD style",
        "behavior-driven testing",
        "behavior-driven development",
        "BDD"
      ],
      "category": "tools",
      "level": "intermediate",
      "tags": [
        "tools"
      ],
      "definition": "An approach to describing software behavior through concrete scenarios and expected outcomes, often written as Given, When, Then.",
      "analogy": "A rehearsal script saying what the audience should see, rather than listing every screw in the stage.",
      "example": "Given no search matches, when the user searches, then an informative empty state appears.",
      "caveat": "Naming tests describe and it is only a style. Full BDD includes collaborative discovery of behavior, not merely a particular test syntax.",
      "related": [
        "test-suite",
        "assertion",
        "integration-test"
      ],
      "sources": [
        {
          "title": "Behavior-driven style — reference and documentation",
          "url": "https://cucumber.io/docs/bdd/"
        }
      ]
    },
    {
      "id": "big-o",
      "term": "Big O",
      "aliases": [
        "time complexity",
        "space complexity"
      ],
      "category": "programming",
      "level": "intermediate",
      "tags": [
        "programming"
      ],
      "definition": "Notation describing an upper bound on how resource use grows as input size grows.",
      "analogy": "The 'how bad does this get with a million guests?' forecast.",
      "example": "Scanning n items once usually takes O(n) time.",
      "caveat": "It describes growth, not an exact running time in seconds.",
      "related": [
        "algorithm",
        "data-structure"
      ],
      "sources": [
        {
          "title": "Python language tutorial",
          "url": "https://docs.python.org/3/tutorial/"
        },
        {
          "title": "MDN Glossary",
          "url": "https://developer.mozilla.org/en-US/docs/Glossary"
        }
      ]
    },
    {
      "id": "binary",
      "term": "Binary",
      "aliases": [
        "base two"
      ],
      "category": "computer-basics",
      "level": "beginner",
      "tags": [
        "computer-basics"
      ],
      "definition": "A number system that uses just two digits: 0 and 1.",
      "analogy": "Counting with two fingers, but somehow running the internet.",
      "example": "The binary number 101 represents the decimal number 5.",
      "caveat": "Binary is a representation, not a programming language.",
      "related": [
        "bit",
        "hexadecimal"
      ],
      "sources": [
        {
          "title": "MDN Glossary",
          "url": "https://developer.mozilla.org/en-US/docs/Glossary"
        }
      ]
    },
    {
      "id": "bit",
      "term": "Bit",
      "aliases": [
        "binary digit"
      ],
      "category": "computer-basics",
      "level": "beginner",
      "tags": [
        "computer-basics"
      ],
      "definition": "The smallest unit of digital information, with a value of either 0 or 1.",
      "analogy": "A light switch with only two moods: off and on.",
      "example": "Eight bits can represent 256 different combinations.",
      "caveat": "A bit is not the same as a byte.",
      "related": [
        "byte",
        "binary"
      ],
      "sources": [
        {
          "title": "MDN Glossary",
          "url": "https://developer.mozilla.org/en-US/docs/Glossary"
        }
      ]
    },
    {
      "id": "boilerplate",
      "term": "Boilerplate",
      "aliases": [
        "boilerplate code"
      ],
      "category": "programming",
      "level": "beginner",
      "tags": [
        "programming",
        "javascript"
      ],
      "definition": "Repetitive setup or structural code needed before the code specific to a task can do its work.",
      "analogy": "The paperwork you fill in before being allowed to write the interesting sentence.",
      "example": "A project scaffold supplies package scripts, configuration, and starter files before you implement search.",
      "caveat": "Boilerplate can encode useful conventions. Hiding it behind tools reduces repetition but does not remove the need to understand it.",
      "related": [
        "framework",
        "codebase",
        "refactoring"
      ],
      "sources": [
        {
          "title": "MDN: Boilerplate for a WebGL rendering context",
          "url": "https://developer.mozilla.org/en-US/docs/Web/API/WebGL_API/By_example/Boilerplate_1"
        }
      ]
    },
    {
      "id": "boolean",
      "term": "Boolean",
      "aliases": [
        "bool"
      ],
      "category": "programming",
      "level": "beginner",
      "tags": [
        "programming"
      ],
      "definition": "A data type with two values, usually called true and false.",
      "analogy": "A yes-or-no answer that refuses to add 'well, it depends'.",
      "example": "The value isLoggedIn can be true or false.",
      "caveat": "Truthiness rules are language-specific and are not always Boolean values.",
      "related": [
        "data-type",
        "conditional"
      ],
      "sources": [
        {
          "title": "Python language tutorial",
          "url": "https://docs.python.org/3/tutorial/"
        },
        {
          "title": "MDN Glossary",
          "url": "https://developer.mozilla.org/en-US/docs/Glossary"
        }
      ]
    },
    {
      "id": "bootstrap",
      "term": "Bootstrap",
      "aliases": [
        "Bootstrap CSS"
      ],
      "category": "tools",
      "level": "beginner",
      "tags": [
        "tools"
      ],
      "definition": "A frontend toolkit with styles, layout utilities, and components for building responsive interfaces.",
      "analogy": "Flat-pack furniture for websites: a quick start, though every room need not look like the showroom.",
      "example": "Bootstrap classes such as container, row, col-md-6, and btn create a responsive layout and button.",
      "caveat": "Some interactive components need Bootstrap JavaScript. Accessibility still depends on correct markup, labels, contrast, and application behavior.",
      "related": [
        "css",
        "responsive-design",
        "ui-component"
      ],
      "sources": [
        {
          "title": "Bootstrap — reference and documentation",
          "url": "https://getbootstrap.com/docs/5.3/getting-started/introduction/"
        }
      ]
    },
    {
      "id": "branch",
      "term": "Branch",
      "aliases": [
        "git branch"
      ],
      "category": "tools",
      "level": "beginner",
      "tags": [
        "tools"
      ],
      "definition": "A movable reference in version control that lets work develop along a separate line.",
      "analogy": "An alternate timeline where you can experiment before bringing the change home.",
      "example": "A feature branch can hold work on a new category filter.",
      "caveat": "Branches share history; they are not independent copies of everything.",
      "related": [
        "git",
        "merge"
      ],
      "sources": [
        {
          "title": "Pro Git book",
          "url": "https://git-scm.com/book/en/v2"
        }
      ]
    },
    {
      "id": "browser-console",
      "term": "Browser console",
      "aliases": [
        "developer console",
        "DevTools console"
      ],
      "category": "tools",
      "level": "beginner",
      "tags": [
        "tools"
      ],
      "definition": "A developer-tools panel for viewing messages and evaluating JavaScript in the context of a web page.",
      "analogy": "The browser's confession booth, except the errors rarely feel remorse.",
      "example": "console.log({ count: 3 }); displays an inspectable value in the console.",
      "caveat": "Console output can expose sensitive data. Pasting untrusted commands can execute code with the page's privileges.",
      "related": [
        "debugging",
        "javascript",
        "syntax-error-unexpected-token"
      ],
      "sources": [
        {
          "title": "Browser console — reference and documentation",
          "url": "https://developer.chrome.com/docs/devtools/console"
        }
      ]
    },
    {
      "id": "byte",
      "term": "Byte",
      "aliases": [],
      "category": "computer-basics",
      "level": "beginner",
      "tags": [
        "computer-basics"
      ],
      "definition": "A group of eight bits, commonly used to measure data size.",
      "analogy": "Eight tiny switches sharing a very small apartment.",
      "example": "A file of 1,000 bytes is one decimal kilobyte.",
      "caveat": "One character can need more than one byte.",
      "related": [
        "bit",
        "unicode"
      ],
      "sources": [
        {
          "title": "MDN Glossary",
          "url": "https://developer.mozilla.org/en-US/docs/Glossary"
        }
      ]
    },
    {
      "id": "cache",
      "term": "Cache",
      "aliases": [
        "caching"
      ],
      "category": "computer-basics",
      "level": "beginner",
      "tags": [
        "computer-basics"
      ],
      "definition": "A store of reusable results or data that can make future access faster.",
      "analogy": "Keeping your favorite snack on your desk instead of hiking to the kitchen.",
      "example": "A browser caches an image so it need not download it again.",
      "caveat": "Cached data can become stale; freshness needs a plan.",
      "related": [
        "ram",
        "cdn"
      ],
      "sources": [
        {
          "title": "MDN Glossary",
          "url": "https://developer.mozilla.org/en-US/docs/Glossary"
        }
      ]
    },
    {
      "id": "callback",
      "term": "Callback function",
      "aliases": [
        "callback",
        "callbacks"
      ],
      "category": "programming",
      "level": "beginner",
      "tags": [
        "programming",
        "javascript"
      ],
      "definition": "A function supplied to other code so that code can invoke it when appropriate.",
      "analogy": "Leaving your phone number with the restaurant; sometimes they call later, sometimes immediately.",
      "example": "[1, 2, 3].map(n => n * 2) calls the supplied callback for each array element.",
      "caveat": "Callbacks can be synchronous or asynchronous. Passing a function is different from immediately calling it and passing its result.",
      "related": [
        "function",
        "function-argument",
        "async",
        "callback-prop"
      ],
      "sources": [
        {
          "title": "MDN: Callback function",
          "url": "https://developer.mozilla.org/en-US/docs/Glossary/Callback_function"
        }
      ]
    },
    {
      "id": "callback-prop",
      "term": "Callback prop",
      "aliases": [
        "prop-function",
        "function prop",
        "prop function",
        "callback props"
      ],
      "category": "web",
      "level": "beginner",
      "tags": [
        "web",
        "react"
      ],
      "definition": "A function passed as a React prop so a child can notify its parent or request an action.",
      "analogy": "Giving a child component a doorbell instead of the keys to your entire state cupboard.",
      "example": "<SaveButton onSave={saveDraft} /> lets SaveButton call onSave() after a click.",
      "caveat": "Pass the function itself unless you intentionally want to call it during rendering. Name callbacks for the event or action they represent.",
      "related": [
        "props",
        "callback",
        "one-way-data-flow"
      ],
      "sources": [
        {
          "title": "Callback prop — reference and documentation",
          "url": "https://react.dev/learn/responding-to-events"
        }
      ]
    },
    {
      "id": "cdn",
      "term": "CDN",
      "aliases": [
        "Content Delivery Network"
      ],
      "category": "devops",
      "level": "beginner",
      "tags": [
        "devops"
      ],
      "definition": "A distributed network of servers that delivers content from locations closer to users, often with caching.",
      "analogy": "Neighborhood snack depots, so everyone need not travel to the one enormous warehouse.",
      "example": "A CDN caches dictionary images and stylesheets at edge locations near visitors.",
      "caveat": "A CDN does not automatically cache every response or fix a slow origin. Cache rules, freshness, and invalidation matter.",
      "related": [
        "cache",
        "asset",
        "latency"
      ],
      "sources": [
        {
          "title": "CDN — reference and documentation",
          "url": "https://www.cloudflare.com/learning/cdn/what-is-a-cdn/"
        }
      ]
    },
    {
      "id": "chaining",
      "term": "Chaining",
      "aliases": [
        "chain",
        "method chaining",
        "promise chain",
        "promise chaining"
      ],
      "category": "programming",
      "level": "intermediate",
      "tags": [
        "programming",
        "javascript"
      ],
      "definition": "Connecting operations so a returned value or promise becomes the starting point for the next operation.",
      "analogy": "A relay race where the baton is data, and forgetting to return it ruins everyone's afternoon.",
      "example": "fetch('/api/terms').then(r => r.json()).then(terms => terms.length) chains promise-based steps.",
      "caveat": "Return a needed value or promise from each .then handler. Chaining synchronous methods does not make them asynchronous.",
      "related": [
        "promise",
        "method",
        "pipeline"
      ],
      "sources": [
        {
          "title": "MDN: Chaining",
          "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Using_promises"
        }
      ]
    },
    {
      "id": "child-component",
      "term": "Child component",
      "aliases": [
        "React child component"
      ],
      "category": "web",
      "level": "beginner",
      "tags": [
        "web",
        "react"
      ],
      "definition": "A component rendered directly inside another component in the UI tree, often receiving data or callbacks through props.",
      "analogy": "The guest who gets a place at the table and occasionally calls the host for more snacks.",
      "example": "In <Page><Avatar /></Page>, Avatar is passed as a child; Page must render its children to display it.",
      "caveat": "Not every nested HTML node is a React component. A child should not mutate props received from its parent.",
      "related": [
        "parent-component",
        "props",
        "callback-prop"
      ],
      "sources": [
        {
          "title": "Child component — reference and documentation",
          "url": "https://react.dev/learn/passing-props-to-a-component"
        }
      ]
    },
    {
      "id": "claude-code",
      "term": "Claude Code",
      "aliases": [
        "Anthropic Claude Code"
      ],
      "category": "tools",
      "level": "beginner",
      "tags": [
        "tools"
      ],
      "definition": "Anthropic's agentic coding tool that can inspect project files, propose and make changes, run commands, and work with development tools.",
      "analogy": "A fast coding collaborator who can hold the toolbox but still needs a sensible brief and a review.",
      "example": "Ask Claude Code to trace a failing test, change the relevant files, and run the project's checks within granted permissions.",
      "caveat": "It can make incorrect changes or run consequential actions. Review diffs and test results, and limit permissions and sensitive-data exposure appropriately.",
      "related": [
        "ai-agent",
        "harness",
        "codebase",
        "cli"
      ],
      "sources": [
        {
          "title": "Claude Code: Overview",
          "url": "https://code.claude.com/docs/en/overview"
        }
      ]
    },
    {
      "id": "cli",
      "term": "CLI",
      "aliases": [
        "command-line interface",
        "terminal command"
      ],
      "category": "tools",
      "level": "beginner",
      "tags": [
        "tools"
      ],
      "definition": "An interface controlled by typing commands rather than primarily clicking visual controls.",
      "analogy": "Talking to your computer in short, slightly bossy sentences.",
      "example": "Running npm run build uses a command-line interface.",
      "caveat": "A terminal hosts a session; a shell interprets its commands.",
      "related": [
        "shell",
        "gui"
      ],
      "sources": [
        {
          "title": "Bash manual",
          "url": "https://www.gnu.org/software/bash/manual/bash.html"
        }
      ]
    },
    {
      "id": "client",
      "term": "Client",
      "aliases": [
        "web client"
      ],
      "category": "networking",
      "level": "beginner",
      "tags": [
        "networking"
      ],
      "definition": "A program or device that requests a resource or service from a server.",
      "analogy": "The diner placing an order, even when the diner is another restaurant.",
      "example": "A browser requests a dictionary page; a backend service can also act as a client of another API.",
      "caveat": "Client does not always mean browser or end user. The role depends on the specific interaction.",
      "related": [
        "server",
        "frontend",
        "http"
      ],
      "sources": [
        {
          "title": "MDN: Client",
          "url": "https://developer.mozilla.org/en-US/docs/Learn_web_development/Extensions/Server-side/First_steps/Client-Server_overview"
        }
      ]
    },
    {
      "id": "cloud-computing",
      "term": "Cloud computing",
      "aliases": [
        "cloud"
      ],
      "category": "devops",
      "level": "beginner",
      "tags": [
        "devops"
      ],
      "definition": "Using computing resources provided over a network, often on demand.",
      "analogy": "Renting a kitchen when you need it instead of owning every oven.",
      "example": "A team rents virtual servers to run an application.",
      "caveat": "The cloud still runs on physical computers someone manages.",
      "related": [
        "server",
        "serverless"
      ],
      "sources": [
        {
          "title": "Docker documentation",
          "url": "https://docs.docker.com/get-started/"
        },
        {
          "title": "AWS cloud concepts",
          "url": "https://aws.amazon.com/what-is/cloud-computing/"
        }
      ]
    },
    {
      "id": "code-review",
      "term": "Code review",
      "aliases": [
        "review"
      ],
      "category": "tools",
      "level": "intermediate",
      "tags": [
        "tools"
      ],
      "definition": "Examining a proposed code change for correctness, clarity, and other project requirements.",
      "analogy": "A second pair of eyes before the recipe goes on the restaurant menu.",
      "example": "A reviewer spots missing error handling in a pull request.",
      "caveat": "Review complements automated checks; neither replaces the other.",
      "related": [
        "pull-request",
        "unit-test"
      ],
      "sources": [
        {
          "title": "Pro Git book",
          "url": "https://git-scm.com/book/en/v2"
        }
      ]
    },
    {
      "id": "codebase",
      "term": "Codebase",
      "aliases": [
        "code base"
      ],
      "category": "tools",
      "level": "beginner",
      "tags": [
        "tools"
      ],
      "definition": "The collection of source code and related project files that make up a software system or maintained project.",
      "analogy": "The whole kitchen cookbook, including the handwritten notes nobody admits they added.",
      "example": "A codebase may contain React components, server handlers, YAML data, tests, and build configuration.",
      "caveat": "A codebase is not always one repository, and a repository may contain several applications or packages.",
      "related": [
        "repository",
        "module",
        "refactoring"
      ],
      "sources": [
        {
          "title": "Codebase — reference and documentation",
          "url": "https://12factor.net/codebase"
        }
      ]
    },
    {
      "id": "commit",
      "term": "Commit",
      "aliases": [
        "git commit"
      ],
      "category": "tools",
      "level": "beginner",
      "tags": [
        "tools"
      ],
      "definition": "A recorded snapshot in version history with metadata and a message.",
      "analogy": "A save point with a note explaining what happened.",
      "example": "A commit can record a fix to a broken search filter.",
      "caveat": "A local commit is not automatically uploaded to a remote.",
      "related": [
        "git",
        "pull-request"
      ],
      "sources": [
        {
          "title": "Pro Git book",
          "url": "https://git-scm.com/book/en/v2"
        }
      ]
    },
    {
      "id": "compiler",
      "term": "Compiler",
      "aliases": [
        "compilation"
      ],
      "category": "programming",
      "level": "intermediate",
      "tags": [
        "programming"
      ],
      "definition": "A program that translates source code into another form, often machine code.",
      "analogy": "The translator who prepares the whole speech before the show.",
      "example": "A C compiler can produce an executable from source files.",
      "caveat": "Compilation and interpretation can coexist in one runtime.",
      "related": [
        "interpreter",
        "runtime"
      ],
      "sources": [
        {
          "title": "Python language tutorial",
          "url": "https://docs.python.org/3/tutorial/"
        },
        {
          "title": "MDN Glossary",
          "url": "https://developer.mozilla.org/en-US/docs/Glossary"
        }
      ]
    },
    {
      "id": "concurrency",
      "term": "Concurrency",
      "aliases": [
        "concurrent"
      ],
      "category": "programming",
      "level": "intermediate",
      "tags": [
        "programming"
      ],
      "definition": "Organizing multiple tasks so they can make progress during overlapping periods.",
      "analogy": "One chef switching between dishes while different pots simmer.",
      "example": "A server can handle other requests while one waits for a database.",
      "caveat": "Concurrent work may run on a single processor core.",
      "related": [
        "parallelism",
        "async"
      ],
      "sources": [
        {
          "title": "Python language tutorial",
          "url": "https://docs.python.org/3/tutorial/"
        },
        {
          "title": "MDN Glossary",
          "url": "https://developer.mozilla.org/en-US/docs/Glossary"
        }
      ]
    },
    {
      "id": "conditional",
      "term": "Conditional",
      "aliases": [
        "if statement",
        "branching"
      ],
      "category": "programming",
      "level": "beginner",
      "tags": [
        "programming"
      ],
      "definition": "Code that chooses what to do based on whether a condition is true.",
      "analogy": "The fork in the road, minus the dramatic movie soundtrack.",
      "example": "If the cart is empty, hide the checkout button.",
      "caveat": "Several conditions can overlap; their order may matter.",
      "related": [
        "boolean",
        "loop"
      ],
      "sources": [
        {
          "title": "Python language tutorial",
          "url": "https://docs.python.org/3/tutorial/"
        },
        {
          "title": "MDN Glossary",
          "url": "https://developer.mozilla.org/en-US/docs/Glossary"
        }
      ]
    },
    {
      "id": "const",
      "term": "const",
      "aliases": [
        "const declaration"
      ],
      "category": "programming",
      "level": "beginner",
      "tags": [
        "programming",
        "javascript"
      ],
      "definition": "A JavaScript declaration for a block-scoped binding that cannot be reassigned after initialization.",
      "analogy": "A permanent name tag on a box, not a promise that nobody can rearrange its contents.",
      "example": "const user = { name: 'Ada' }; user.name = 'Grace'; is allowed, but user = {}; is not.",
      "caveat": "const does not make objects or arrays immutable. A const declaration needs an initializer and has a temporal dead zone.",
      "related": [
        "let",
        "immutable",
        "variable-assignment"
      ],
      "sources": [
        {
          "title": "MDN: const",
          "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/const"
        }
      ]
    },
    {
      "id": "constructor",
      "term": "Constructor",
      "aliases": [
        "class constructor"
      ],
      "category": "programming",
      "level": "beginner",
      "tags": [
        "programming",
        "javascript"
      ],
      "definition": "A function or class method used to initialize an object when an instance is created.",
      "analogy": "The move-in checklist that gives a new object its keys, furniture, and unreasonable defaults.",
      "example": "class User { constructor(name) { this.name = name; } } initializes new User('Ada').",
      "caveat": "React function components have no constructor method. Class constructors and ordinary function calls have different rules.",
      "related": [
        "object",
        "function",
        "initial-state"
      ],
      "sources": [
        {
          "title": "MDN: Constructor",
          "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes/constructor"
        }
      ]
    },
    {
      "id": "container",
      "term": "Container",
      "aliases": [
        "containerization"
      ],
      "category": "devops",
      "level": "intermediate",
      "tags": [
        "devops"
      ],
      "definition": "An isolated execution environment that packages an application with needed user-space dependencies.",
      "analogy": "Your app's packed lunch: familiar ingredients, wherever lunch happens.",
      "example": "A Docker container can run an app with its required libraries.",
      "caveat": "Containers commonly share the host kernel; they are not full virtual machines.",
      "related": [
        "docker",
        "virtual-machine"
      ],
      "sources": [
        {
          "title": "Docker: containers",
          "url": "https://docs.docker.com/get-started/docker-concepts/the-basics/what-is-a-container/"
        }
      ]
    },
    {
      "id": "image",
      "term": "Container image",
      "aliases": [
        "Docker image",
        "OCI image"
      ],
      "category": "devops",
      "level": "intermediate",
      "tags": [
        "devops"
      ],
      "definition": "A packaged filesystem and metadata used as a template for containers.",
      "analogy": "The sealed recipe kit; a running container is the meal being cooked.",
      "example": "A team builds an image and runs several containers from it.",
      "caveat": "Changing a running container does not automatically change its source image.",
      "related": [
        "container",
        "docker"
      ],
      "sources": [
        {
          "title": "Docker: images",
          "url": "https://docs.docker.com/get-started/docker-concepts/the-basics/what-is-an-image/"
        }
      ]
    },
    {
      "id": "csp",
      "term": "Content Security Policy",
      "aliases": [
        "CSP"
      ],
      "category": "security",
      "level": "intermediate",
      "tags": [
        "security"
      ],
      "definition": "Browser policy rules that restrict permitted resource loading and certain execution behaviors.",
      "analogy": "A guest list for scripts, styles, and other resources on a page.",
      "example": "A policy can disallow inline scripts and limit script origins.",
      "caveat": "CSP is defense in depth, not a replacement for safe application code.",
      "related": [
        "xss",
        "https"
      ],
      "sources": [
        {
          "title": "OWASP Cheat Sheet Series",
          "url": "https://cheatsheetseries.owasp.org/"
        }
      ]
    },
    {
      "id": "content-type",
      "term": "Content-Type",
      "aliases": [
        "Content-Type header",
        "media type header"
      ],
      "category": "web",
      "level": "beginner",
      "tags": [
        "web"
      ],
      "definition": "An HTTP header that identifies the media type of the associated request or response body.",
      "analogy": "The label saying whether the parcel contains JSON soup, HTML sandwiches, or an image of a sandwich.",
      "example": "Content-Type: application/json declares that the message body contains JSON data.",
      "caveat": "It describes the body, not the desired response format. When using browser FormData, let the browser supply the multipart boundary.",
      "related": [
        "request-header",
        "json",
        "http"
      ],
      "sources": [
        {
          "title": "MDN: Content-Type",
          "url": "https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/Content-Type"
        }
      ]
    },
    {
      "id": "context-window",
      "term": "Context window",
      "aliases": [
        "context length"
      ],
      "category": "ai",
      "level": "intermediate",
      "tags": [
        "ai"
      ],
      "definition": "The maximum sequence of tokens a model can consider in a given interaction.",
      "analogy": "The size of the desk holding the model's current reading material.",
      "example": "A long document may exceed the model's context limit.",
      "caveat": "A large window does not guarantee reliable use of every detail.",
      "related": [
        "token",
        "llm"
      ],
      "sources": [
        {
          "title": "Google ML Glossary",
          "url": "https://developers.google.com/machine-learning/glossary"
        }
      ]
    },
    {
      "id": "cd",
      "term": "Continuous delivery",
      "aliases": [
        "CD",
        "continuous deployment"
      ],
      "category": "devops",
      "level": "intermediate",
      "tags": [
        "devops"
      ],
      "definition": "Keeping software ready to release through an automated, repeatable pipeline.",
      "analogy": "A delivery conveyor belt with a human release button when needed.",
      "example": "A pipeline builds a tested artifact ready for production deployment.",
      "caveat": "Continuous deployment goes further by automatically releasing qualifying changes.",
      "related": [
        "ci",
        "deployment"
      ],
      "sources": [
        {
          "title": "Docker documentation",
          "url": "https://docs.docker.com/get-started/"
        },
        {
          "title": "AWS cloud concepts",
          "url": "https://aws.amazon.com/what-is/cloud-computing/"
        }
      ]
    },
    {
      "id": "ci",
      "term": "Continuous integration",
      "aliases": [
        "CI"
      ],
      "category": "devops",
      "level": "intermediate",
      "tags": [
        "devops"
      ],
      "definition": "Frequently integrating code changes and checking them with automated builds or tests.",
      "analogy": "Checking every new ingredient before the shared soup becomes a surprise.",
      "example": "A pull request triggers automated tests and a build.",
      "caveat": "CI helps detect problems; it does not prove there are none.",
      "related": [
        "cd",
        "unit-test"
      ],
      "sources": [
        {
          "title": "GitHub: continuous integration",
          "url": "https://docs.github.com/en/actions/get-started/continuous-integration"
        }
      ]
    },
    {
      "id": "cookie",
      "term": "Cookie",
      "aliases": [
        "browser cookie"
      ],
      "category": "web",
      "level": "beginner",
      "tags": [
        "web"
      ],
      "definition": "A small piece of data a browser stores for a site and may send with matching requests.",
      "analogy": "A little note the website asks your browser to carry on future visits.",
      "example": "A session cookie can identify a logged-in session.",
      "caveat": "Cookies have scope and security settings; they are not inherently secret.",
      "related": [
        "session",
        "csrf"
      ],
      "sources": [
        {
          "title": "MDN web documentation",
          "url": "https://developer.mozilla.org/en-US/docs/Web"
        }
      ]
    },
    {
      "id": "cors",
      "term": "CORS",
      "aliases": [
        "cross-origin resource sharing"
      ],
      "category": "web",
      "level": "intermediate",
      "tags": [
        "web"
      ],
      "definition": "Browser-enforced rules that let a server indicate which other origins may read its responses.",
      "analogy": "A browser checking the guest list before handing a page another site's data.",
      "example": "An API can permit a frontend on a different origin to read a response.",
      "caveat": "CORS is not authentication and does not block every kind of request.",
      "related": [
        "api",
        "http"
      ],
      "sources": [
        {
          "title": "MDN: CORS",
          "url": "https://developer.mozilla.org/en-US/docs/Web/HTTP/Guides/CORS"
        }
      ]
    },
    {
      "id": "coupling",
      "term": "Coupling",
      "aliases": [
        "tight coupling",
        "loose coupling"
      ],
      "category": "programming",
      "level": "intermediate",
      "tags": [
        "programming",
        "javascript"
      ],
      "definition": "The degree to which parts of a system depend on each other's details, behavior, or structure.",
      "analogy": "Two appliances sharing a power cable so enthusiastically that moving the toaster relocates the fridge.",
      "example": "A component that knows a database's table layout is coupled to that storage implementation.",
      "caveat": "Some coupling is unavoidable and useful. Reduce dependencies on unstable details rather than aiming for a system where nothing knows anything.",
      "related": [
        "decoupling",
        "interface",
        "single-responsibility-principle"
      ],
      "sources": [
        {
          "title": "Coupling — reference and documentation",
          "url": "https://learn.microsoft.com/en-us/dotnet/architecture/modern-web-apps-azure/architectural-principles"
        }
      ]
    },
    {
      "id": "cpu",
      "term": "CPU",
      "aliases": [
        "central processing unit",
        "processor"
      ],
      "category": "computer-basics",
      "level": "beginner",
      "tags": [
        "computer-basics"
      ],
      "definition": "The main processor that executes a computer's instructions.",
      "analogy": "The kitchen chef: follows instructions, gets hot, needs a fan.",
      "example": "A CPU runs the instructions in your spreadsheet app.",
      "caveat": "Clock speed alone does not tell you overall performance.",
      "related": [
        "gpu",
        "ram"
      ],
      "sources": [
        {
          "title": "MDN Glossary",
          "url": "https://developer.mozilla.org/en-US/docs/Glossary"
        }
      ]
    },
    {
      "id": "cron-job",
      "term": "Cron job",
      "aliases": [
        "cron",
        "crontab",
        "scheduled job"
      ],
      "category": "devops",
      "level": "intermediate",
      "tags": [
        "devops"
      ],
      "definition": "A task scheduled to run automatically at specified times using cron or a cron-compatible scheduler.",
      "analogy": "A very punctual robot intern who still needs instructions about what to do when Tuesday goes wrong.",
      "example": "0 9 * * 1 runs a command at 09:00 every Monday in the scheduler's configured time zone.",
      "caveat": "The classic format has five time fields; other schedulers differ. Handle environment settings, logs, failures, time zones, and overlapping runs.",
      "related": [
        "shell",
        "server",
        "pipeline"
      ],
      "sources": [
        {
          "title": "Cron job — reference and documentation",
          "url": "https://man7.org/linux/man-pages/man5/crontab.5.html"
        }
      ]
    },
    {
      "id": "csrf",
      "term": "Cross-site request forgery",
      "aliases": [
        "CSRF"
      ],
      "category": "security",
      "level": "intermediate",
      "tags": [
        "security"
      ],
      "definition": "An attack that causes a browser to send an unwanted request using a victim's credentials.",
      "analogy": "Someone tricking your already-badged browser into pressing a button for them.",
      "example": "A malicious page attempts a state-changing request to a site where you are logged in.",
      "caveat": "Appropriate CSRF protections depend on the authentication and request design.",
      "related": [
        "cookie",
        "session"
      ],
      "sources": [
        {
          "title": "OWASP Cheat Sheet Series",
          "url": "https://cheatsheetseries.owasp.org/"
        }
      ]
    },
    {
      "id": "xss",
      "term": "Cross-site scripting",
      "aliases": [
        "XSS"
      ],
      "category": "security",
      "level": "intermediate",
      "tags": [
        "security"
      ],
      "definition": "A vulnerability where attacker-controlled content executes as script in a user's browser.",
      "analogy": "An uninvited guest sneaking stage directions into your web page.",
      "example": "Unsafe HTML insertion can let a comment execute malicious JavaScript.",
      "caveat": "Use safe rendering and context-appropriate defenses; input filtering alone is insufficient.",
      "related": [
        "dom",
        "csp"
      ],
      "sources": [
        {
          "title": "OWASP Cheat Sheet Series",
          "url": "https://cheatsheetseries.owasp.org/"
        }
      ]
    },
    {
      "id": "crud",
      "term": "CRUD",
      "aliases": [
        "Create Read Update Delete"
      ],
      "category": "data",
      "level": "beginner",
      "tags": [
        "data"
      ],
      "definition": "The four basic operations for managing stored data: create, read, update, and delete.",
      "analogy": "A filing cabinet's greatest hits: add it, find it, fix it, and finally admit you no longer need it.",
      "example": "A dictionary admin can create a term, read its definition, update its examples, or delete a duplicate.",
      "caveat": "CRUD describes data operations, not a mandatory HTTP mapping or a substitute for business rules and authorization.",
      "related": [
        "database",
        "api",
        "get-request",
        "post-request"
      ],
      "sources": [
        {
          "title": "MDN: CRUD",
          "url": "https://developer.mozilla.org/en-US/docs/Glossary/CRUD"
        }
      ]
    },
    {
      "id": "css",
      "term": "CSS",
      "aliases": [
        "Cascading Style Sheets"
      ],
      "category": "web",
      "level": "beginner",
      "tags": [
        "web"
      ],
      "definition": "The stylesheet language used to control the presentation and layout of HTML and other supported documents.",
      "analogy": "The interior designer who can also move every sofa when the screen gets smaller.",
      "example": ".term-card { padding: 1rem; border-radius: 0.75rem; } styles dictionary cards.",
      "caveat": "The cascade decides which declarations win; source order alone does not explain every conflict.",
      "related": [
        "html",
        "css-selector",
        "responsive-design"
      ],
      "sources": [
        {
          "title": "MDN: CSS",
          "url": "https://developer.mozilla.org/en-US/docs/Web/CSS"
        }
      ]
    },
    {
      "id": "css-selector",
      "term": "CSS selector",
      "aliases": [
        "CSS selectors",
        "selector"
      ],
      "category": "web",
      "level": "beginner",
      "tags": [
        "web"
      ],
      "definition": "A pattern that identifies which document elements a CSS rule should apply to.",
      "analogy": "An address label for styling: deliver these colors to this class, not the entire neighborhood.",
      "example": ".term-card > h2 selects h2 elements that are direct children of elements with class term-card.",
      "caveat": "Specificity influences the cascade, but cascade layers, origin, and importance also matter. A selector alone does not define styling.",
      "related": [
        "css",
        "dom",
        "html"
      ],
      "sources": [
        {
          "title": "MDN: CSS selector",
          "url": "https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_selectors"
        }
      ]
    },
    {
      "id": "curl",
      "term": "curl",
      "aliases": [
        "cURL"
      ],
      "category": "tools",
      "level": "beginner",
      "tags": [
        "tools"
      ],
      "definition": "A command-line tool for transferring data using URLs, commonly used to inspect and call HTTP endpoints.",
      "analogy": "A browser's practical cousin who skips the pictures and asks to see the headers.",
      "example": "curl -i https://example.com/api/terms requests an endpoint and prints response headers with the body.",
      "caveat": "curl does not render a web page or execute its JavaScript. Avoid exposing credentials in command history or copied examples.",
      "related": [
        "cli",
        "http",
        "endpoint"
      ],
      "sources": [
        {
          "title": "curl — reference and documentation",
          "url": "https://curl.se/docs/manpage.html"
        }
      ]
    },
    {
      "id": "data-structure",
      "term": "Data structure",
      "aliases": [
        "array",
        "list",
        "hash map"
      ],
      "category": "programming",
      "level": "intermediate",
      "tags": [
        "programming"
      ],
      "definition": "A way of organizing data so particular operations are convenient or efficient.",
      "analogy": "Choosing shelves, drawers, or a pile on the floor for your information.",
      "example": "A map can associate each username with a profile.",
      "caveat": "The best structure depends on how you access and change the data.",
      "related": [
        "algorithm",
        "big-o"
      ],
      "sources": [
        {
          "title": "Python language tutorial",
          "url": "https://docs.python.org/3/tutorial/"
        },
        {
          "title": "MDN Glossary",
          "url": "https://developer.mozilla.org/en-US/docs/Glossary"
        }
      ]
    },
    {
      "id": "data-type",
      "term": "Data type",
      "aliases": [
        "type"
      ],
      "category": "programming",
      "level": "beginner",
      "tags": [
        "programming"
      ],
      "definition": "A classification that describes what kind of value something is and which operations make sense.",
      "analogy": "Labels that stop you from trying to multiply a sandwich.",
      "example": "Numbers, strings, and Booleans are common data types.",
      "caveat": "A type system can be stricter or looser depending on the language.",
      "related": [
        "variable",
        "type-system"
      ],
      "sources": [
        {
          "title": "Python language tutorial",
          "url": "https://docs.python.org/3/tutorial/"
        },
        {
          "title": "MDN Glossary",
          "url": "https://developer.mozilla.org/en-US/docs/Glossary"
        }
      ]
    },
    {
      "id": "database",
      "term": "Database",
      "aliases": [
        "DB"
      ],
      "category": "data",
      "level": "beginner",
      "tags": [
        "data"
      ],
      "definition": "An organized collection of data managed so applications can store, retrieve, and update information.",
      "analogy": "A filing system that can answer questions without asking you to search every drawer yourself.",
      "example": "A dictionary database stores terms and lets an API find entries matching a query.",
      "caveat": "A database is not necessarily SQL, relational, or one physical server. Its guarantees and query capabilities depend on the system.",
      "related": [
        "query",
        "crud",
        "sql",
        "nosql"
      ],
      "sources": [
        {
          "title": "Database — reference and documentation",
          "url": "https://www.postgresql.org/docs/current/tutorial-concepts.html"
        }
      ]
    },
    {
      "id": "index",
      "term": "Database index",
      "aliases": [
        "index",
        "indexing"
      ],
      "category": "data",
      "level": "intermediate",
      "tags": [
        "data"
      ],
      "definition": "An additional structure that helps a database locate certain data efficiently.",
      "analogy": "A book index that saves you from reading every page to find 'pizza'.",
      "example": "An index on email can speed up finding an account by email.",
      "caveat": "Indexes use space and can make writes more expensive.",
      "related": [
        "query",
        "big-o"
      ],
      "sources": [
        {
          "title": "PostgreSQL documentation",
          "url": "https://www.postgresql.org/docs/current/"
        },
        {
          "title": "Google ML Glossary",
          "url": "https://developers.google.com/machine-learning/glossary"
        }
      ]
    },
    {
      "id": "debugging",
      "term": "Debugging",
      "aliases": [
        "debugger",
        "bug"
      ],
      "category": "tools",
      "level": "beginner",
      "tags": [
        "tools"
      ],
      "definition": "Finding and understanding the cause of unintended software behavior.",
      "analogy": "Detective work where the culprit is often a line you wrote yesterday.",
      "example": "A breakpoint can help inspect why a value is unexpected.",
      "caveat": "Changing code until the symptom disappears is not always finding the cause.",
      "related": [
        "ide",
        "unit-test"
      ],
      "sources": [
        {
          "title": "VS Code debugging",
          "url": "https://code.visualstudio.com/docs/debugtest/debugging"
        }
      ]
    },
    {
      "id": "decoupling",
      "term": "Decoupling",
      "aliases": [
        "loose coupling",
        "separation of concerns"
      ],
      "category": "programming",
      "level": "intermediate",
      "tags": [
        "programming",
        "javascript"
      ],
      "definition": "Reducing unnecessary dependencies so parts can change, be tested, or be replaced with less impact on each other.",
      "analogy": "Giving the toaster and fridge their own cables before somebody asks for a kitchen redesign.",
      "example": "Pass a repository interface to application logic instead of importing a specific database client everywhere.",
      "caveat": "An extra interface does not automatically remove behavioral dependencies. Over-abstraction can add complexity without useful independence.",
      "related": [
        "coupling",
        "interface",
        "test-double"
      ],
      "sources": [
        {
          "title": "Decoupling — reference and documentation",
          "url": "https://learn.microsoft.com/en-us/dotnet/architecture/modern-web-apps-azure/architectural-principles"
        }
      ]
    },
    {
      "id": "deep-learning",
      "term": "Deep learning",
      "aliases": [
        "DL"
      ],
      "category": "ai",
      "level": "intermediate",
      "tags": [
        "ai"
      ],
      "definition": "Machine learning using neural networks with multiple layers of representation.",
      "analogy": "Many layers of math wearing the same oversized lab coat.",
      "example": "A deep model can learn increasingly complex image features.",
      "caveat": "Depth alone does not guarantee quality.",
      "related": [
        "neural-network",
        "machine-learning"
      ],
      "sources": [
        {
          "title": "Google ML Glossary",
          "url": "https://developers.google.com/machine-learning/glossary"
        }
      ]
    },
    {
      "id": "dependency",
      "term": "Dependency",
      "aliases": [
        "package",
        "third-party package"
      ],
      "category": "tools",
      "level": "beginner",
      "tags": [
        "tools"
      ],
      "definition": "Software or another component that your project relies on.",
      "analogy": "A borrowed ingredient your recipe needs to work.",
      "example": "An application may depend on a date-formatting package.",
      "caveat": "Dependencies bring maintenance, license, and security responsibilities.",
      "related": [
        "library",
        "package-manager"
      ],
      "sources": [
        {
          "title": "npm package dependencies",
          "url": "https://docs.npmjs.com/specifying-dependencies-and-devdependencies-in-a-package-json-file/"
        }
      ]
    },
    {
      "id": "deployment",
      "term": "Deployment",
      "aliases": [
        "deploy",
        "release rollout"
      ],
      "category": "devops",
      "level": "beginner",
      "tags": [
        "devops"
      ],
      "definition": "Making a version of software available in its target environment.",
      "analogy": "Opening the restaurant doors after the kitchen is ready.",
      "example": "A team deploys a new website build to hosting.",
      "caveat": "A deployment and a user-visible feature release can happen separately.",
      "related": [
        "cd",
        "github-pages"
      ],
      "sources": [
        {
          "title": "Docker documentation",
          "url": "https://docs.docker.com/get-started/"
        },
        {
          "title": "AWS cloud concepts",
          "url": "https://aws.amazon.com/what-is/cloud-computing/"
        }
      ]
    },
    {
      "id": "design-pattern",
      "term": "Design pattern",
      "aliases": [
        "software design pattern"
      ],
      "category": "programming",
      "level": "intermediate",
      "tags": [
        "programming",
        "javascript"
      ],
      "definition": "A named, reusable approach to a recurring design problem, adapted to a particular context rather than pasted as finished code.",
      "analogy": "A tried-and-tested seating plan, not a command to host every dinner in exactly the same room.",
      "example": "The Factory Pattern centralizes object creation when the concrete type depends on input.",
      "caveat": "A pattern is useful only when it fits the problem. Adding named patterns unnecessarily can make simple code harder to follow.",
      "related": [
        "factory-pattern",
        "mvc",
        "refactoring"
      ],
      "sources": [
        {
          "title": "Design pattern — reference and documentation",
          "url": "https://www.martinfowler.com/articles/writingPatterns.html"
        }
      ]
    },
    {
      "id": "div",
      "term": "div",
      "aliases": [
        "div element",
        "division element"
      ],
      "category": "web",
      "level": "beginner",
      "tags": [
        "web"
      ],
      "definition": "A generic HTML container with no special semantic meaning, used to group content for styling or scripting.",
      "analogy": "A plain cardboard box: useful, but it does not become a button because you draw a finger on it.",
      "example": "<div class=\"term-grid\">...</div> groups entries for a grid layout.",
      "caveat": "Prefer meaningful elements such as main, nav, or button when their semantics fit. A clickable div needs extra keyboard and accessibility work.",
      "related": [
        "html",
        "semantic-html",
        "css"
      ],
      "sources": [
        {
          "title": "MDN: div",
          "url": "https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Elements/div"
        }
      ]
    },
    {
      "id": "dns",
      "term": "DNS",
      "aliases": [
        "domain name system"
      ],
      "category": "networking",
      "level": "beginner",
      "tags": [
        "networking"
      ],
      "definition": "A distributed system that maps domain names to records such as IP addresses.",
      "analogy": "The internet's contact list, so you do not have to memorize everybody's numbers.",
      "example": "DNS can resolve a website name to a server address.",
      "caveat": "DNS provides several record types, not just address records.",
      "related": [
        "ip-address",
        "http"
      ],
      "sources": [
        {
          "title": "MDN Glossary",
          "url": "https://developer.mozilla.org/en-US/docs/Glossary"
        }
      ]
    },
    {
      "id": "docker",
      "term": "Docker",
      "aliases": [],
      "category": "devops",
      "level": "intermediate",
      "tags": [
        "devops"
      ],
      "definition": "A platform and set of tools for building and running container images.",
      "analogy": "The packing station and delivery trolley for your app's lunchbox.",
      "example": "A Dockerfile describes steps for building an application image.",
      "caveat": "Docker is one implementation in a wider container ecosystem.",
      "related": [
        "container",
        "image"
      ],
      "sources": [
        {
          "title": "Docker overview",
          "url": "https://docs.docker.com/get-started/docker-overview/"
        }
      ]
    },
    {
      "id": "dom",
      "term": "DOM",
      "aliases": [
        "Document Object Model"
      ],
      "category": "web",
      "level": "beginner",
      "tags": [
        "web"
      ],
      "definition": "The browser's object representation of a document, with nodes that scripts can inspect and change.",
      "analogy": "The page's family tree, where even a text node gets a seat at the reunion.",
      "example": "document.querySelector('h1').textContent = 'Hello'; changes a heading in the document.",
      "caveat": "The DOM is an interface to the document, not the original HTML text or React's virtual representation; XML documents can have a DOM too.",
      "related": [
        "html",
        "javascript",
        "virtual-dom"
      ],
      "sources": [
        {
          "title": "MDN: DOM",
          "url": "https://developer.mozilla.org/en-US/docs/Web/API/Document_Object_Model/Introduction"
        }
      ]
    },
    {
      "id": "embedding",
      "term": "Embedding",
      "aliases": [
        "vector embedding"
      ],
      "category": "ai",
      "level": "intermediate",
      "tags": [
        "ai"
      ],
      "definition": "A numerical representation that places items in a space where useful relationships can be compared.",
      "analogy": "Giving words or images coordinates in a giant mathematical neighborhood.",
      "example": "Related sentences can have nearby text embeddings.",
      "caveat": "Closeness depends on the model and is not an objective meaning score.",
      "related": [
        "vector-database",
        "rag"
      ],
      "sources": [
        {
          "title": "Google ML Glossary",
          "url": "https://developers.google.com/machine-learning/glossary"
        }
      ]
    },
    {
      "id": "encoding",
      "term": "Encoding",
      "aliases": [
        "UTF-8",
        "character encoding"
      ],
      "category": "computer-basics",
      "level": "intermediate",
      "tags": [
        "computer-basics"
      ],
      "definition": "A set of rules for representing information in a particular format.",
      "analogy": "Packing the same message into a box the receiver knows how to unpack.",
      "example": "UTF-8 represents Unicode characters as sequences of bytes.",
      "caveat": "Encoding is not encryption and does not make a message secret.",
      "related": [
        "unicode",
        "encryption"
      ],
      "sources": [
        {
          "title": "MDN: Character encoding",
          "url": "https://developer.mozilla.org/en-US/docs/Glossary/Character_encoding"
        }
      ]
    },
    {
      "id": "encryption",
      "term": "Encryption",
      "aliases": [
        "encrypt",
        "decrypt"
      ],
      "category": "security",
      "level": "beginner",
      "tags": [
        "security"
      ],
      "definition": "Transforming readable data into a form that requires appropriate key material to recover.",
      "analogy": "Locking the message in a box instead of hoping nobody reads the envelope.",
      "example": "TLS encrypts data exchanged over a secure connection.",
      "caveat": "Encryption does not protect against every endpoint or key-management failure.",
      "related": [
        "hashing",
        "tls"
      ],
      "sources": [
        {
          "title": "OWASP Cheat Sheet Series",
          "url": "https://cheatsheetseries.owasp.org/"
        }
      ]
    },
    {
      "id": "endpoint",
      "term": "Endpoint",
      "aliases": [
        "API endpoint"
      ],
      "category": "web",
      "level": "beginner",
      "tags": [
        "web"
      ],
      "definition": "An addressable point where an API offers an operation; in HTTP APIs it is commonly identified by a method and URL.",
      "analogy": "A specific service counter, not the entire shopping mall.",
      "example": "GET /api/terms retrieves terms, while POST /api/terms can create one at the same path.",
      "caveat": "A URL alone may not identify the operation: methods, headers, versions, and authentication can change its meaning.",
      "related": [
        "api",
        "http",
        "get-request",
        "post-request"
      ],
      "sources": [
        {
          "title": "Endpoint — reference and documentation",
          "url": "https://spec.openapis.org/oas/latest.html#paths-object"
        }
      ]
    },
    {
      "id": "environment-variable",
      "term": "Environment variable",
      "aliases": [
        "env var",
        "configuration"
      ],
      "category": "tools",
      "level": "intermediate",
      "tags": [
        "tools"
      ],
      "definition": "A named value provided to a process through its execution environment.",
      "analogy": "A sticky note handed to the program when it starts work.",
      "example": "PORT=3000 can tell a server which port to listen on.",
      "caveat": "Environment variables are not automatically secret or secure.",
      "related": [
        "process",
        "secret"
      ],
      "sources": [
        {
          "title": "Node.js environment variables",
          "url": "https://nodejs.org/api/environment_variables.html"
        }
      ]
    },
    {
      "id": "es6",
      "term": "ES6",
      "aliases": [
        "ES2015",
        "ECMAScript 2015",
        "ECMAScript 6"
      ],
      "category": "programming",
      "level": "beginner",
      "tags": [
        "programming",
        "javascript"
      ],
      "definition": "The 2015 edition of the ECMAScript standard that added features including let, const, arrow functions, classes, and modules.",
      "analogy": "JavaScript's big wardrobe update; the old shirts did not instantly disappear.",
      "example": "const double = n => n * 2; uses an arrow function and a const declaration.",
      "caveat": "ES6 is one historical edition, not a name for all modern JavaScript. Browser support depends on the specific feature.",
      "related": [
        "javascript",
        "let",
        "const",
        "module"
      ],
      "sources": [
        {
          "title": "ES6 — reference and documentation",
          "url": "https://262.ecma-international.org/6.0/"
        }
      ]
    },
    {
      "id": "etl",
      "term": "ETL",
      "aliases": [
        "extract transform load"
      ],
      "category": "data",
      "level": "intermediate",
      "tags": [
        "data"
      ],
      "definition": "A process that extracts data, transforms it, and loads it into a destination.",
      "analogy": "Collect the groceries, chop them, then put the salad in the serving bowl.",
      "example": "An ETL job cleans sales records before loading a warehouse.",
      "caveat": "In ELT, loading happens before transformation.",
      "related": [
        "database",
        "query"
      ],
      "sources": [
        {
          "title": "PostgreSQL documentation",
          "url": "https://www.postgresql.org/docs/current/"
        },
        {
          "title": "Google ML Glossary",
          "url": "https://developers.google.com/machine-learning/glossary"
        }
      ]
    },
    {
      "id": "evaluation",
      "term": "Evaluation",
      "aliases": [
        "eval",
        "evals",
        "model evaluation"
      ],
      "category": "ai",
      "level": "intermediate",
      "tags": [
        "ai"
      ],
      "definition": "Measuring a model or system's performance against defined tasks and criteria.",
      "analogy": "A report card based on actual assignments, not how confidently the student smiles.",
      "example": "An evaluation can test answer accuracy on a held-out question set.",
      "caveat": "A useful evaluation should match real use and include failure cases.",
      "related": [
        "overfitting",
        "model"
      ],
      "sources": [
        {
          "title": "Google ML Glossary",
          "url": "https://developers.google.com/machine-learning/glossary"
        }
      ]
    },
    {
      "id": "exception",
      "term": "Exception",
      "aliases": [
        "error handling",
        "try catch"
      ],
      "category": "programming",
      "level": "intermediate",
      "tags": [
        "programming"
      ],
      "definition": "A signal that normal execution cannot continue and needs an error-handling path.",
      "analogy": "Your program pulling the emergency cord instead of silently eating the problem.",
      "example": "A file operation can raise an exception if the file is missing.",
      "caveat": "Exceptions are not a substitute for validating expected inputs.",
      "related": [
        "debugging",
        "unit-test"
      ],
      "sources": [
        {
          "title": "Python language tutorial",
          "url": "https://docs.python.org/3/tutorial/"
        },
        {
          "title": "MDN Glossary",
          "url": "https://developer.mozilla.org/en-US/docs/Glossary"
        }
      ]
    },
    {
      "id": "factory-pattern",
      "term": "Factory Pattern",
      "aliases": [
        "factory function",
        "object factory",
        "factory method"
      ],
      "category": "programming",
      "level": "intermediate",
      "tags": [
        "programming",
        "javascript"
      ],
      "definition": "A creational design approach that puts object creation behind a function or abstraction so callers need not choose or construct concrete implementations directly.",
      "analogy": "Order a drink at the counter without personally assembling the espresso machine.",
      "example": "createStorage('memory') returns an in-memory store, while createStorage('disk') returns a disk-backed store with the same interface.",
      "caveat": "A simple factory function, the formal Factory Method pattern, and Abstract Factory are related but distinct. Do not add factories without useful variation.",
      "related": [
        "design-pattern",
        "constructor",
        "interface"
      ],
      "sources": [
        {
          "title": "Microsoft Learn: Simple Factory, Factory Method, and Abstract Factory",
          "url": "https://learn.microsoft.com/en-us/shows/visual-studio-toolbox/design-patterns-factories"
        }
      ]
    },
    {
      "id": "failover",
      "term": "Failover",
      "aliases": [
        "automatic failover"
      ],
      "category": "devops",
      "level": "intermediate",
      "tags": [
        "devops"
      ],
      "definition": "Switching work or traffic from a failed or unhealthy component to a healthy alternative, automatically or manually.",
      "analogy": "The backup singer taking the microphone when the lead singer loses their voice.",
      "example": "A health check detects a failed server, and the load balancer directs requests to healthy instances.",
      "caveat": "Failover needs an available alternative and a tested recovery plan. Detection delays, insufficient capacity, or replication lag can still cause disruption.",
      "related": [
        "redundancy",
        "load-balancer",
        "database"
      ],
      "sources": [
        {
          "title": "Failover — reference and documentation",
          "url": "https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Concepts.MultiAZ.Failover.html"
        }
      ]
    },
    {
      "id": "fetch-api",
      "term": "Fetch API",
      "aliases": [
        "fetch",
        "window.fetch"
      ],
      "category": "web",
      "level": "beginner",
      "tags": [
        "web"
      ],
      "definition": "A browser API, also available in some other runtimes, for making requests and handling responses using promises.",
      "analogy": "A digital courier who returns a delivery receipt, even when the parcel contains a 404 complaint.",
      "example": "const response = await fetch('/api/terms'); if (!response.ok) throw new Error('Request failed'); const terms = await response.json();",
      "caveat": "fetch normally rejects on network failures, not HTTP error statuses. Check response.ok; browser cross-origin requests also follow CORS rules.",
      "related": [
        "promise",
        "http",
        "xmlhttprequest",
        "async-function"
      ],
      "sources": [
        {
          "title": "MDN: Fetch API",
          "url": "https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API/Using_Fetch"
        }
      ]
    },
    {
      "id": "fine-tuning",
      "term": "Fine-tuning",
      "aliases": [
        "finetuning"
      ],
      "category": "ai",
      "level": "intermediate",
      "tags": [
        "ai"
      ],
      "definition": "Further training an existing model on additional data for a particular purpose.",
      "analogy": "Giving a trained chef extra practice with your restaurant's menu.",
      "example": "A model can be fine-tuned on examples of a desired writing style.",
      "caveat": "Fine-tuning changes model parameters; supplying documents in a prompt does not.",
      "related": [
        "training",
        "rag"
      ],
      "sources": [
        {
          "title": "Google ML Glossary",
          "url": "https://developers.google.com/machine-learning/glossary"
        }
      ]
    },
    {
      "id": "flux",
      "term": "Flux",
      "aliases": [
        "Flux architecture"
      ],
      "category": "web",
      "level": "intermediate",
      "tags": [
        "web",
        "react"
      ],
      "definition": "An application architecture associated with React that organizes updates through a one-way cycle of actions, a dispatcher, stores, and views.",
      "analogy": "A roundabout for application updates, with fewer opportunities for data to drive into oncoming traffic.",
      "example": "A user action is dispatched, a store updates, and subscribed views render the new state.",
      "caveat": "Flux is an architectural pattern, not React itself or a requirement for using React. Redux adopts related ideas but has a different design.",
      "related": [
        "redux",
        "one-way-data-flow",
        "state-management"
      ],
      "sources": [
        {
          "title": "Flux — reference and documentation",
          "url": "https://facebookarchive.github.io/flux/docs/in-depth-overview/"
        }
      ]
    },
    {
      "id": "foreign-key",
      "term": "Foreign key",
      "aliases": [
        "FK"
      ],
      "category": "data",
      "level": "intermediate",
      "tags": [
        "data"
      ],
      "definition": "A constraint that links values in one table to valid referenced values in another.",
      "analogy": "The address on an invitation that must point to a real guest.",
      "example": "An order's customer_id can reference the customers table.",
      "caveat": "Deletion behavior depends on how the constraint is configured.",
      "related": [
        "primary-key",
        "schema"
      ],
      "sources": [
        {
          "title": "PostgreSQL documentation",
          "url": "https://www.postgresql.org/docs/current/"
        },
        {
          "title": "Google ML Glossary",
          "url": "https://developers.google.com/machine-learning/glossary"
        }
      ]
    },
    {
      "id": "forward-deployed-engineer",
      "term": "Forward deployed engineer",
      "aliases": [
        "FDE",
        "forward deployed software engineer",
        "FDSE"
      ],
      "category": "product",
      "level": "intermediate",
      "tags": [
        "engineering",
        "customer-facing",
        "implementation",
        "production",
        "ai"
      ],
      "definition": "A customer-facing engineer who works closely with customer teams to adapt, integrate, and deploy a company's technology into useful production workflows.",
      "analogy": "Instead of delivering a fancy coffee machine and waving goodbye, you help the cafe connect it, survive the morning rush, and tell the manufacturer what needs fixing.",
      "example": "An FDE from an AI company builds and deploys an internal support assistant connected to a customer's systems, then checks whether staff actually use it.",
      "caveat": "The balance of implementation, product development, and customer interaction varies by employer. The role also exists outside AI companies.",
      "related": [
        "api",
        "iteration",
        "llm"
      ],
      "sources": [
        {
          "title": "OpenAI: Forward Deployed Engineer role and responsibilities",
          "url": "https://openai.com/careers/forward-deployed-engineer-(fde)-seattle-seattle/"
        }
      ]
    },
    {
      "id": "framework",
      "term": "Framework",
      "aliases": [
        "software framework",
        "application framework"
      ],
      "category": "web",
      "level": "beginner",
      "tags": [
        "web"
      ],
      "definition": "A reusable structure that supplies conventions and coordinates parts of an application, calling your code at defined points.",
      "analogy": "A building kit with a floor plan and a foreman who decides when to call each trade.",
      "example": "A web framework routes incoming requests to handlers and runs middleware around them.",
      "caveat": "Framework and library are not perfectly separated categories. Understand what the framework controls and what remains your responsibility.",
      "related": [
        "library",
        "api",
        "boilerplate"
      ],
      "sources": [
        {
          "title": "MDN: Framework",
          "url": "https://developer.mozilla.org/en-US/docs/Learn_web_development/Extensions/Server-side/First_steps/Web_frameworks"
        }
      ]
    },
    {
      "id": "frontend",
      "term": "Frontend",
      "aliases": [
        "front-end",
        "front end"
      ],
      "category": "web",
      "level": "beginner",
      "tags": [
        "web"
      ],
      "definition": "The part of an application users interact with, including its interface and client-side behavior.",
      "analogy": "The restaurant's dining room, where broken buttons are as noticeable as wobbly chairs.",
      "example": "A React page displays terms, filters search results, and submits feedback to an API.",
      "caveat": "Frontend work includes accessibility, performance, and data handling. Server rendering means its code is not always executed only in a browser.",
      "related": [
        "backend",
        "react",
        "client"
      ],
      "sources": [
        {
          "title": "MDN: Frontend",
          "url": "https://developer.mozilla.org/en-US/docs/Learn_web_development/Getting_started/Web_standards/The_web_standards_model"
        }
      ]
    },
    {
      "id": "function",
      "term": "Function",
      "aliases": [
        "JavaScript function"
      ],
      "category": "programming",
      "level": "beginner",
      "tags": [
        "programming",
        "javascript"
      ],
      "definition": "A callable piece of code that can receive inputs, perform work, and return a value.",
      "analogy": "A tiny recipe you can reuse without rewriting the cookbook each time.",
      "example": "function double(n) { return n * 2; } returns 6 when called with double(3).",
      "caveat": "Functions need not be pure or return an explicit value. In JavaScript, falling through without returning produces undefined.",
      "related": [
        "function-parameter",
        "function-argument",
        "method",
        "callback"
      ],
      "sources": [
        {
          "title": "MDN: Function",
          "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Functions"
        }
      ]
    },
    {
      "id": "function-argument",
      "term": "Function argument",
      "aliases": [
        "argument",
        "actual parameter"
      ],
      "category": "programming",
      "level": "beginner",
      "tags": [
        "programming",
        "javascript"
      ],
      "definition": "An actual value or expression supplied when a function is called.",
      "analogy": "The pizza you actually deliver, rather than the empty box drawn on the order form.",
      "example": "In greet('Ada'), the string 'Ada' is the argument.",
      "caveat": "An argument is supplied by the caller; a parameter is the named slot in the function definition.",
      "related": [
        "function-parameter",
        "function"
      ],
      "sources": [
        {
          "title": "MDN: Function argument",
          "url": "https://developer.mozilla.org/en-US/docs/Glossary/Argument"
        }
      ]
    },
    {
      "id": "function-parameter",
      "term": "Function parameter",
      "aliases": [
        "formal parameter",
        "function parameters"
      ],
      "category": "programming",
      "level": "beginner",
      "tags": [
        "programming",
        "javascript"
      ],
      "definition": "A named input in a function definition that receives a value when the function is called.",
      "analogy": "The labeled slot in a vending machine, patiently waiting for an argument-shaped snack.",
      "example": "In function greet(name) { return 'Hi ' + name; }, name is a parameter.",
      "caveat": "In JavaScript, a missing argument normally produces undefined unless a default or other handling applies.",
      "related": [
        "function-argument",
        "function"
      ],
      "sources": [
        {
          "title": "MDN: Function parameter",
          "url": "https://developer.mozilla.org/en-US/docs/Glossary/Parameter"
        }
      ]
    },
    {
      "id": "generative-ai",
      "term": "Generative AI",
      "aliases": [
        "GenAI"
      ],
      "category": "ai",
      "level": "beginner",
      "tags": [
        "ai"
      ],
      "definition": "AI systems that produce new content such as text, images, audio, or code.",
      "analogy": "A pattern-powered studio that can create impressive work and impressive nonsense.",
      "example": "A generative model can draft a caption from an image.",
      "caveat": "Generated content still needs review for accuracy and suitability.",
      "related": [
        "llm",
        "hallucination"
      ],
      "sources": [
        {
          "title": "Google ML Glossary",
          "url": "https://developers.google.com/machine-learning/glossary"
        }
      ]
    },
    {
      "id": "get-request",
      "term": "GET request",
      "aliases": [
        "HTTP GET",
        "GET"
      ],
      "category": "web",
      "level": "beginner",
      "tags": [
        "web"
      ],
      "definition": "An HTTP request asking for a representation of a resource, such as a page or collection of terms.",
      "analogy": "Looking at the menu should not silently place an order for twelve pizzas.",
      "example": "GET /api/terms?q=react requests matching entries without asking the server to change them.",
      "caveat": "GET is defined as safe and idempotent, not side-effect-free internally. Avoid state-changing operations and secrets in URLs; caching is not unconditional.",
      "related": [
        "http",
        "post-request",
        "endpoint"
      ],
      "sources": [
        {
          "title": "MDN: GET request",
          "url": "https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Methods/GET"
        }
      ]
    },
    {
      "id": "git",
      "term": "Git",
      "aliases": [
        "version control"
      ],
      "category": "tools",
      "level": "beginner",
      "tags": [
        "tools"
      ],
      "definition": "A distributed version-control system that records changes and helps people work on code together.",
      "analogy": "A time machine for files, with occasional arguments about parallel universes.",
      "example": "Git records a project change in a commit.",
      "caveat": "Git and GitHub are different things.",
      "related": [
        "commit",
        "repository"
      ],
      "sources": [
        {
          "title": "Pro Git book",
          "url": "https://git-scm.com/book/en/v2"
        }
      ]
    },
    {
      "id": "github-pages",
      "term": "GitHub Pages",
      "aliases": [
        "GH Pages"
      ],
      "category": "tools",
      "level": "beginner",
      "tags": [
        "tools"
      ],
      "definition": "GitHub's hosting service for publishing static websites from repository content or build artifacts.",
      "analogy": "A public shelf for your website, next to the code that made it.",
      "example": "A workflow publishes this dictionary's generated static files.",
      "caveat": "It does not run a Django server or other application backend.",
      "related": [
        "static-site",
        "deployment"
      ],
      "sources": [
        {
          "title": "GitHub Pages documentation",
          "url": "https://docs.github.com/en/pages"
        }
      ]
    },
    {
      "id": "gpu",
      "term": "GPU",
      "aliases": [
        "graphics processing unit"
      ],
      "category": "computer-basics",
      "level": "beginner",
      "tags": [
        "computer-basics"
      ],
      "definition": "A processor designed to perform many similar calculations in parallel.",
      "analogy": "A huge kitchen crew chopping thousands of carrots at once.",
      "example": "GPUs help render games and train many machine-learning models.",
      "caveat": "Not every task gets faster on a GPU.",
      "related": [
        "cpu",
        "machine-learning"
      ],
      "sources": [
        {
          "title": "MDN Glossary",
          "url": "https://developer.mozilla.org/en-US/docs/Glossary"
        }
      ]
    },
    {
      "id": "gui",
      "term": "GUI",
      "aliases": [
        "graphical user interface"
      ],
      "category": "tools",
      "level": "beginner",
      "tags": [
        "tools"
      ],
      "definition": "An interface that uses visual elements such as windows, icons, and buttons.",
      "analogy": "The click-and-point version of talking to a computer.",
      "example": "A visual Git client provides buttons for staging changes.",
      "caveat": "A GUI can expose the same operations as a CLI in a different form.",
      "related": [
        "cli",
        "ux"
      ],
      "sources": [
        {
          "title": "MDN Glossary",
          "url": "https://developer.mozilla.org/en-US/docs/Glossary"
        }
      ]
    },
    {
      "id": "hallucination",
      "term": "Hallucination",
      "aliases": [
        "AI hallucination",
        "confabulation"
      ],
      "category": "ai",
      "level": "beginner",
      "tags": [
        "ai"
      ],
      "definition": "Generated output that is unsupported, false, or inconsistent with the available information.",
      "analogy": "The model confidently giving directions to a cafe it just invented.",
      "example": "An assistant might invent a citation for a paper that does not exist.",
      "caveat": "The term does not imply the model is having a human experience.",
      "related": [
        "llm",
        "rag"
      ],
      "sources": [
        {
          "title": "Survey of hallucination in language generation",
          "url": "https://arxiv.org/abs/2202.03629"
        }
      ]
    },
    {
      "id": "hard-coding",
      "term": "Hard-coding",
      "aliases": [
        "hardcoding",
        "hard-coded value"
      ],
      "category": "programming",
      "level": "beginner",
      "tags": [
        "programming",
        "javascript"
      ],
      "definition": "Embedding a fixed value directly in code instead of obtaining it from configuration, input, or another data source.",
      "analogy": "Writing the Wi-Fi password on the wall and calling the wall a configuration system.",
      "example": "const apiUrl = 'https://api.example.com'; hard-codes an API base URL.",
      "caveat": "Fixed values can be appropriate constants. Secrets and environment-specific settings usually need safer, changeable configuration.",
      "related": [
        "environment-variable",
        "secret",
        "refactoring"
      ],
      "sources": [
        {
          "title": "Hard-coding — reference and documentation",
          "url": "https://cwe.mitre.org/data/definitions/547.html"
        }
      ]
    },
    {
      "id": "harness",
      "term": "Harness",
      "aliases": [
        "test harness",
        "agent harness",
        "software harness"
      ],
      "category": "tools",
      "level": "intermediate",
      "tags": [
        "tools"
      ],
      "definition": "Surrounding infrastructure that runs and controls a program, test, or AI agent, providing inputs, tools, execution rules, and result collection.",
      "analogy": "The stage crew, safety ropes, and cue sheet that let the performer do more than improvise in an empty room.",
      "example": "A test harness prepares fixtures and collects results; an agent harness manages tool calls, context, and execution loops.",
      "caveat": "The meaning depends on context. A harness is not the model or application logic itself, and it cannot guarantee correct behavior.",
      "related": [
        "test-suite",
        "ai-agent",
        "claude-code"
      ],
      "sources": [
        {
          "title": "Anthropic: Demystifying evals for AI agents",
          "url": "https://www.anthropic.com/research/demystifying-evals-for-ai-agents"
        },
        {
          "title": "Python unittest: test runner and fixtures",
          "url": "https://docs.python.org/3/library/unittest.html"
        }
      ]
    },
    {
      "id": "hashing",
      "term": "Hashing",
      "aliases": [
        "hash",
        "cryptographic hash"
      ],
      "category": "security",
      "level": "intermediate",
      "tags": [
        "security"
      ],
      "definition": "Mapping input to a fixed-size output; cryptographic hashes are designed to resist certain attacks.",
      "analogy": "A data fingerprint, not a tiny recoverable photocopy.",
      "example": "A file hash can help check whether file contents changed.",
      "caveat": "Password storage needs a suitable password-hashing scheme, not a plain fast hash.",
      "related": [
        "encryption",
        "salting"
      ],
      "sources": [
        {
          "title": "OWASP Cheat Sheet Series",
          "url": "https://cheatsheetseries.owasp.org/"
        }
      ]
    },
    {
      "id": "headless",
      "term": "Headless",
      "aliases": [
        "headless browser",
        "headless software"
      ],
      "category": "tools",
      "level": "intermediate",
      "tags": [
        "tools"
      ],
      "definition": "Describes software operating without its usual visible graphical interface, or a system whose presentation layer is separated from its core.",
      "analogy": "The restaurant kitchen can still cook even when there is no dining room attached.",
      "example": "A headless browser loads a page, runs JavaScript, and checks behavior without opening a visible browser window.",
      "caveat": "Context matters: a headless browser still renders internally, while a headless CMS exposes content for a separate frontend.",
      "related": [
        "gui",
        "api",
        "frontend"
      ],
      "sources": [
        {
          "title": "Headless — reference and documentation",
          "url": "https://developer.chrome.com/docs/chromium/headless"
        }
      ]
    },
    {
      "id": "hexadecimal",
      "term": "Hexadecimal",
      "aliases": [
        "hex",
        "base sixteen"
      ],
      "category": "computer-basics",
      "level": "intermediate",
      "tags": [
        "computer-basics"
      ],
      "definition": "A number system with sixteen digits: 0–9 and A–F.",
      "analogy": "Binary put on a shorter coat so humans could read it.",
      "example": "The CSS color #FF0000 is bright red.",
      "caveat": "A–F represent the decimal values 10–15.",
      "related": [
        "binary",
        "css"
      ],
      "sources": [
        {
          "title": "MDN Glossary",
          "url": "https://developer.mozilla.org/en-US/docs/Glossary"
        }
      ]
    },
    {
      "id": "hoisting",
      "term": "Hoisting",
      "aliases": [],
      "category": "programming",
      "level": "intermediate",
      "tags": [
        "programming",
        "javascript"
      ],
      "definition": "The name for declaration behaviors that can make bindings affect a scope before execution reaches their written declaration.",
      "analogy": "The guest list reaches the party before some guests receive permission to enter.",
      "example": "sayHi(); function sayHi() { return 'Hi'; } works because the function declaration is initialized early.",
      "caveat": "Source code is not literally moved. var is initialized to undefined early; let, const, and classes cannot be used before initialization.",
      "related": [
        "var",
        "let",
        "const",
        "variable-initialization"
      ],
      "sources": [
        {
          "title": "MDN: Hoisting",
          "url": "https://developer.mozilla.org/en-US/docs/Glossary/Hoisting"
        }
      ]
    },
    {
      "id": "html",
      "term": "HTML",
      "aliases": [
        "HyperText Markup Language"
      ],
      "category": "web",
      "level": "beginner",
      "tags": [
        "web"
      ],
      "definition": "The markup language that describes the structure and meaning of web content using elements such as headings, links, and forms.",
      "analogy": "The building's labeled rooms before CSS chooses the wallpaper.",
      "example": "<button type=\"button\">Search</button> marks up a native button.",
      "caveat": "HTML describes structure and semantics; use CSS for presentation and JavaScript for additional behavior. Native elements often provide useful accessibility behavior.",
      "related": [
        "css",
        "javascript",
        "semantic-html"
      ],
      "sources": [
        {
          "title": "MDN: HTML",
          "url": "https://developer.mozilla.org/en-US/docs/Web/HTML"
        }
      ]
    },
    {
      "id": "http",
      "term": "HTTP",
      "aliases": [
        "Hypertext Transfer Protocol"
      ],
      "category": "web",
      "level": "beginner",
      "tags": [
        "web"
      ],
      "definition": "An application-level request-response protocol used to exchange representations and metadata between clients and servers.",
      "analogy": "The agreed conversation format that stops browsers and servers from communicating entirely through awkward waving.",
      "example": "A browser sends GET /terms; the server replies with a status code, headers, and a response body.",
      "caveat": "Plain HTTP does not encrypt traffic. HTTPS protects HTTP with TLS; stateless protocol semantics do not mean applications cannot maintain sessions.",
      "related": [
        "https",
        "request-header",
        "content-type",
        "client"
      ],
      "sources": [
        {
          "title": "RFC 9110: HTTP Semantics",
          "url": "https://www.rfc-editor.org/rfc/rfc9110"
        }
      ]
    },
    {
      "id": "httponly-cookie",
      "term": "HttpOnly cookie",
      "aliases": [
        "HTTP-only cookie",
        "HTTP only cookie"
      ],
      "category": "security",
      "level": "intermediate",
      "tags": [
        "security"
      ],
      "definition": "A cookie marked HttpOnly so browser JavaScript cannot read or change it through APIs such as document.cookie.",
      "analogy": "A cookie jar behind the counter: scripts cannot grab it, but the browser waiter can still serve it.",
      "example": "Set-Cookie: session=opaque-id; HttpOnly; Secure; SameSite=Lax; Path=/",
      "caveat": "HttpOnly reduces token theft through script access; it does not prevent malicious requests, XSS itself, or all CSRF attacks.",
      "related": [
        "cookie",
        "xss",
        "csrf",
        "session"
      ],
      "sources": [
        {
          "title": "MDN: HttpOnly cookie",
          "url": "https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/Set-Cookie"
        }
      ]
    },
    {
      "id": "https",
      "term": "HTTPS",
      "aliases": [
        "HTTP secure"
      ],
      "category": "web",
      "level": "beginner",
      "tags": [
        "web"
      ],
      "definition": "HTTP carried over a connection protected by TLS.",
      "analogy": "HTTP wearing a locked, tamper-evident envelope.",
      "example": "An https:// address uses encrypted transport when the connection is valid.",
      "caveat": "HTTPS does not guarantee a site's content or business is trustworthy.",
      "related": [
        "http",
        "tls"
      ],
      "sources": [
        {
          "title": "MDN web documentation",
          "url": "https://developer.mozilla.org/en-US/docs/Web"
        }
      ]
    },
    {
      "id": "io",
      "term": "I/O",
      "aliases": [
        "input/output",
        "input output"
      ],
      "category": "computer-basics",
      "level": "beginner",
      "tags": [
        "computer-basics"
      ],
      "definition": "Moving data into or out of a program or system, such as reading a file or communicating over a network.",
      "analogy": "The kitchen's deliveries and serving hatch, rather than the actual chopping of onions.",
      "example": "Reading terms.yaml from disk and fetching terms from a server are both I/O operations.",
      "caveat": "I/O can block or be asynchronous depending on the API. Non-blocking I/O does not make CPU-heavy computation faster.",
      "related": [
        "async",
        "storage",
        "server"
      ],
      "sources": [
        {
          "title": "I/O — reference and documentation",
          "url": "https://nodejs.org/en/learn/asynchronous-work/overview-of-blocking-vs-non-blocking"
        }
      ]
    },
    {
      "id": "ide",
      "term": "IDE",
      "aliases": [
        "integrated development environment"
      ],
      "category": "tools",
      "level": "beginner",
      "tags": [
        "tools"
      ],
      "definition": "An application combining tools for writing, running, and inspecting code.",
      "analogy": "A workbench with the editor, toolbox, and magnifying glass built in.",
      "example": "An IDE can offer code completion and a debugger.",
      "caveat": "The boundary between an IDE and an extensible editor is fuzzy.",
      "related": [
        "debugging",
        "compiler"
      ],
      "sources": [
        {
          "title": "VS Code documentation",
          "url": "https://code.visualstudio.com/docs"
        }
      ]
    },
    {
      "id": "immutable",
      "term": "Immutable",
      "aliases": [
        "immutability",
        "immutable data"
      ],
      "category": "programming",
      "level": "intermediate",
      "tags": [
        "programming",
        "javascript"
      ],
      "definition": "Unable to change after creation, or deliberately treated as unchangeable so updates produce new values instead.",
      "analogy": "A printed menu: publish a new edition instead of scribbling over everyone's copy.",
      "example": "const next = [...items, 'new']; creates a new array rather than pushing into items.",
      "caveat": "JavaScript objects are mutable by default. const protects the binding, and Object.freeze is shallow unless nested values are handled too.",
      "related": [
        "mutation",
        "const",
        "pure-function"
      ],
      "sources": [
        {
          "title": "MDN: Immutable",
          "url": "https://developer.mozilla.org/en-US/docs/Glossary/Immutable"
        }
      ]
    },
    {
      "id": "inference",
      "term": "Inference",
      "aliases": [
        "model inference"
      ],
      "category": "ai",
      "level": "beginner",
      "tags": [
        "ai"
      ],
      "definition": "Using a model to produce an output from new input.",
      "analogy": "The exam after practice: the model uses what it already learned.",
      "example": "A trained image model predicts what is in a new photo.",
      "caveat": "Inference usually does not update the model's weights.",
      "related": [
        "training",
        "model"
      ],
      "sources": [
        {
          "title": "Google ML Glossary",
          "url": "https://developers.google.com/machine-learning/glossary"
        }
      ]
    },
    {
      "id": "initial-state",
      "term": "Initial state",
      "aliases": [
        "starting state"
      ],
      "category": "web",
      "level": "beginner",
      "tags": [
        "web",
        "react"
      ],
      "definition": "The state value an application or component starts with before its later updates.",
      "analogy": "The board game's setup before someone immediately disputes the rules.",
      "example": "const [count, setCount] = useState(0); starts count at 0.",
      "caveat": "React uses the initial useState value on the initial render, not to reset state whenever props change. Initializer functions should be pure.",
      "related": [
        "state-management",
        "react-component",
        "mutation"
      ],
      "sources": [
        {
          "title": "Initial state — reference and documentation",
          "url": "https://react.dev/reference/react/useState"
        }
      ]
    },
    {
      "id": "integration-test",
      "term": "Integration test",
      "aliases": [
        "integration testing"
      ],
      "category": "tools",
      "level": "intermediate",
      "tags": [
        "tools"
      ],
      "definition": "A test that checks whether multiple parts work together correctly across a chosen boundary.",
      "analogy": "Checking that the toaster, socket, and bread can cooperate before inviting guests.",
      "example": "An API integration test sends a request through routing, validation, and database access and checks the result.",
      "caveat": "Define the boundary explicitly; teams use the label differently. A mocked network layer cannot prove the real remote service works.",
      "related": [
        "unit-test",
        "test-suite",
        "api"
      ],
      "sources": [
        {
          "title": "Integration test — reference and documentation",
          "url": "https://martinfowler.com/bliki/IntegrationTest.html"
        }
      ]
    },
    {
      "id": "interface",
      "term": "Interface",
      "aliases": [
        "software interface"
      ],
      "category": "programming",
      "level": "beginner",
      "tags": [
        "programming",
        "javascript"
      ],
      "definition": "A defined boundary through which people or software interact with a system, specifying the available operations or information.",
      "analogy": "The service window: an agreed way to ask for help without climbing inside the kitchen.",
      "example": "A storage interface can specify get(key), set(key, value), and remove(key).",
      "caveat": "Context changes the meaning: UI, API, and TypeScript interface are related ideas. A TypeScript interface alone does not validate runtime data.",
      "related": [
        "api",
        "ui",
        "coupling"
      ],
      "sources": [
        {
          "title": "MDN: Interface",
          "url": "https://developer.mozilla.org/en-US/docs/Glossary/Interface"
        }
      ]
    },
    {
      "id": "interpreter",
      "term": "Interpreter",
      "aliases": [
        "interpretation"
      ],
      "category": "programming",
      "level": "intermediate",
      "tags": [
        "programming"
      ],
      "definition": "A program that carries out instructions from code or an intermediate representation.",
      "analogy": "The translator working through the script as the show happens.",
      "example": "A shell interprets commands you enter.",
      "caveat": "Many interpreters also compile code internally.",
      "related": [
        "compiler",
        "runtime"
      ],
      "sources": [
        {
          "title": "Python language tutorial",
          "url": "https://docs.python.org/3/tutorial/"
        },
        {
          "title": "MDN Glossary",
          "url": "https://developer.mozilla.org/en-US/docs/Glossary"
        }
      ]
    },
    {
      "id": "ip-address",
      "term": "IP address",
      "aliases": [
        "Internet Protocol address",
        "IPv4",
        "IPv6"
      ],
      "category": "networking",
      "level": "beginner",
      "tags": [
        "networking"
      ],
      "definition": "An address used to identify an interface or destination for IP communication.",
      "analogy": "A delivery address for network traffic, with some very complicated apartment rules.",
      "example": "A device can have a local IPv4 address such as 192.168.1.10.",
      "caveat": "Addresses can change or be shared; they are not reliable person identifiers.",
      "related": [
        "dns",
        "tcp"
      ],
      "sources": [
        {
          "title": "MDN Glossary",
          "url": "https://developer.mozilla.org/en-US/docs/Glossary"
        }
      ]
    },
    {
      "id": "iteration",
      "term": "Iteration",
      "aliases": [
        "iterate",
        "feedback loop"
      ],
      "category": "product",
      "level": "beginner",
      "tags": [
        "product"
      ],
      "definition": "A repeated cycle of trying, learning, and improving.",
      "analogy": "Build a little, learn a little, stop defending the first pancake.",
      "example": "A team refines search after seeing which queries return no results.",
      "caveat": "Repeated changes are useful when they are guided by evidence.",
      "related": [
        "mvp",
        "ab-test"
      ],
      "sources": [
        {
          "title": "GOV.UK: Agile delivery",
          "url": "https://www.gov.uk/service-manual/agile-delivery"
        }
      ]
    },
    {
      "id": "javascript",
      "term": "JavaScript",
      "aliases": [
        "JS",
        "ECMAScript"
      ],
      "category": "web",
      "level": "beginner",
      "tags": [
        "web",
        "javascript"
      ],
      "definition": "A programming language used for web interactions and many server, desktop, and tooling tasks.",
      "analogy": "The page's backstage crew, turning decorative buttons into buttons that actually do things.",
      "example": "document.querySelector('button').addEventListener('click', () => alert('Hi'));",
      "caveat": "JavaScript is not Java. Browser APIs and Node.js APIs come from their environments rather than the language alone.",
      "related": [
        "html",
        "node-js",
        "es6"
      ],
      "sources": [
        {
          "title": "MDN: JavaScript",
          "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript"
        }
      ]
    },
    {
      "id": "jest",
      "term": "Jest",
      "aliases": [
        "Jest testing framework"
      ],
      "category": "tools",
      "level": "beginner",
      "tags": [
        "tools",
        "javascript"
      ],
      "definition": "A JavaScript testing framework with a test runner, assertions, mocking utilities, and coverage support.",
      "analogy": "The rehearsal supervisor who runs the scenes and points at the actor who forgot their expected value.",
      "example": "test('adds numbers', () => { expect(1 + 2).toBe(3); }); defines a Jest test.",
      "caveat": "Jest does not itself supply a real browser. DOM simulations, module transforms, and environment setup depend on your configuration.",
      "related": [
        "test-suite",
        "assertion",
        "mock",
        "unit-test"
      ],
      "sources": [
        {
          "title": "Jest — reference and documentation",
          "url": "https://jestjs.io/docs/getting-started"
        }
      ]
    },
    {
      "id": "jquery",
      "term": "jQuery",
      "aliases": [
        "jQuery library"
      ],
      "category": "web",
      "level": "beginner",
      "tags": [
        "web",
        "javascript"
      ],
      "definition": "A JavaScript library that offers concise DOM selection, manipulation, events, and Ajax utilities.",
      "analogy": "A well-traveled multitool from the era when browsers could not agree on how to open a drawer.",
      "example": "$('button').on('click', () => $('.message').text('Hello')); attaches an event handler.",
      "caveat": "Many tasks now have convenient native browser APIs. Avoid changing React-managed DOM with jQuery without a clear integration boundary.",
      "related": [
        "dom",
        "ajax",
        "library"
      ],
      "sources": [
        {
          "title": "jQuery — reference and documentation",
          "url": "https://api.jquery.com/"
        }
      ]
    },
    {
      "id": "json",
      "term": "JSON",
      "aliases": [
        "JavaScript Object Notation"
      ],
      "category": "web",
      "level": "beginner",
      "tags": [
        "web"
      ],
      "definition": "A text format for structured data using objects, arrays, strings, numbers, booleans, and null.",
      "analogy": "A tidy packing list for data, with a strict ban on comments and trailing-comma freeloaders.",
      "example": "{\"name\":\"Ada\",\"skills\":[\"React\",\"Node.js\"]} is JSON text that JSON.parse can turn into JavaScript data.",
      "caveat": "JSON is not a JavaScript object. It cannot directly represent functions, undefined, or cyclic references, and object keys require double quotes.",
      "related": [
        "stringify",
        "serialization",
        "object"
      ],
      "sources": [
        {
          "title": "MDN: JSON",
          "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON"
        }
      ]
    },
    {
      "id": "jsx",
      "term": "JSX",
      "aliases": [
        "JavaScript XML"
      ],
      "category": "web",
      "level": "beginner",
      "tags": [
        "web",
        "react"
      ],
      "definition": "A JavaScript syntax extension for describing UI with HTML-like markup that tooling transforms into JavaScript element creation.",
      "analogy": "HTML's familiar outfit worn by JavaScript, with slightly different pockets.",
      "example": "const heading = <h1 className=\"title\">Hello</h1>; describes an element for React to render.",
      "caveat": "JSX is not an HTML string and browsers do not generally execute it directly. Its rules include className and explicitly closed tags.",
      "related": [
        "react-component",
        "babel",
        "dom"
      ],
      "sources": [
        {
          "title": "JSX — reference and documentation",
          "url": "https://react.dev/learn/writing-markup-with-jsx"
        }
      ]
    },
    {
      "id": "jwt",
      "term": "JWT",
      "aliases": [
        "JSON Web Token"
      ],
      "category": "security",
      "level": "intermediate",
      "tags": [
        "security"
      ],
      "definition": "A compact format for carrying claims, such as a user ID, in a token that can be signed or encrypted.",
      "analogy": "A pocket-sized claim ticket; the bouncer still has to check who issued it.",
      "example": "An API validates a signed JWT's signature, issuer, audience, and expiration before accepting its claims.",
      "caveat": "A signed JWT is usually readable, not encrypted. Decoding claims is not validation, and JWT is not an authentication protocol.",
      "related": [
        "access-token",
        "refresh-token",
        "authentication"
      ],
      "sources": [
        {
          "title": "RFC 7519: JSON Web Token",
          "url": "https://www.rfc-editor.org/rfc/rfc7519"
        },
        {
          "title": "RFC 8725: JSON Web Token Best Current Practices",
          "url": "https://www.rfc-editor.org/rfc/rfc8725"
        }
      ]
    },
    {
      "id": "kernel",
      "term": "Kernel",
      "aliases": [],
      "category": "computer-basics",
      "level": "intermediate",
      "tags": [
        "computer-basics"
      ],
      "definition": "The core of an operating system that manages resources such as memory and devices.",
      "analogy": "The backstage manager you rarely see but absolutely need.",
      "example": "The Linux kernel schedules processes and handles device access.",
      "caveat": "The kernel is one part of an operating system.",
      "related": [
        "operating-system",
        "process"
      ],
      "sources": [
        {
          "title": "MDN Glossary",
          "url": "https://developer.mozilla.org/en-US/docs/Glossary"
        }
      ]
    },
    {
      "id": "kpi",
      "term": "KPI",
      "aliases": [
        "key performance indicator"
      ],
      "category": "product",
      "level": "intermediate",
      "tags": [
        "product"
      ],
      "definition": "A chosen measure used to track progress toward an important objective.",
      "analogy": "The dashboard gauge that matters, not every number the engine can produce.",
      "example": "A dictionary might track the proportion of searches that find a useful entry.",
      "caveat": "A metric is not automatically a good target.",
      "related": [
        "ab-test",
        "mvp"
      ],
      "sources": [
        {
          "title": "GOV.UK: Measuring success",
          "url": "https://www.gov.uk/service-manual/measuring-success"
        }
      ]
    },
    {
      "id": "llm",
      "term": "Large language model",
      "aliases": [
        "LLM",
        "language model"
      ],
      "category": "ai",
      "level": "beginner",
      "tags": [
        "ai"
      ],
      "definition": "A large model trained on language-related data to predict or generate token sequences.",
      "analogy": "A very practiced text predictor that can sound confident even when it is wrong.",
      "example": "An LLM can draft a summary or help explain code.",
      "caveat": "Fluent text is not evidence of factual accuracy.",
      "related": [
        "token",
        "hallucination"
      ],
      "sources": [
        {
          "title": "Google ML Glossary",
          "url": "https://developers.google.com/machine-learning/glossary"
        }
      ]
    },
    {
      "id": "latency",
      "term": "Latency",
      "aliases": [
        "response delay"
      ],
      "category": "networking",
      "level": "beginner",
      "tags": [
        "networking"
      ],
      "definition": "The time delay between an action and a relevant response.",
      "analogy": "How long after 'hello?' you have to wait for 'hello!'.",
      "example": "A request may take 120 milliseconds to receive its response.",
      "caveat": "Specify what is measured; one-way and round-trip latency differ.",
      "related": [
        "bandwidth",
        "cdn"
      ],
      "sources": [
        {
          "title": "MDN Glossary",
          "url": "https://developer.mozilla.org/en-US/docs/Glossary"
        }
      ]
    },
    {
      "id": "leaf-component",
      "term": "Leaf component",
      "aliases": [
        "leaf components"
      ],
      "category": "web",
      "level": "intermediate",
      "tags": [
        "web",
        "react"
      ],
      "definition": "A component at the end of a component hierarchy that does not render other custom components below it.",
      "analogy": "The family-tree cousin who brings no plus-ones to the component reunion.",
      "example": "A PriceLabel component that returns only <span>$10</span> can be a leaf in the component tree.",
      "caveat": "Leaf depends on which tree you mean: DOM nodes, rendered components, and React's ownership relationships are not identical.",
      "related": [
        "react-component",
        "child-component",
        "virtual-dom-tree"
      ],
      "sources": [
        {
          "title": "Leaf component — reference and documentation",
          "url": "https://react.dev/learn/understanding-your-ui-as-a-tree"
        }
      ]
    },
    {
      "id": "least-privilege",
      "term": "Least privilege",
      "aliases": [],
      "category": "security",
      "level": "intermediate",
      "tags": [
        "security"
      ],
      "definition": "Giving an identity only the access needed to perform its required tasks.",
      "analogy": "Giving the gardener a garden key, not the keys to every apartment.",
      "example": "A read-only reporting account should not be able to delete database tables.",
      "caveat": "Permissions need review as tasks and roles change.",
      "related": [
        "authorization",
        "secret"
      ],
      "sources": [
        {
          "title": "OWASP Cheat Sheet Series",
          "url": "https://cheatsheetseries.owasp.org/"
        }
      ]
    },
    {
      "id": "let",
      "term": "let",
      "aliases": [
        "let declaration"
      ],
      "category": "programming",
      "level": "beginner",
      "tags": [
        "programming",
        "javascript"
      ],
      "definition": "A JavaScript declaration for a block-scoped variable whose value can be reassigned.",
      "analogy": "A locker key valid for this room, with permission to swap the snacks.",
      "example": "let count = 0; count += 1; updates a variable that belongs to its surrounding block.",
      "caveat": "A let binding exists in a temporal dead zone until initialized; accessing it earlier throws rather than returning undefined.",
      "related": [
        "var",
        "const",
        "hoisting"
      ],
      "sources": [
        {
          "title": "MDN: let",
          "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/let"
        }
      ]
    },
    {
      "id": "library",
      "term": "Library",
      "aliases": [
        "software library",
        "code library"
      ],
      "category": "web",
      "level": "beginner",
      "tags": [
        "web"
      ],
      "definition": "Reusable code that an application calls to perform particular tasks through a defined interface.",
      "analogy": "A toolbox you pick tools from, rather than a foreman deciding your entire workday.",
      "example": "A date-formatting library turns a timestamp into a readable label without supplying your whole application structure.",
      "caveat": "The line between a library and framework can blur. Dependencies still bring maintenance, compatibility, and security responsibilities.",
      "related": [
        "framework",
        "api",
        "dependency"
      ],
      "sources": [
        {
          "title": "MDN: Library",
          "url": "https://developer.mozilla.org/en-US/docs/Learn_web_development/Core/Frameworks_libraries"
        }
      ]
    },
    {
      "id": "linux",
      "term": "Linux",
      "aliases": [
        "GNU/Linux",
        "Linux distribution"
      ],
      "category": "computer-basics",
      "level": "beginner",
      "tags": [
        "computer-basics"
      ],
      "definition": "An operating-system kernel whose name also commonly refers to distributions that combine it with system tools and software.",
      "analogy": "The engine shared by many different buses, each with its own seats and slightly opinionated dashboard.",
      "example": "Ubuntu and Fedora are Linux distributions often used for development or running servers.",
      "caveat": "Strictly, Linux is the kernel; a distribution supplies the rest. Package managers and defaults vary between distributions.",
      "related": [
        "kernel",
        "operating-system",
        "server"
      ],
      "sources": [
        {
          "title": "Linux — reference and documentation",
          "url": "https://www.kernel.org/linux.html"
        }
      ]
    },
    {
      "id": "load-balancer",
      "term": "Load balancer",
      "aliases": [
        "load balancing"
      ],
      "category": "devops",
      "level": "intermediate",
      "tags": [
        "devops"
      ],
      "definition": "A component that distributes incoming traffic across available backends.",
      "analogy": "The host seating diners across tables so one waiter does not melt.",
      "example": "Requests can be spread across several application servers.",
      "caveat": "Distribution policies and health checks affect actual behavior.",
      "related": [
        "server",
        "scalability"
      ],
      "sources": [
        {
          "title": "Docker documentation",
          "url": "https://docs.docker.com/get-started/"
        },
        {
          "title": "AWS cloud concepts",
          "url": "https://aws.amazon.com/what-is/cloud-computing/"
        }
      ]
    },
    {
      "id": "long-polling",
      "term": "Long polling",
      "aliases": [
        "long-polling",
        "HTTP long polling"
      ],
      "category": "networking",
      "level": "intermediate",
      "tags": [
        "networking"
      ],
      "definition": "A technique where a client sends a request that the server keeps open until new data is available or a timeout occurs.",
      "analogy": "Calling the help desk and staying on hold until there is actually something worth hearing.",
      "example": "A notifications client receives a held response when an update arrives, then immediately opens the next request.",
      "caveat": "Connections still time out and must reconnect. Long polling differs from repeated short polling, streaming responses, and WebSockets.",
      "related": [
        "http",
        "websocket",
        "webhook"
      ],
      "sources": [
        {
          "title": "RFC 6202: Known Issues and Best Practices for Long Polling and Streaming",
          "url": "https://www.rfc-editor.org/rfc/rfc6202"
        }
      ]
    },
    {
      "id": "loop",
      "term": "Loop",
      "aliases": [
        "iteration"
      ],
      "category": "programming",
      "level": "beginner",
      "tags": [
        "programming"
      ],
      "definition": "Code that repeats while a condition holds or for items in a collection.",
      "analogy": "Your computer saying 'one more time' without getting bored.",
      "example": "A loop can send a reminder for each overdue task.",
      "caveat": "A condition that never changes can cause an infinite loop.",
      "related": [
        "algorithm",
        "recursion"
      ],
      "sources": [
        {
          "title": "Python language tutorial",
          "url": "https://docs.python.org/3/tutorial/"
        },
        {
          "title": "MDN Glossary",
          "url": "https://developer.mozilla.org/en-US/docs/Glossary"
        }
      ]
    },
    {
      "id": "machine-learning",
      "term": "Machine learning",
      "aliases": [
        "ML"
      ],
      "category": "ai",
      "level": "beginner",
      "tags": [
        "ai"
      ],
      "definition": "Methods that learn patterns from data to make predictions or decisions.",
      "analogy": "Instead of writing every rule, you show examples and let math find a pattern.",
      "example": "A model can learn to predict house prices from past sales.",
      "caveat": "Bad or unrepresentative data can produce bad predictions.",
      "related": [
        "model",
        "training"
      ],
      "sources": [
        {
          "title": "Google ML Glossary",
          "url": "https://developers.google.com/machine-learning/glossary"
        }
      ]
    },
    {
      "id": "macos",
      "term": "macOS",
      "aliases": [
        "Mac OS",
        "Mac OS X"
      ],
      "category": "computer-basics",
      "level": "beginner",
      "tags": [
        "computer-basics"
      ],
      "definition": "Apple's operating system for Mac computers, providing the desktop environment and services that applications use.",
      "analogy": "The Mac's building manager, keeping apps, files, and hardware from arguing in the hallway.",
      "example": "A developer uses Terminal on macOS to run Git, Node.js, and a local development server.",
      "caveat": "macOS is not Linux. Both support many Unix-style tools, but commands, file systems, and platform APIs can differ.",
      "related": [
        "operating-system",
        "linux",
        "shell"
      ],
      "sources": [
        {
          "title": "macOS — reference and documentation",
          "url": "https://support.apple.com/guide/mac-help/welcome/mac"
        }
      ]
    },
    {
      "id": "merge",
      "term": "Merge",
      "aliases": [
        "git merge"
      ],
      "category": "tools",
      "level": "intermediate",
      "tags": [
        "tools"
      ],
      "definition": "Combining changes from different development histories.",
      "analogy": "Two timelines agreeing on what the next episode should contain.",
      "example": "A team merges a tested feature branch into main.",
      "caveat": "Conflicting edits may require a human decision.",
      "related": [
        "branch",
        "pull-request"
      ],
      "sources": [
        {
          "title": "Pro Git book",
          "url": "https://git-scm.com/book/en/v2"
        }
      ]
    },
    {
      "id": "method",
      "term": "Method",
      "aliases": [
        "object method"
      ],
      "category": "programming",
      "level": "beginner",
      "tags": [
        "programming",
        "javascript"
      ],
      "definition": "A function associated with an object, usually accessed through one of its properties.",
      "analogy": "A toolbox that comes with its own instruction button instead of a loose instruction leaflet.",
      "example": "const user = { greet() { return 'Hi'; } }; user.greet() calls a method.",
      "caveat": "For ordinary JavaScript functions, this depends on how the function is called. Extracting a method can lose its intended receiver.",
      "related": [
        "function",
        "object",
        "chaining"
      ],
      "sources": [
        {
          "title": "MDN: Method",
          "url": "https://developer.mozilla.org/en-US/docs/Glossary/Method"
        }
      ]
    },
    {
      "id": "migration",
      "term": "Migration",
      "aliases": [
        "database migration"
      ],
      "category": "data",
      "level": "intermediate",
      "tags": [
        "data"
      ],
      "definition": "A versioned change to a database's structure or data.",
      "analogy": "Renovating your data's house with written instructions and hopefully a backup.",
      "example": "A migration can add an optional phone_number column.",
      "caveat": "Large or destructive migrations need a rollout and recovery plan.",
      "related": [
        "schema",
        "backup"
      ],
      "sources": [
        {
          "title": "Django migrations",
          "url": "https://docs.djangoproject.com/en/stable/topics/migrations/"
        }
      ]
    },
    {
      "id": "mvp",
      "term": "Minimum viable product",
      "aliases": [
        "MVP"
      ],
      "category": "product",
      "level": "beginner",
      "tags": [
        "product"
      ],
      "definition": "The smallest product experiment that can test an important assumption with real users.",
      "analogy": "A useful first bicycle, not half a wheel and a motivational poster.",
      "example": "A recipe app tests demand with saving and viewing a small recipe collection.",
      "caveat": "Minimum scope still needs enough quality and value for the intended test.",
      "related": [
        "prototype",
        "iteration"
      ],
      "sources": [
        {
          "title": "GOV.UK: Beta phase",
          "url": "https://www.gov.uk/service-manual/agile-delivery/how-the-beta-phase-works"
        }
      ]
    },
    {
      "id": "mock",
      "term": "Mock",
      "aliases": [
        "mock object",
        "mock function",
        "mocking"
      ],
      "category": "tools",
      "level": "intermediate",
      "tags": [
        "tools"
      ],
      "definition": "A test double configured to replace a collaborator and help verify expected calls or interactions.",
      "analogy": "A rehearsal customer who follows a script and remembers whether you offered the refund.",
      "example": "A mocked sendEmail function lets a test assert that a signup flow requested one welcome email.",
      "caveat": "Mock is often used loosely. A canned-response stub and a behavior-verifying mock serve different purposes; excessive mocking can hide integration failures.",
      "related": [
        "test-double",
        "unit-test",
        "integration-test"
      ],
      "sources": [
        {
          "title": "Mock — reference and documentation",
          "url": "https://martinfowler.com/articles/mocksArentStubs.html"
        }
      ]
    },
    {
      "id": "model",
      "term": "Model",
      "aliases": [
        "AI model",
        "ML model"
      ],
      "category": "ai",
      "level": "beginner",
      "tags": [
        "ai"
      ],
      "definition": "A learned or specified mathematical system that maps inputs to outputs.",
      "analogy": "A recipe whose settings may have been adjusted after tasting many examples.",
      "example": "A spam model maps an email to a spam probability.",
      "caveat": "A model's output is not automatically reliable outside its tested setting.",
      "related": [
        "training",
        "inference"
      ],
      "sources": [
        {
          "title": "Google ML Glossary",
          "url": "https://developers.google.com/machine-learning/glossary"
        }
      ]
    },
    {
      "id": "mvc",
      "term": "Model-View-Controller",
      "aliases": [
        "MVC",
        "Model View Controller"
      ],
      "category": "programming",
      "level": "intermediate",
      "tags": [
        "programming",
        "javascript"
      ],
      "definition": "An architectural pattern that separates domain data and behavior, its presentation, and input handling or coordination.",
      "analogy": "The records clerk, noticeboard, and receptionist have different jobs even when they share an office.",
      "example": "A controller receives a request, asks a model for data, and chooses a view to present the result.",
      "caveat": "MVC has several variants, especially on the web. A React component alone is not a complete MVC architecture.",
      "related": [
        "design-pattern",
        "frontend",
        "backend"
      ],
      "sources": [
        {
          "title": "Model-View-Controller — reference and documentation",
          "url": "https://martinfowler.com/eaaCatalog/modelViewController.html"
        }
      ]
    },
    {
      "id": "module",
      "term": "Module",
      "aliases": [
        "modules",
        "ES module",
        "JavaScript module"
      ],
      "category": "programming",
      "level": "beginner",
      "tags": [
        "programming",
        "javascript"
      ],
      "definition": "A unit of code with its own scope that can explicitly export values and import values from other modules.",
      "analogy": "A workshop with a service window: exported tools go out, private clutter stays inside.",
      "example": "export const double = n => n * 2; can be imported by another JavaScript module.",
      "caveat": "JavaScript has ES modules and other module systems such as CommonJS. Their loading rules and interoperability differ.",
      "related": [
        "es6",
        "node-js",
        "library"
      ],
      "sources": [
        {
          "title": "MDN: Module",
          "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Modules"
        }
      ]
    },
    {
      "id": "mount",
      "term": "Mount",
      "aliases": [
        "mounting",
        "component mount",
        "unmount"
      ],
      "category": "web",
      "level": "intermediate",
      "tags": [
        "web",
        "react"
      ],
      "definition": "The lifecycle event when a component is added to the rendered UI tree; unmounting removes it.",
      "analogy": "A performer entering the stage, not merely changing their hat during the same scene.",
      "example": "Conditionally rendering <SearchPanel /> mounts it when shown and unmounts it when removed.",
      "caveat": "A re-render is not a remount. Effects and cleanup have their own timing; development Strict Mode can replay setup and cleanup to expose problems.",
      "related": [
        "react-component",
        "initial-state",
        "virtual-dom"
      ],
      "sources": [
        {
          "title": "Mount — reference and documentation",
          "url": "https://react.dev/learn/lifecycle-of-reactive-effects"
        }
      ]
    },
    {
      "id": "mfa",
      "term": "Multi-factor authentication",
      "aliases": [
        "MFA",
        "2FA",
        "two-factor authentication"
      ],
      "category": "security",
      "level": "beginner",
      "tags": [
        "security"
      ],
      "definition": "Authentication using more than one distinct category of factor.",
      "analogy": "The door asking for your key and proof that you are carrying it.",
      "example": "A login can require a password and a security key.",
      "caveat": "Two passwords are not two different factor categories.",
      "related": [
        "authentication",
        "phishing"
      ],
      "sources": [
        {
          "title": "OWASP Cheat Sheet Series",
          "url": "https://cheatsheetseries.owasp.org/"
        }
      ]
    },
    {
      "id": "mutation",
      "term": "Mutation",
      "aliases": [
        "data mutation",
        "mutating state"
      ],
      "category": "programming",
      "level": "intermediate",
      "tags": [
        "programming",
        "javascript"
      ],
      "definition": "Changing an existing object or data structure in place rather than producing a separate updated value.",
      "analogy": "Editing the shared whiteboard while everyone else thinks they still have yesterday's photograph.",
      "example": "items.push('new') mutates items; const next = [...items, 'new']; creates a new array.",
      "caveat": "Mutation is not always wrong, but mutating React state or shared inputs can break assumptions. Spread copies are shallow.",
      "related": [
        "immutable",
        "object",
        "array",
        "state-management"
      ],
      "sources": [
        {
          "title": "Mutation — reference and documentation",
          "url": "https://react.dev/learn/updating-objects-in-state"
        }
      ]
    },
    {
      "id": "navigation",
      "term": "Navigation",
      "aliases": [
        "website navigation",
        "app navigation"
      ],
      "category": "product",
      "level": "beginner",
      "tags": [
        "product"
      ],
      "definition": "The controls and structure that help users move between locations or views and understand where they are.",
      "analogy": "The website's signposts, ideally better than 'miscellaneous stuff down that corridor.'",
      "example": "A topic sidebar, breadcrumbs, and links to related terms provide different navigation paths.",
      "caveat": "Navigation should work with keyboards, meaningful link text, and browser history. Use links for destinations and buttons for actions.",
      "related": [
        "ui",
        "accessibility",
        "website"
      ],
      "sources": [
        {
          "title": "Navigation — reference and documentation",
          "url": "https://www.w3.org/WAI/tutorials/menus/"
        }
      ]
    },
    {
      "id": "nested-component",
      "term": "Nested component",
      "aliases": [
        "component nesting"
      ],
      "category": "web",
      "level": "beginner",
      "tags": [
        "web",
        "react"
      ],
      "definition": "A component rendered somewhere inside another component's output, forming a deeper UI hierarchy.",
      "analogy": "A set of nesting dolls, except each doll can receive props and complain about missing keys.",
      "example": "App renders Layout, which renders Sidebar, which renders a SearchBox component.",
      "caveat": "Rendering components inside other components is normal. Defining a component function inside a parent can create a new type each render and reset state.",
      "related": [
        "parent-component",
        "child-component",
        "react-component"
      ],
      "sources": [
        {
          "title": "Nested component — reference and documentation",
          "url": "https://react.dev/learn/preserving-and-resetting-state"
        }
      ]
    },
    {
      "id": "neural-network",
      "term": "Neural network",
      "aliases": [
        "ANN",
        "artificial neural network"
      ],
      "category": "ai",
      "level": "intermediate",
      "tags": [
        "ai"
      ],
      "definition": "A model made of connected layers of numerical operations with adjustable parameters.",
      "analogy": "A relay team of math workers passing transformed numbers onward.",
      "example": "A neural network can transform pixels into class scores.",
      "caveat": "Inspired by brains does not mean it works like a human brain.",
      "related": [
        "deep-learning",
        "parameter"
      ],
      "sources": [
        {
          "title": "Google ML Glossary",
          "url": "https://developers.google.com/machine-learning/glossary"
        }
      ]
    },
    {
      "id": "node-js",
      "term": "Node.js",
      "aliases": [
        "Node",
        "NodeJS"
      ],
      "category": "tools",
      "level": "beginner",
      "tags": [
        "tools",
        "javascript"
      ],
      "definition": "A JavaScript runtime that executes JavaScript outside the browser and supplies APIs for tasks such as networking and file access.",
      "analogy": "JavaScript gets an office outside the browser and immediately starts answering HTTP requests.",
      "example": "A Node.js script reads a YAML file from disk or starts an HTTP server.",
      "caveat": "Node.js is neither a framework nor a browser. Its event loop supports asynchronous I/O, but CPU-heavy synchronous code can still block it.",
      "related": [
        "javascript",
        "runtime",
        "server",
        "io"
      ],
      "sources": [
        {
          "title": "Node.js — reference and documentation",
          "url": "https://nodejs.org/en/learn/getting-started/introduction-to-nodejs"
        }
      ]
    },
    {
      "id": "nosql",
      "term": "NoSQL",
      "aliases": [
        "non-relational database"
      ],
      "category": "data",
      "level": "intermediate",
      "tags": [
        "data"
      ],
      "definition": "A broad label for databases that use models other than conventional relational tables.",
      "analogy": "A data toolbox with document folders, key drawers, and graph-shaped shelves.",
      "example": "A document database can store records as flexible documents.",
      "caveat": "NoSQL does not mean 'no structure' or 'no transactions'.",
      "related": [
        "database",
        "schema"
      ],
      "sources": [
        {
          "title": "PostgreSQL documentation",
          "url": "https://www.postgresql.org/docs/current/"
        },
        {
          "title": "Google ML Glossary",
          "url": "https://developers.google.com/machine-learning/glossary"
        }
      ]
    },
    {
      "id": "npm",
      "term": "npm",
      "aliases": [
        "npm CLI",
        "Node Package Manager"
      ],
      "category": "tools",
      "level": "beginner",
      "tags": [
        "tools",
        "javascript"
      ],
      "definition": "A JavaScript package ecosystem and command-line package manager used to install dependencies, publish packages, and run project scripts.",
      "analogy": "The supply counter for JavaScript projects, including both useful tools and a receipt for everything you ordered.",
      "example": "npm install adds project dependencies; npm run dev runs the project's dev script.",
      "caveat": "npm is not Node.js itself. Review dependencies and lockfile changes; installing packages can run lifecycle scripts.",
      "related": [
        "package-manager",
        "node-js",
        "npx",
        "pnpm"
      ],
      "sources": [
        {
          "title": "npm — reference and documentation",
          "url": "https://docs.npmjs.com/about-npm"
        }
      ]
    },
    {
      "id": "npx",
      "term": "npx",
      "aliases": [
        "npm exec"
      ],
      "category": "tools",
      "level": "beginner",
      "tags": [
        "tools",
        "javascript"
      ],
      "definition": "An npm command for executing package-provided commands, using local packages or fetching missing ones when needed.",
      "analogy": "Borrowing a workshop tool for a job without permanently bolting it to your hallway.",
      "example": "npx eslint . runs the package's command against the current project.",
      "caveat": "A missing package may be downloaded and its code executed. Verify package names and versions rather than treating npx commands as harmless text.",
      "related": [
        "npm",
        "cli",
        "package-manager"
      ],
      "sources": [
        {
          "title": "npx — reference and documentation",
          "url": "https://docs.npmjs.com/cli/v11/commands/npx/"
        }
      ]
    },
    {
      "id": "object",
      "term": "Object",
      "aliases": [
        "JavaScript object",
        "objects"
      ],
      "category": "programming",
      "level": "beginner",
      "tags": [
        "programming",
        "javascript"
      ],
      "definition": "A JavaScript value that groups properties identified by string or symbol keys, often combining data and behavior.",
      "analogy": "A labeled toolbox: name in one compartment, tools in another, and occasionally a function that makes coffee.",
      "example": "const user = { name: 'Ada', greet() { return 'Hi'; } }; groups properties and a method.",
      "caveat": "Objects are compared by identity, not by matching contents. Two object literals with the same fields are different objects.",
      "related": [
        "array",
        "method",
        "json"
      ],
      "sources": [
        {
          "title": "MDN: Object",
          "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Working_with_objects"
        }
      ]
    },
    {
      "id": "observability",
      "term": "Observability",
      "aliases": [
        "monitoring",
        "logs metrics traces"
      ],
      "category": "devops",
      "level": "intermediate",
      "tags": [
        "devops"
      ],
      "definition": "The ability to understand a system's internal behavior from the signals it produces.",
      "analogy": "Windows, thermometers, and breadcrumbs for a machine you cannot watch directly.",
      "example": "Logs, metrics, and traces help investigate a slow checkout.",
      "caveat": "Collecting lots of telemetry is not enough; it must support useful questions.",
      "related": [
        "latency",
        "debugging"
      ],
      "sources": [
        {
          "title": "Docker documentation",
          "url": "https://docs.docker.com/get-started/"
        },
        {
          "title": "AWS cloud concepts",
          "url": "https://aws.amazon.com/what-is/cloud-computing/"
        }
      ]
    },
    {
      "id": "one-way-data-flow",
      "term": "One-way data flow",
      "aliases": [
        "unidirectional data flow",
        "one way data flow"
      ],
      "category": "web",
      "level": "intermediate",
      "tags": [
        "web",
        "react"
      ],
      "definition": "An approach where state flows toward the UI, while events request updates through a defined path.",
      "analogy": "A one-way street for data, with event buses reporting back to the traffic controller.",
      "example": "A parent passes count and onIncrement; the child calls onIncrement and receives the updated count on the next render.",
      "caveat": "Callbacks can send events upward without allowing a child to edit its parent's state directly.",
      "related": [
        "props",
        "callback-prop",
        "state-management",
        "flux"
      ],
      "sources": [
        {
          "title": "One-way data flow — reference and documentation",
          "url": "https://react.dev/learn/sharing-state-between-components"
        }
      ]
    },
    {
      "id": "operating-system",
      "term": "Operating system",
      "aliases": [
        "OS"
      ],
      "category": "computer-basics",
      "level": "beginner",
      "tags": [
        "computer-basics"
      ],
      "definition": "Software that manages hardware and provides services for other programs.",
      "analogy": "The hotel manager who gives apps rooms and stops fights over the elevator.",
      "example": "Linux, Windows, and macOS are operating systems.",
      "caveat": "An operating system is more than its visual desktop.",
      "related": [
        "kernel",
        "process"
      ],
      "sources": [
        {
          "title": "MDN Glossary",
          "url": "https://developer.mozilla.org/en-US/docs/Glossary"
        }
      ]
    },
    {
      "id": "optimistic-update",
      "term": "Optimistic updating",
      "aliases": [
        "optimistic update",
        "optimistic UI",
        "optimistic updates"
      ],
      "category": "web",
      "level": "intermediate",
      "tags": [
        "web",
        "react"
      ],
      "definition": "Updating the visible client state before a server operation is confirmed, then reconciling with the actual result.",
      "analogy": "Marking your parcel as packed before the courier agrees to carry it; keep the undo tape handy.",
      "example": "Show a new comment immediately as pending, then replace it with the saved comment or remove it if the request fails.",
      "caveat": "Plan for rejection, retries, conflicts, and duplicate submissions. The server remains authoritative for persisted data and permissions.",
      "related": [
        "state-management",
        "api",
        "mutation"
      ],
      "sources": [
        {
          "title": "Optimistic updating — reference and documentation",
          "url": "https://react.dev/reference/react/useOptimistic"
        }
      ]
    },
    {
      "id": "orm",
      "term": "ORM",
      "aliases": [
        "object-relational mapping"
      ],
      "category": "data",
      "level": "intermediate",
      "tags": [
        "data"
      ],
      "definition": "A technique that maps application objects to relational database data.",
      "analogy": "A translator between your code's objects and your database's tables.",
      "example": "Django's ORM can query rows using Python objects and methods.",
      "caveat": "An ORM does not remove the need to understand database behavior.",
      "related": [
        "sql",
        "backend"
      ],
      "sources": [
        {
          "title": "Django database models",
          "url": "https://docs.djangoproject.com/en/stable/topics/db/models/"
        }
      ]
    },
    {
      "id": "overfitting",
      "term": "Overfitting",
      "aliases": [],
      "category": "ai",
      "level": "intermediate",
      "tags": [
        "ai"
      ],
      "definition": "Learning training-specific details so strongly that performance suffers on new data.",
      "analogy": "Memorizing the practice exam, then panicking when the questions change.",
      "example": "A model fits training noise but predicts poorly on new examples.",
      "caveat": "Evaluate on data that was not used for training or tuning.",
      "related": [
        "training",
        "evaluation"
      ],
      "sources": [
        {
          "title": "Google ML Glossary",
          "url": "https://developers.google.com/machine-learning/glossary"
        }
      ]
    },
    {
      "id": "package-manager",
      "term": "Package manager",
      "aliases": [
        "npm",
        "pnpm",
        "pip",
        "uv"
      ],
      "category": "tools",
      "level": "intermediate",
      "tags": [
        "tools"
      ],
      "definition": "A tool that helps install and manage software packages and their dependencies.",
      "analogy": "The shopper who reads your ingredient list and fetches the right packages.",
      "example": "npm can install dependencies described in package.json.",
      "caveat": "Lockfiles help make dependency resolution repeatable.",
      "related": [
        "dependency",
        "repository"
      ],
      "sources": [
        {
          "title": "npm documentation",
          "url": "https://docs.npmjs.com/"
        }
      ]
    },
    {
      "id": "packet",
      "term": "Packet",
      "aliases": [
        "network packet"
      ],
      "category": "networking",
      "level": "intermediate",
      "tags": [
        "networking"
      ],
      "definition": "A unit of data transmitted over a network, with information needed to handle it.",
      "analogy": "One parcel in a shipment, carrying both contents and delivery details.",
      "example": "A large transfer is carried as many network packets.",
      "caveat": "Packet formats and size limits depend on the network protocols.",
      "related": [
        "tcp",
        "udp"
      ],
      "sources": [
        {
          "title": "MDN Glossary",
          "url": "https://developer.mozilla.org/en-US/docs/Glossary"
        }
      ]
    },
    {
      "id": "parallelism",
      "term": "Parallelism",
      "aliases": [
        "parallel"
      ],
      "category": "programming",
      "level": "intermediate",
      "tags": [
        "programming"
      ],
      "definition": "Executing multiple tasks at the same time using multiple execution resources.",
      "analogy": "Several chefs actually cooking at the same moment.",
      "example": "Several CPU cores can process separate images simultaneously.",
      "caveat": "Parallelism can introduce coordination overhead.",
      "related": [
        "concurrency",
        "thread"
      ],
      "sources": [
        {
          "title": "Python language tutorial",
          "url": "https://docs.python.org/3/tutorial/"
        },
        {
          "title": "MDN Glossary",
          "url": "https://developer.mozilla.org/en-US/docs/Glossary"
        }
      ]
    },
    {
      "id": "parameter",
      "term": "Parameter",
      "aliases": [
        "weights",
        "model weights"
      ],
      "category": "ai",
      "level": "intermediate",
      "tags": [
        "ai"
      ],
      "definition": "A value inside a model that influences its computations and may be learned during training.",
      "analogy": "One of the many knobs adjusted while the model practices.",
      "example": "Training can adjust a neural network's weights.",
      "caveat": "More parameters do not automatically mean better results for every task.",
      "related": [
        "training",
        "neural-network"
      ],
      "sources": [
        {
          "title": "Google ML Glossary",
          "url": "https://developers.google.com/machine-learning/glossary"
        }
      ]
    },
    {
      "id": "parent-component",
      "term": "Parent component",
      "aliases": [
        "React parent component"
      ],
      "category": "web",
      "level": "beginner",
      "tags": [
        "web",
        "react"
      ],
      "definition": "A component that renders another component below it in the UI tree.",
      "analogy": "The dinner host who sets the table and passes props instead of the salt.",
      "example": "function Page() { return <Greeting name=\"Ada\" />; } makes Page the parent of Greeting.",
      "caveat": "Parent and child describe a rendering relationship, not class inheritance. The same component type can have different parents in different places.",
      "related": [
        "child-component",
        "props",
        "react-component"
      ],
      "sources": [
        {
          "title": "Parent component — reference and documentation",
          "url": "https://react.dev/learn/understanding-your-ui-as-a-tree"
        }
      ]
    },
    {
      "id": "phishing",
      "term": "Phishing",
      "aliases": [
        "social engineering"
      ],
      "category": "security",
      "level": "beginner",
      "tags": [
        "security"
      ],
      "definition": "Deceptive messages or sites that trick people into revealing information or taking harmful actions.",
      "analogy": "A scammer wearing a fake help-desk mustache.",
      "example": "A fake login page tries to capture your password.",
      "caveat": "Phishing can arrive through many channels, not only email.",
      "related": [
        "mfa",
        "authentication"
      ],
      "sources": [
        {
          "title": "OWASP Cheat Sheet Series",
          "url": "https://cheatsheetseries.owasp.org/"
        }
      ]
    },
    {
      "id": "pipeline",
      "term": "Pipeline",
      "aliases": [
        "processing pipeline",
        "data pipeline"
      ],
      "category": "programming",
      "level": "intermediate",
      "tags": [
        "programming",
        "javascript"
      ],
      "definition": "A sequence of stages that process input, passing results onward toward an output.",
      "analogy": "A sandwich assembly line, except the cheese stage should not secretly redeploy production.",
      "example": "A search pipeline normalizes text, filters matching entries, sorts results, and formats them for display.",
      "caveat": "Pipeline can also mean CI/CD or shell processing. Error handling, ordering, and backpressure depend on the implementation.",
      "related": [
        "chaining",
        "etl",
        "ci"
      ],
      "sources": [
        {
          "title": "Pipeline — reference and documentation",
          "url": "https://learn.microsoft.com/en-us/azure/architecture/patterns/pipes-and-filters"
        }
      ]
    },
    {
      "id": "pnpm",
      "term": "pnpm",
      "aliases": [
        "performant npm"
      ],
      "category": "tools",
      "level": "beginner",
      "tags": [
        "tools",
        "javascript"
      ],
      "definition": "A JavaScript package manager that uses a shared content-addressed store and linked dependencies to reduce duplicated package data.",
      "analogy": "A shared warehouse instead of buying a fresh identical toolbox for every project.",
      "example": "pnpm install installs dependencies and records resolutions in pnpm-lock.yaml.",
      "caveat": "Its dependency layout can expose undeclared dependencies. Use the package manager and lockfile expected by the project.",
      "related": [
        "npm",
        "package-manager",
        "dependency"
      ],
      "sources": [
        {
          "title": "pnpm — reference and documentation",
          "url": "https://pnpm.io/motivation"
        }
      ]
    },
    {
      "id": "port",
      "term": "Port",
      "aliases": [
        "network port"
      ],
      "category": "networking",
      "level": "intermediate",
      "tags": [
        "networking"
      ],
      "definition": "A numerical identifier that helps transport protocols direct traffic to the right endpoint.",
      "analogy": "The apartment number after the building's IP address.",
      "example": "HTTPS commonly uses TCP port 443.",
      "caveat": "The same port number has separate meanings for different transport protocols.",
      "related": [
        "ip-address",
        "tcp"
      ],
      "sources": [
        {
          "title": "MDN Glossary",
          "url": "https://developer.mozilla.org/en-US/docs/Glossary"
        }
      ]
    },
    {
      "id": "post-request",
      "term": "POST request",
      "aliases": [
        "POST",
        "HTTP POST"
      ],
      "category": "web",
      "level": "beginner",
      "tags": [
        "web"
      ],
      "definition": "An HTTP request asking a resource to process the supplied content according to that resource's rules.",
      "analogy": "Handing a form to the service desk and asking them to do something with it.",
      "example": "POST /api/terms with a JSON body can request creation of a dictionary entry.",
      "caveat": "POST is not limited to creation, not automatically idempotent, and not encrypted without HTTPS. Validate content and permissions server-side.",
      "related": [
        "http",
        "get-request",
        "content-type"
      ],
      "sources": [
        {
          "title": "MDN: POST request",
          "url": "https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Methods/POST"
        }
      ]
    },
    {
      "id": "primary-key",
      "term": "Primary key",
      "aliases": [
        "PK"
      ],
      "category": "data",
      "level": "intermediate",
      "tags": [
        "data"
      ],
      "definition": "A field or set of fields that uniquely identifies each row in a table.",
      "analogy": "A database row's official name badge, with no duplicates allowed.",
      "example": "A user_id can be the primary key of a users table.",
      "caveat": "A primary key can consist of more than one column.",
      "related": [
        "foreign-key",
        "database"
      ],
      "sources": [
        {
          "title": "PostgreSQL documentation",
          "url": "https://www.postgresql.org/docs/current/"
        },
        {
          "title": "Google ML Glossary",
          "url": "https://developers.google.com/machine-learning/glossary"
        }
      ]
    },
    {
      "id": "process",
      "term": "Process",
      "aliases": [],
      "category": "computer-basics",
      "level": "intermediate",
      "tags": [
        "computer-basics"
      ],
      "definition": "A running instance of a program, with its own resources and execution state.",
      "analogy": "A recipe is a program; the chef currently cooking it is a process.",
      "example": "Opening two app instances may create two processes.",
      "caveat": "One program can start several processes.",
      "related": [
        "thread",
        "operating-system"
      ],
      "sources": [
        {
          "title": "MDN Glossary",
          "url": "https://developer.mozilla.org/en-US/docs/Glossary"
        }
      ]
    },
    {
      "id": "promise",
      "term": "Promise",
      "aliases": [
        "JavaScript Promise"
      ],
      "category": "programming",
      "level": "intermediate",
      "tags": [
        "programming",
        "javascript"
      ],
      "definition": "A JavaScript object representing an eventual result: it starts pending and settles as fulfilled with a value or rejected with a reason.",
      "analogy": "A numbered takeaway ticket, not the meal itself and definitely not a guarantee that dinner will succeed.",
      "example": "fetch('/api/terms').then(response => response.json()).then(showTerms).catch(showError); handles an eventual result.",
      "caveat": "Promises are not automatically cancellable or parallel. A .then callback's return value determines the next promise's outcome.",
      "related": [
        "async",
        "async-function",
        "chaining",
        "callback"
      ],
      "sources": [
        {
          "title": "MDN: Promise",
          "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise"
        }
      ]
    },
    {
      "id": "prompt",
      "term": "Prompt",
      "aliases": [
        "prompting"
      ],
      "category": "ai",
      "level": "beginner",
      "tags": [
        "ai"
      ],
      "definition": "The input instructions or context given to a generative model.",
      "analogy": "The brief you hand to an enthusiastic assistant with imperfect judgment.",
      "example": "A prompt can ask for three explanations written for beginners.",
      "caveat": "A clear prompt helps but cannot guarantee correctness.",
      "related": [
        "llm",
        "prompt-engineering"
      ],
      "sources": [
        {
          "title": "Google ML Glossary",
          "url": "https://developers.google.com/machine-learning/glossary"
        }
      ]
    },
    {
      "id": "prompt-engineering",
      "term": "Prompt engineering",
      "aliases": [
        "prompt design"
      ],
      "category": "ai",
      "level": "intermediate",
      "tags": [
        "ai"
      ],
      "definition": "Designing and testing model inputs to improve behavior for a task.",
      "analogy": "Editing the recipe instructions until the assistant stops adding imaginary ingredients.",
      "example": "You can test whether examples improve a classification prompt.",
      "caveat": "It is one part of a system, alongside evaluation and other controls.",
      "related": [
        "prompt",
        "evaluation"
      ],
      "sources": [
        {
          "title": "Google ML Glossary",
          "url": "https://developers.google.com/machine-learning/glossary"
        }
      ]
    },
    {
      "id": "props",
      "term": "Props",
      "aliases": [
        "React props",
        "properties"
      ],
      "category": "web",
      "level": "beginner",
      "tags": [
        "web",
        "react"
      ],
      "definition": "Read-only inputs a React component receives, including values, objects, functions, or JSX.",
      "analogy": "A component's delivery package: use the contents, but do not rewrite the sender's order.",
      "example": "<Avatar name=\"Ada\" size={48} /> passes name and size to Avatar.",
      "caveat": "Props are snapshots for a render. A parent may pass new props later, but the receiving component must not mutate them or their nested objects.",
      "related": [
        "react-component",
        "callback-prop",
        "one-way-data-flow"
      ],
      "sources": [
        {
          "title": "Props — reference and documentation",
          "url": "https://react.dev/learn/passing-props-to-a-component"
        }
      ]
    },
    {
      "id": "prototype",
      "term": "Prototype",
      "aliases": [
        "prototyping"
      ],
      "category": "product",
      "level": "beginner",
      "tags": [
        "product"
      ],
      "definition": "An early representation of a product used to explore or test ideas.",
      "analogy": "A rehearsal that lets you find the awkward parts before opening night.",
      "example": "A clickable mockup can test whether people understand navigation.",
      "caveat": "A prototype may not be usable as a production product.",
      "related": [
        "mvp",
        "usability"
      ],
      "sources": [
        {
          "title": "GOV.UK: Making prototypes",
          "url": "https://www.gov.uk/service-manual/design/making-prototypes"
        }
      ]
    },
    {
      "id": "proxy",
      "term": "Proxy",
      "aliases": [
        "forward proxy",
        "reverse proxy"
      ],
      "category": "networking",
      "level": "intermediate",
      "tags": [
        "networking"
      ],
      "definition": "An intermediary that makes or handles requests on behalf of another party.",
      "analogy": "A middleperson who takes the request, passes it along, and returns the answer.",
      "example": "A reverse proxy can route incoming traffic to backend services.",
      "caveat": "A proxy is not automatically private or secure.",
      "related": [
        "server",
        "load-balancer"
      ],
      "sources": [
        {
          "title": "MDN Glossary",
          "url": "https://developer.mozilla.org/en-US/docs/Glossary"
        }
      ]
    },
    {
      "id": "pull-request",
      "term": "Pull request",
      "aliases": [
        "PR",
        "merge request",
        "MR"
      ],
      "category": "tools",
      "level": "beginner",
      "tags": [
        "tools"
      ],
      "definition": "A proposal to review and integrate changes into a project's branch.",
      "analogy": "A polite 'here's my change; please take a look' with a diff attached.",
      "example": "A contributor opens a pull request to add a dictionary entry.",
      "caveat": "A pull request is a hosting-platform workflow, not a core Git command.",
      "related": [
        "commit",
        "code-review"
      ],
      "sources": [
        {
          "title": "Pro Git book",
          "url": "https://git-scm.com/book/en/v2"
        }
      ]
    },
    {
      "id": "pure-function",
      "term": "Pure function",
      "aliases": [
        "purity"
      ],
      "category": "programming",
      "level": "intermediate",
      "tags": [
        "programming"
      ],
      "definition": "A function whose result depends only on its inputs and that has no observable side effects.",
      "analogy": "A vending machine that gives the same snack for the same buttons, without texting your boss.",
      "example": "A function that adds two numbers without changing other state is pure.",
      "caveat": "Reading changing external state can make a function impure.",
      "related": [
        "function",
        "unit-test"
      ],
      "sources": [
        {
          "title": "Python language tutorial",
          "url": "https://docs.python.org/3/tutorial/"
        },
        {
          "title": "MDN Glossary",
          "url": "https://developer.mozilla.org/en-US/docs/Glossary"
        }
      ]
    },
    {
      "id": "query",
      "term": "Query",
      "aliases": [
        "database query"
      ],
      "category": "data",
      "level": "beginner",
      "tags": [
        "data"
      ],
      "definition": "A request to retrieve or manipulate data.",
      "analogy": "A question for your database, preferably more precise than 'where's my stuff?'.",
      "example": "A query can find all orders placed this week.",
      "caveat": "Queries can change data as well as read it.",
      "related": [
        "sql",
        "index"
      ],
      "sources": [
        {
          "title": "PostgreSQL documentation",
          "url": "https://www.postgresql.org/docs/current/"
        },
        {
          "title": "Google ML Glossary",
          "url": "https://developers.google.com/machine-learning/glossary"
        }
      ]
    },
    {
      "id": "rag",
      "term": "RAG",
      "aliases": [
        "Retrieval-augmented generation",
        "retrieval augmented generation"
      ],
      "category": "ai",
      "level": "intermediate",
      "tags": [
        "ai"
      ],
      "definition": "A technique that retrieves relevant information and supplies it as context to a model so it can generate a better-grounded answer.",
      "analogy": "An open-book exam for an AI that still occasionally misreads the textbook.",
      "example": "A support assistant retrieves relevant help articles before answering a question about refunds.",
      "caveat": "Retrieval does not retrain the model or guarantee correctness. Bad sources, missing context, and fabricated claims remain possible.",
      "related": [
        "llm",
        "embedding",
        "hallucination"
      ],
      "sources": [
        {
          "title": "Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks",
          "url": "https://arxiv.org/abs/2005.11401"
        }
      ]
    },
    {
      "id": "ram",
      "term": "RAM",
      "aliases": [
        "random access memory",
        "memory"
      ],
      "category": "computer-basics",
      "level": "beginner",
      "tags": [
        "computer-basics"
      ],
      "definition": "Working memory that holds data programs need while they run.",
      "analogy": "Your desk: useful now, mysteriously empty after the lights go out.",
      "example": "An editor keeps your open document in RAM.",
      "caveat": "Typical RAM loses its contents when power is removed.",
      "related": [
        "cpu",
        "storage"
      ],
      "sources": [
        {
          "title": "MDN Glossary",
          "url": "https://developer.mozilla.org/en-US/docs/Glossary"
        }
      ]
    },
    {
      "id": "react-component",
      "term": "React component",
      "aliases": [
        "function component",
        "React components"
      ],
      "category": "web",
      "level": "beginner",
      "tags": [
        "web",
        "react"
      ],
      "definition": "A reusable unit of React UI, usually a function that receives props and returns a description of what to render.",
      "analogy": "A small kitchen station: make one dish well instead of running the entire restaurant.",
      "example": "function Greeting({ name }) { return <h1>Hello, {name}</h1>; }",
      "caveat": "A focused responsibility is a design goal, not a one-element rule. Keep rendering pure and use an uppercase component name in JSX.",
      "related": [
        "ui-component",
        "props",
        "jsx",
        "single-responsibility-principle"
      ],
      "sources": [
        {
          "title": "React component — reference and documentation",
          "url": "https://react.dev/learn/your-first-component"
        }
      ]
    },
    {
      "id": "react",
      "term": "React.js",
      "aliases": [
        "React",
        "ReactJS"
      ],
      "category": "web",
      "level": "beginner",
      "tags": [
        "web",
        "react"
      ],
      "definition": "A JavaScript library for building user interfaces from components and updating them as data changes.",
      "analogy": "A stage manager that helps your interface follow the script when the cast's mood changes.",
      "example": "A React search component updates its results when the user changes the search query.",
      "caveat": "React is a library, not a complete application architecture. Routing, data loading, and deployment depend on additional choices.",
      "related": [
        "react-component",
        "jsx",
        "state-management"
      ],
      "sources": [
        {
          "title": "React.js — reference and documentation",
          "url": "https://react.dev/"
        }
      ]
    },
    {
      "id": "recursion",
      "term": "Recursion",
      "aliases": [],
      "category": "programming",
      "level": "intermediate",
      "tags": [
        "programming"
      ],
      "definition": "A technique where a function solves a problem by calling itself on smaller cases.",
      "analogy": "Opening a box containing a smaller box, until you reach the last box.",
      "example": "A function can recursively visit folders inside folders.",
      "caveat": "A stopping case is essential; deep calls can exhaust the stack.",
      "related": [
        "function",
        "stack"
      ],
      "sources": [
        {
          "title": "Python language tutorial",
          "url": "https://docs.python.org/3/tutorial/"
        },
        {
          "title": "MDN Glossary",
          "url": "https://developer.mozilla.org/en-US/docs/Glossary"
        }
      ]
    },
    {
      "id": "reducer",
      "term": "Reducer",
      "aliases": [
        "state reducer",
        "Redux reducer"
      ],
      "category": "programming",
      "level": "intermediate",
      "tags": [
        "programming",
        "javascript"
      ],
      "definition": "A function that calculates an accumulated or next value from the current value and an input; state reducers commonly use the previous state and an action.",
      "analogy": "A scorekeeper who reads one event and writes the next score without secretly ordering pizza.",
      "example": "function reducer(state, action) { return action.type === 'increment' ? state + 1 : state; }",
      "caveat": "React and Redux reducers should be pure and avoid side effects or direct mutation of existing state. Redux Toolkit's draft syntax is a special abstraction.",
      "related": [
        "redux",
        "pure-function",
        "immutable",
        "array"
      ],
      "sources": [
        {
          "title": "Reducer — reference and documentation",
          "url": "https://react.dev/learn/extracting-state-logic-into-a-reducer"
        }
      ]
    },
    {
      "id": "redundancy",
      "term": "Redundancy",
      "aliases": [
        "redundant infrastructure"
      ],
      "category": "devops",
      "level": "intermediate",
      "tags": [
        "devops"
      ],
      "definition": "Having extra instances or alternative resources so one component's failure does not have to stop the system.",
      "analogy": "Keeping a spare microphone because the main one also suffers from stage fright.",
      "example": "Two app instances run in separate failure zones, with enough spare capacity to survive losing one.",
      "caveat": "Redundancy supplies alternatives; failover uses them. A backup file alone is not a live redundant service, and shared dependencies can still fail.",
      "related": [
        "failover",
        "backup",
        "load-balancer"
      ],
      "sources": [
        {
          "title": "Redundancy — reference and documentation",
          "url": "https://learn.microsoft.com/en-us/azure/well-architected/reliability/redundancy"
        }
      ]
    },
    {
      "id": "redux",
      "term": "Redux",
      "aliases": [
        "Redux store",
        "Redux Toolkit"
      ],
      "category": "web",
      "level": "intermediate",
      "tags": [
        "web",
        "react"
      ],
      "definition": "A JavaScript state-management library where dispatched actions describe events and reducers calculate state updates in a store.",
      "analogy": "A central logbook where updates file paperwork before changing the scoreboard.",
      "example": "store.dispatch({ type: 'counter/incremented' }); asks the store to process an action.",
      "caveat": "Redux is not required for every React app. Redux Toolkit is the standard approach; its Immer-powered reducers allow mutation-like syntax without mutating previous state.",
      "related": [
        "reducer",
        "flux",
        "state-management",
        "immutable"
      ],
      "sources": [
        {
          "title": "Redux — reference and documentation",
          "url": "https://redux.js.org/introduction/why-rtk-is-redux-today"
        }
      ]
    },
    {
      "id": "refactoring",
      "term": "Refactoring",
      "aliases": [
        "code refactoring"
      ],
      "category": "tools",
      "level": "intermediate",
      "tags": [
        "tools"
      ],
      "definition": "Restructuring existing code to improve its design while preserving its observable behavior.",
      "analogy": "Reorganizing the kitchen so dinner tastes the same but nobody trips over the toaster.",
      "example": "Extract duplicated validation into a shared function, then verify the same inputs still produce the same results.",
      "caveat": "A feature change or bug fix can accompany refactoring, but changes in behavior should be identified and verified separately.",
      "related": [
        "codebase",
        "unit-test",
        "single-responsibility-principle"
      ],
      "sources": [
        {
          "title": "Refactoring — reference and documentation",
          "url": "https://refactoring.com/"
        }
      ]
    },
    {
      "id": "refresh-token",
      "term": "Refresh token",
      "aliases": [
        "OAuth refresh token"
      ],
      "category": "security",
      "level": "intermediate",
      "tags": [
        "security"
      ],
      "definition": "A credential used with an authorization server to obtain a new access token without repeating the full login flow.",
      "analogy": "The pass-renewal voucher you keep safe, rather than waving at every gym door.",
      "example": "When an access token expires, the client exchanges an eligible refresh token at the token endpoint.",
      "caveat": "Do not send it to ordinary resource endpoints. Storage, expiration, revocation, and rotation or sender binding depend on the client and security policy.",
      "related": [
        "access-token",
        "jwt",
        "authentication"
      ],
      "sources": [
        {
          "title": "RFC 6749: Refresh Token",
          "url": "https://www.rfc-editor.org/rfc/rfc6749#section-1.5"
        },
        {
          "title": "RFC 9700: OAuth 2.0 Security Best Current Practice",
          "url": "https://www.rfc-editor.org/rfc/rfc9700#section-4.14"
        }
      ]
    },
    {
      "id": "reinforcement-learning",
      "term": "Reinforcement learning",
      "aliases": [
        "RL",
        "reward"
      ],
      "category": "ai",
      "level": "advanced",
      "tags": [
        "ai"
      ],
      "definition": "Learning a policy for actions through interaction and reward signals.",
      "analogy": "Trying moves, seeing what scores points, and improving the strategy.",
      "example": "An agent can learn game-playing actions from rewards.",
      "caveat": "A badly designed reward can encourage unintended behavior.",
      "related": [
        "machine-learning",
        "ai-agent"
      ],
      "sources": [
        {
          "title": "Google ML Glossary",
          "url": "https://developers.google.com/machine-learning/glossary"
        }
      ]
    },
    {
      "id": "repository",
      "term": "Repository",
      "aliases": [
        "repo"
      ],
      "category": "tools",
      "level": "beginner",
      "tags": [
        "tools"
      ],
      "definition": "A project's version-controlled files and recorded history.",
      "analogy": "The project's home, scrapbook, and organized junk drawer.",
      "example": "A Git repository contains code, documentation, and commits.",
      "caveat": "A repository can live locally without being hosted online.",
      "related": [
        "git",
        "branch"
      ],
      "sources": [
        {
          "title": "Pro Git book",
          "url": "https://git-scm.com/book/en/v2"
        }
      ]
    },
    {
      "id": "request-header",
      "term": "Request header",
      "aliases": [
        "HTTP request header",
        "request headers"
      ],
      "category": "web",
      "level": "beginner",
      "tags": [
        "web"
      ],
      "definition": "An HTTP header field sent by a client to provide metadata or preferences for a request.",
      "analogy": "The notes attached to a food order: desired format, credentials, and please do not bring extra mystery sauce.",
      "example": "Accept: application/json tells a server which response format the client prefers.",
      "caveat": "Content-Type describes the request body's format, while Accept describes preferred response formats. Browsers control some headers and CORS can restrict others.",
      "related": [
        "http",
        "content-type",
        "cors"
      ],
      "sources": [
        {
          "title": "MDN: Request header",
          "url": "https://developer.mozilla.org/en-US/docs/Glossary/Request_header"
        }
      ]
    },
    {
      "id": "responsive-design",
      "term": "Responsive design",
      "aliases": [
        "responsive",
        "responsive web design",
        "RWD"
      ],
      "category": "web",
      "level": "beginner",
      "tags": [
        "web"
      ],
      "definition": "Designing an interface to adapt to different screen sizes, input methods, and viewing conditions.",
      "analogy": "A layout that changes clothes for the occasion instead of squeezing a desktop suit onto a phone.",
      "example": "A three-column term grid becomes one column on a narrow screen using CSS grid and media queries.",
      "caveat": "Shrinking everything is not enough. Check readable text, touch targets, content order, and actual devices.",
      "related": [
        "css",
        "ui",
        "accessibility"
      ],
      "sources": [
        {
          "title": "MDN: Responsive design",
          "url": "https://developer.mozilla.org/en-US/docs/Learn_web_development/Core/CSS_layout/Responsive_Design"
        }
      ]
    },
    {
      "id": "rest",
      "term": "REST",
      "aliases": [
        "representational state transfer"
      ],
      "category": "web",
      "level": "intermediate",
      "tags": [
        "web"
      ],
      "definition": "An architectural style for distributed systems built around constraints such as statelessness and a uniform interface.",
      "analogy": "Organizing a library so everyone uses the same borrowing rules.",
      "example": "A resource-oriented HTTP API may expose /books and /books/42.",
      "caveat": "Using JSON over HTTP alone does not make an API RESTful.",
      "related": [
        "api",
        "http"
      ],
      "sources": [
        {
          "title": "MDN web documentation",
          "url": "https://developer.mozilla.org/en-US/docs/Web"
        }
      ]
    },
    {
      "id": "retrieve",
      "term": "Retrieve",
      "aliases": [
        "retrieval",
        "data retrieval"
      ],
      "category": "data",
      "level": "beginner",
      "tags": [
        "data"
      ],
      "definition": "Read or obtain stored information from a source such as a database, cache, file, or API.",
      "analogy": "Find the labeled box in storage without pretending you just manufactured its contents.",
      "example": "A search endpoint retrieves matching term records from a database and returns them to the client.",
      "caveat": "Retrieving data does not necessarily modify it or require a network request. Search quality and authorization still matter.",
      "related": [
        "crud",
        "query",
        "rag"
      ],
      "sources": [
        {
          "title": "Retrieve — reference and documentation",
          "url": "https://www.postgresql.org/docs/current/tutorial-select.html"
        }
      ]
    },
    {
      "id": "runtime",
      "term": "Runtime",
      "aliases": [
        "runtime environment"
      ],
      "category": "programming",
      "level": "intermediate",
      "tags": [
        "programming"
      ],
      "definition": "The environment and support software a program uses while executing.",
      "analogy": "The stage, lights, and crew your code needs to perform.",
      "example": "Node.js is a JavaScript runtime outside the browser.",
      "caveat": "A runtime is not necessarily the same thing as a framework.",
      "related": [
        "compiler",
        "framework"
      ],
      "sources": [
        {
          "title": "Python language tutorial",
          "url": "https://docs.python.org/3/tutorial/"
        },
        {
          "title": "MDN Glossary",
          "url": "https://developer.mozilla.org/en-US/docs/Glossary"
        }
      ]
    },
    {
      "id": "salting",
      "term": "Salting",
      "aliases": [
        "salt",
        "password salt"
      ],
      "category": "security",
      "level": "intermediate",
      "tags": [
        "security"
      ],
      "definition": "Adding a unique value to each password before hashing it.",
      "analogy": "Giving each password its own seasoning so identical recipes do not look identical.",
      "example": "Two users with the same password can have different stored password hashes.",
      "caveat": "A salt is usually public; it does not replace a secure password-hashing scheme.",
      "related": [
        "hashing",
        "authentication"
      ],
      "sources": [
        {
          "title": "OWASP Cheat Sheet Series",
          "url": "https://cheatsheetseries.owasp.org/"
        }
      ]
    },
    {
      "id": "scalability",
      "term": "Scalability",
      "aliases": [
        "scale up",
        "scale out"
      ],
      "category": "devops",
      "level": "intermediate",
      "tags": [
        "devops"
      ],
      "definition": "A system's ability to handle more work by changing or adding resources.",
      "analogy": "Inviting more guests without turning dinner into a fire drill.",
      "example": "Adding replicas can help an application serve more requests.",
      "caveat": "A bottleneck in one component can limit the whole system.",
      "related": [
        "load-balancer",
        "database"
      ],
      "sources": [
        {
          "title": "Docker documentation",
          "url": "https://docs.docker.com/get-started/"
        },
        {
          "title": "AWS cloud concepts",
          "url": "https://aws.amazon.com/what-is/cloud-computing/"
        }
      ]
    },
    {
      "id": "schema",
      "term": "Schema",
      "aliases": [
        "database schema"
      ],
      "category": "data",
      "level": "intermediate",
      "tags": [
        "data"
      ],
      "definition": "A description of how data is organized, including fields, types, and constraints.",
      "analogy": "The floor plan for your data, so every room has a purpose.",
      "example": "An orders table might require an ID, customer ID, and total.",
      "caveat": "The word schema also applies to formats such as JSON.",
      "related": [
        "database",
        "migration"
      ],
      "sources": [
        {
          "title": "PostgreSQL documentation",
          "url": "https://www.postgresql.org/docs/current/"
        },
        {
          "title": "Google ML Glossary",
          "url": "https://developers.google.com/machine-learning/glossary"
        }
      ]
    },
    {
      "id": "secret",
      "term": "Secret",
      "aliases": [
        "API key",
        "credentials",
        "access token"
      ],
      "category": "security",
      "level": "beginner",
      "tags": [
        "security"
      ],
      "definition": "Sensitive information that grants access or must remain confidential.",
      "analogy": "The spare key that should never appear in your public README.",
      "example": "A backend stores an API credential outside committed source code.",
      "caveat": "Anything shipped in frontend code can be inspected by users.",
      "related": [
        "authentication",
        "environment-variable"
      ],
      "sources": [
        {
          "title": "OWASP Cheat Sheet Series",
          "url": "https://cheatsheetseries.owasp.org/"
        }
      ]
    },
    {
      "id": "semantic-html",
      "term": "Semantic HTML",
      "aliases": [
        "semantics"
      ],
      "category": "product",
      "level": "intermediate",
      "tags": [
        "product"
      ],
      "definition": "Using HTML elements that describe the meaning and role of content.",
      "analogy": "Putting the correct labels on the drawers instead of painting everything 'box'.",
      "example": "Use a button for an action and a heading for a section title.",
      "caveat": "Semantic elements still need correct content and interaction behavior.",
      "related": [
        "html",
        "accessibility"
      ],
      "sources": [
        {
          "title": "MDN: Semantics",
          "url": "https://developer.mozilla.org/en-US/docs/Glossary/Semantics"
        }
      ]
    },
    {
      "id": "serialization",
      "term": "Serialization",
      "aliases": [
        "serialize",
        "deserialization"
      ],
      "category": "data",
      "level": "intermediate",
      "tags": [
        "data"
      ],
      "definition": "Converting data into a format suitable for storage or transmission.",
      "analogy": "Packing an object into a suitcase, then unpacking it on the other side.",
      "example": "An application can serialize a list as JSON text.",
      "caveat": "Not every format preserves every original data type.",
      "related": [
        "json",
        "encoding"
      ],
      "sources": [
        {
          "title": "PostgreSQL documentation",
          "url": "https://www.postgresql.org/docs/current/"
        },
        {
          "title": "Google ML Glossary",
          "url": "https://developers.google.com/machine-learning/glossary"
        }
      ]
    },
    {
      "id": "server",
      "term": "Server",
      "aliases": [
        "web server"
      ],
      "category": "devops",
      "level": "beginner",
      "tags": [
        "devops"
      ],
      "definition": "A program, or the machine running it, that provides resources or services to clients.",
      "analogy": "The restaurant kitchen answering orders while clients argue about the menu.",
      "example": "A Node.js HTTP server receives GET /terms and returns a JSON response.",
      "caveat": "Server describes a role, not necessarily a powerful physical box. One machine or program can act as both client and server.",
      "related": [
        "client",
        "http",
        "backend"
      ],
      "sources": [
        {
          "title": "MDN: Server",
          "url": "https://developer.mozilla.org/en-US/docs/Learn_web_development/Howto/Web_mechanics/What_is_a_web_server"
        }
      ]
    },
    {
      "id": "ssr",
      "term": "Server-side rendering",
      "aliases": [
        "SSR"
      ],
      "category": "web",
      "level": "intermediate",
      "tags": [
        "web"
      ],
      "definition": "Generating a page's HTML on the server before sending it to the browser.",
      "analogy": "Serving the meal already plated instead of shipping a box of ingredients.",
      "example": "A server renders a product page with its title already in the HTML.",
      "caveat": "SSR can still use client-side JavaScript afterward.",
      "related": [
        "static-site",
        "frontend"
      ],
      "sources": [
        {
          "title": "MDN web documentation",
          "url": "https://developer.mozilla.org/en-US/docs/Web"
        }
      ]
    },
    {
      "id": "serverless",
      "term": "Serverless",
      "aliases": [],
      "category": "devops",
      "level": "intermediate",
      "tags": [
        "devops"
      ],
      "definition": "A model where a provider manages server provisioning and execution infrastructure.",
      "analogy": "The restaurant provides the kitchen; you bring the recipe and pay under its rules.",
      "example": "A function runs when an upload event occurs.",
      "caveat": "There are still servers, and billing and scaling behavior vary.",
      "related": [
        "cloud-computing",
        "server"
      ],
      "sources": [
        {
          "title": "Docker documentation",
          "url": "https://docs.docker.com/get-started/"
        },
        {
          "title": "AWS cloud concepts",
          "url": "https://aws.amazon.com/what-is/cloud-computing/"
        }
      ]
    },
    {
      "id": "session",
      "term": "Session",
      "aliases": [
        "user session"
      ],
      "category": "web",
      "level": "intermediate",
      "tags": [
        "web"
      ],
      "definition": "A way to maintain continuity or state across several interactions.",
      "analogy": "A claim ticket that lets a service remember which visit is yours.",
      "example": "A server can associate a session identifier with a signed-in user.",
      "caveat": "Sessions can expire; their identifiers need protection.",
      "related": [
        "cookie",
        "authentication"
      ],
      "sources": [
        {
          "title": "MDN web documentation",
          "url": "https://developer.mozilla.org/en-US/docs/Web"
        }
      ]
    },
    {
      "id": "shallow-rendering",
      "term": "Shallow rendering",
      "aliases": [
        "shallow render",
        "React shallow rendering"
      ],
      "category": "tools",
      "level": "intermediate",
      "tags": [
        "tools"
      ],
      "definition": "A testing approach that renders a component's immediate output without fully rendering its child components.",
      "analogy": "Inspecting the restaurant's front counter while replacing the kitchen with cardboard cutouts.",
      "example": "A legacy component test examines that a parent returns a Child element without executing Child's rendering logic.",
      "caveat": "It can miss real interactions and integration behavior. React's legacy test renderer is deprecated; favor user-observable tests with maintained tools.",
      "related": [
        "react-component",
        "unit-test",
        "integration-test"
      ],
      "sources": [
        {
          "title": "React: react-test-renderer Deprecation Warnings",
          "url": "https://react.dev/warnings/react-test-renderer"
        }
      ]
    },
    {
      "id": "shell",
      "term": "Shell",
      "aliases": [
        "bash",
        "zsh",
        "command shell"
      ],
      "category": "tools",
      "level": "intermediate",
      "tags": [
        "tools"
      ],
      "definition": "A program that interprets commands and lets you interact with the operating system.",
      "analogy": "The interpreter between your typed requests and the computer's chores.",
      "example": "Bash can run commands and shell scripts.",
      "caveat": "Quoting rules matter when passing data into commands.",
      "related": [
        "cli",
        "operating-system"
      ],
      "sources": [
        {
          "title": "Bash manual",
          "url": "https://www.gnu.org/software/bash/manual/bash.html"
        }
      ]
    },
    {
      "id": "single-responsibility-principle",
      "term": "Single Responsibility Principle",
      "aliases": [
        "SRP",
        "single responsibility"
      ],
      "category": "programming",
      "level": "intermediate",
      "tags": [
        "programming",
        "javascript"
      ],
      "definition": "A design principle that groups code around one responsibility, so it has one coherent reason to change.",
      "analogy": "Do not make the chef also handle payroll just because both tasks involve dough.",
      "example": "Separate invoice calculation from PDF formatting because pricing rules and document layouts change for different reasons.",
      "caveat": "One responsibility does not mean one line, one method, or one HTML element. Choose boundaries based on related reasons for change.",
      "related": [
        "react-component",
        "coupling",
        "refactoring"
      ],
      "sources": [
        {
          "title": "Single Responsibility Principle — reference and documentation",
          "url": "https://blog.cleancoder.com/uncle-bob/2014/05/08/SingleReponsibilityPrinciple.html"
        }
      ]
    },
    {
      "id": "single-page-application",
      "term": "Single-page application",
      "aliases": [
        "SPA",
        "SPAs",
        "single page application"
      ],
      "category": "web",
      "level": "intermediate",
      "tags": [
        "web"
      ],
      "definition": "A web application that handles much of its navigation by updating the current document through JavaScript instead of loading a new document for every view.",
      "analogy": "Renovating the room around you instead of making you leave the building for every new screen.",
      "example": "A client router changes from /terms to /terms/react and updates the view without a full document navigation.",
      "caveat": "The first page can be server-rendered. Deep links, history, accessibility, and SEO still need deliberate handling; API requests may continue throughout use.",
      "related": [
        "web-application",
        "navigation",
        "ssr"
      ],
      "sources": [
        {
          "title": "MDN: Single-page application",
          "url": "https://developer.mozilla.org/en-US/docs/Glossary/SPA"
        }
      ]
    },
    {
      "id": "software-factory",
      "term": "Software factory",
      "aliases": [
        "software factories"
      ],
      "category": "tools",
      "level": "intermediate",
      "tags": [
        "tools"
      ],
      "definition": "An organized set of reusable tools, templates, processes, and automation for producing and delivering software consistently.",
      "analogy": "A workshop with repeatable build stations, rather than a wizard manually forging every release at midnight.",
      "example": "A team supplies service templates, automated tests, security checks, and deployment pipelines for new applications.",
      "caveat": "The term has several industry meanings and is not a specific product. It differs from the Factory Pattern, which concerns object creation in code.",
      "related": [
        "pipeline",
        "ci",
        "cd",
        "factory-pattern"
      ],
      "sources": [
        {
          "title": "Microsoft: Web Service Software Factory Modeling Edition",
          "url": "https://learn.microsoft.com/en-us/archive/msdn-magazine/2008/launch/service-station-web-service-software-factory-modeling-edition"
        }
      ]
    },
    {
      "id": "sql",
      "term": "SQL",
      "aliases": [
        "structured query language"
      ],
      "category": "data",
      "level": "beginner",
      "tags": [
        "data"
      ],
      "definition": "A language used to define, query, and change data in relational databases.",
      "analogy": "Politely asking tables questions, with unusually strict punctuation.",
      "example": "SELECT name FROM users asks for the names in a users table.",
      "caveat": "SQL dialects and supported features vary by database.",
      "related": [
        "database",
        "query"
      ],
      "sources": [
        {
          "title": "PostgreSQL documentation",
          "url": "https://www.postgresql.org/docs/current/"
        },
        {
          "title": "Google ML Glossary",
          "url": "https://developers.google.com/machine-learning/glossary"
        }
      ]
    },
    {
      "id": "sql-injection",
      "term": "SQL injection",
      "aliases": [
        "SQLi"
      ],
      "category": "security",
      "level": "intermediate",
      "tags": [
        "security"
      ],
      "definition": "An attack where untrusted input changes the meaning of a database command.",
      "analogy": "A visitor writing extra instructions on the order slip and hoping the kitchen obeys.",
      "example": "Unsafe string-building can turn a search input into part of a SQL command.",
      "caveat": "Use parameterized queries and appropriate permissions.",
      "related": [
        "sql",
        "query"
      ],
      "sources": [
        {
          "title": "OWASP Cheat Sheet Series",
          "url": "https://cheatsheetseries.owasp.org/"
        }
      ]
    },
    {
      "id": "stack",
      "term": "Stack",
      "aliases": [
        "LIFO",
        "call stack"
      ],
      "category": "programming",
      "level": "intermediate",
      "tags": [
        "programming"
      ],
      "definition": "A structure where the most recently added item is removed first.",
      "analogy": "A stack of plates: taking the bottom one is a risky hobby.",
      "example": "Function calls are commonly tracked using a call stack.",
      "caveat": "Stack storage details vary between languages and runtimes.",
      "related": [
        "data-structure",
        "recursion"
      ],
      "sources": [
        {
          "title": "Python language tutorial",
          "url": "https://docs.python.org/3/tutorial/"
        },
        {
          "title": "MDN Glossary",
          "url": "https://developer.mozilla.org/en-US/docs/Glossary"
        }
      ]
    },
    {
      "id": "state-management",
      "term": "State management",
      "aliases": [
        "application state management"
      ],
      "category": "web",
      "level": "intermediate",
      "tags": [
        "web",
        "react"
      ],
      "definition": "Organizing changing application data, where it lives, how it updates, and which parts of the UI depend on it.",
      "analogy": "Keeping one sensible scoreboard instead of asking every player to remember a different score.",
      "example": "Keep a search query in local state and share selected filters through their nearest common parent.",
      "caveat": "Not every value belongs in a global store. Derived data and cached server data have different needs from local interactive state.",
      "related": [
        "initial-state",
        "redux",
        "one-way-data-flow"
      ],
      "sources": [
        {
          "title": "State management — reference and documentation",
          "url": "https://react.dev/learn/managing-state"
        }
      ]
    },
    {
      "id": "statement",
      "term": "Statement",
      "aliases": [
        "JavaScript statement"
      ],
      "category": "programming",
      "level": "beginner",
      "tags": [
        "programming",
        "react",
        "javascript"
      ],
      "definition": "A unit of code that performs an action or controls execution, such as a declaration, return, or if statement.",
      "analogy": "A script's stage direction: announce a variable, take a turn, or leave the scene.",
      "example": "if (count > 0) { console.log(count); } is a conditional statement.",
      "caveat": "An expression produces a value; a statement describes an action or control structure. Some statements contain expressions.",
      "related": [
        "conditional",
        "variable-declaration",
        "function"
      ],
      "sources": [
        {
          "title": "MDN: Statement",
          "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements"
        }
      ]
    },
    {
      "id": "static-site",
      "term": "Static site",
      "aliases": [
        "static website",
        "SSG",
        "static site generation"
      ],
      "category": "web",
      "level": "beginner",
      "tags": [
        "web"
      ],
      "definition": "A website served from prebuilt files instead of generating each page on demand.",
      "analogy": "A prepared picnic: open the basket and everything is already there.",
      "example": "GitHub Pages can host prebuilt HTML, CSS, and JavaScript.",
      "caveat": "A static site can still have interactive client-side features.",
      "related": [
        "ssr",
        "github-pages"
      ],
      "sources": [
        {
          "title": "MDN web documentation",
          "url": "https://developer.mozilla.org/en-US/docs/Web"
        }
      ]
    },
    {
      "id": "storage",
      "term": "Storage",
      "aliases": [
        "disk",
        "ssd",
        "hdd"
      ],
      "category": "computer-basics",
      "level": "beginner",
      "tags": [
        "computer-basics"
      ],
      "definition": "Hardware that keeps files and other data even when power is off.",
      "analogy": "The filing cabinet your computer remembers to keep overnight.",
      "example": "An SSD stores photos, apps, and the operating system.",
      "caveat": "Storage capacity and RAM capacity solve different problems.",
      "related": [
        "ram",
        "operating-system"
      ],
      "sources": [
        {
          "title": "MDN Glossary",
          "url": "https://developer.mozilla.org/en-US/docs/Glossary"
        }
      ]
    },
    {
      "id": "string",
      "term": "String",
      "aliases": [
        "text string",
        "strings"
      ],
      "category": "programming",
      "level": "beginner",
      "tags": [
        "programming",
        "javascript"
      ],
      "definition": "An immutable JavaScript primitive representing text as a sequence of UTF-16 code units.",
      "analogy": "A text message that must be rewritten, rather than edited one character in place.",
      "example": "const greeting = 'Hello'; greeting.toUpperCase() returns 'HELLO' without changing greeting.",
      "caveat": "String length counts UTF-16 code units, so an emoji or visible character may occupy more than one unit.",
      "related": [
        "immutable",
        "unicode",
        "data-type"
      ],
      "sources": [
        {
          "title": "MDN: String",
          "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String"
        }
      ]
    },
    {
      "id": "stringify",
      "term": "Stringify",
      "aliases": [
        "JSON.stringify",
        "stringification"
      ],
      "category": "data",
      "level": "beginner",
      "tags": [
        "data"
      ],
      "definition": "Convert a value into a string representation; JSON.stringify specifically produces JSON text for supported values.",
      "analogy": "Packing data into a text-shaped suitcase, with a few items refused at check-in.",
      "example": "JSON.stringify({ name: 'Ada', count: 2 }) returns the text {\"name\":\"Ada\",\"count\":2}.",
      "caveat": "JSON.stringify can omit unsupported properties, turn some values into null, or throw for cycles and unhandled BigInt. It is not a universal deep clone.",
      "related": [
        "json",
        "serialization",
        "string"
      ],
      "sources": [
        {
          "title": "MDN: Stringify",
          "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify"
        }
      ]
    },
    {
      "id": "supervised-learning",
      "term": "Supervised learning",
      "aliases": [
        "labeled data"
      ],
      "category": "ai",
      "level": "intermediate",
      "tags": [
        "ai"
      ],
      "definition": "Learning from examples that include the desired target output.",
      "analogy": "Practice questions with answer keys, but considerably more spreadsheets.",
      "example": "Training on emails labeled spam or not spam is supervised learning.",
      "caveat": "Labels can be noisy, biased, or inconsistent.",
      "related": [
        "machine-learning",
        "training"
      ],
      "sources": [
        {
          "title": "Google ML Glossary",
          "url": "https://developers.google.com/machine-learning/glossary"
        }
      ]
    },
    {
      "id": "syntactic-sugar",
      "term": "Syntactic sugar",
      "aliases": [
        "syntactical sugar"
      ],
      "category": "programming",
      "level": "intermediate",
      "tags": [
        "programming",
        "javascript"
      ],
      "definition": "Convenient syntax that expresses an existing operation more clearly or briefly without adding fundamentally new capability.",
      "analogy": "A prettier spoon for the same soup; dinner still has to be cooked.",
      "example": "In a typical class, JavaScript method syntax is shorter than assigning equivalent functions individually.",
      "caveat": "Shorter syntax can have subtle semantics. For example, classes and arrow functions are not interchangeable with every older function pattern.",
      "related": [
        "es6",
        "javascript",
        "ternary-operator"
      ],
      "sources": [
        {
          "title": "MDN: JavaScript language overview",
          "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Language_overview"
        }
      ]
    },
    {
      "id": "tcp",
      "term": "TCP",
      "aliases": [
        "transmission control protocol"
      ],
      "category": "networking",
      "level": "intermediate",
      "tags": [
        "networking"
      ],
      "definition": "A transport protocol that provides an ordered, reliable byte stream between endpoints.",
      "analogy": "A careful courier who tracks delivery and puts the pages back in order.",
      "example": "Many web connections use TCP underneath higher-level protocols.",
      "caveat": "Reliable delivery does not mean instant delivery or application-level success.",
      "related": [
        "udp",
        "http"
      ],
      "sources": [
        {
          "title": "MDN Glossary",
          "url": "https://developer.mozilla.org/en-US/docs/Glossary"
        }
      ]
    },
    {
      "id": "ternary-operator",
      "term": "Ternary operator",
      "aliases": [
        "conditional operator",
        "conditional expression"
      ],
      "category": "programming",
      "level": "beginner",
      "tags": [
        "programming",
        "javascript"
      ],
      "definition": "The JavaScript conditional operator that chooses between two expressions based on a condition, using condition ? a : b.",
      "analogy": "A tiny fork in the road with exactly two signposts and no room for a committee.",
      "example": "const label = isLoggedIn ? 'Sign out' : 'Sign in'; chooses a label.",
      "caveat": "It is an expression that returns a value. Deeply nested ternaries often cost more readability than they save in lines.",
      "related": [
        "conditional",
        "javascript",
        "syntactic-sugar"
      ],
      "sources": [
        {
          "title": "MDN: Ternary operator",
          "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Conditional_operator"
        }
      ]
    },
    {
      "id": "test-double",
      "term": "Test double",
      "aliases": [
        "test doubles"
      ],
      "category": "tools",
      "level": "intermediate",
      "tags": [
        "tools"
      ],
      "definition": "A substitute for a real collaborator used during testing, including dummies, stubs, spies, mocks, and fakes.",
      "analogy": "A stunt double for your database who does not demand a production password.",
      "example": "A fake in-memory repository replaces a database while testing application logic.",
      "caveat": "Different doubles serve different goals. Passing with a substitute does not prove compatibility with the real dependency.",
      "related": [
        "mock",
        "unit-test",
        "integration-test"
      ],
      "sources": [
        {
          "title": "Test double — reference and documentation",
          "url": "https://martinfowler.com/bliki/TestDouble.html"
        }
      ]
    },
    {
      "id": "test-suite",
      "term": "Test suite",
      "aliases": [
        "test suites"
      ],
      "category": "tools",
      "level": "beginner",
      "tags": [
        "tools"
      ],
      "definition": "A collection of tests organized to run together for a project, feature, or purpose.",
      "analogy": "A choir of assertions; one off-key result can stop the performance.",
      "example": "A search test suite covers normalization, matching, empty input, and filter combinations.",
      "caveat": "A green suite only covers the behavior it actually checks. Test counts alone do not establish confidence or meaningful coverage.",
      "related": [
        "unit-test",
        "integration-test",
        "assertion"
      ],
      "sources": [
        {
          "title": "Test suite — reference and documentation",
          "url": "https://jestjs.io/docs/api#describename-fn"
        }
      ]
    },
    {
      "id": "thread",
      "term": "Thread",
      "aliases": [],
      "category": "computer-basics",
      "level": "intermediate",
      "tags": [
        "computer-basics"
      ],
      "definition": "An execution path within a process that usually shares that process's memory.",
      "analogy": "Several cooks in one kitchen, all reaching for the same salt.",
      "example": "A browser can use different threads for different tasks.",
      "caveat": "Sharing memory makes coordination necessary.",
      "related": [
        "process",
        "concurrency"
      ],
      "sources": [
        {
          "title": "MDN Glossary",
          "url": "https://developer.mozilla.org/en-US/docs/Glossary"
        }
      ]
    },
    {
      "id": "tls",
      "term": "TLS",
      "aliases": [
        "transport layer security"
      ],
      "category": "security",
      "level": "intermediate",
      "tags": [
        "security"
      ],
      "definition": "A protocol for protecting communication with encryption, integrity checks, and peer authentication.",
      "analogy": "A private conversation with tamper checks and an ID check at the start.",
      "example": "HTTPS uses TLS to protect traffic between browser and server.",
      "caveat": "Trust and security depend on correct certificates, configuration, and endpoints.",
      "related": [
        "https",
        "encryption"
      ],
      "sources": [
        {
          "title": "OWASP Cheat Sheet Series",
          "url": "https://cheatsheetseries.owasp.org/"
        }
      ]
    },
    {
      "id": "token",
      "term": "Token",
      "aliases": [
        "AI token",
        "tokenization"
      ],
      "category": "ai",
      "level": "beginner",
      "tags": [
        "ai"
      ],
      "definition": "A unit of input or output processed by a model, often part of a word.",
      "analogy": "Text cut into bite-sized pieces; the slices are not always whole words.",
      "example": "The word 'unbelievable' may be split into several tokens.",
      "caveat": "Token boundaries and counts depend on the tokenizer.",
      "related": [
        "llm",
        "context-window"
      ],
      "sources": [
        {
          "title": "Google ML Glossary",
          "url": "https://developers.google.com/machine-learning/glossary"
        }
      ]
    },
    {
      "id": "training",
      "term": "Training",
      "aliases": [
        "model training"
      ],
      "category": "ai",
      "level": "beginner",
      "tags": [
        "ai"
      ],
      "definition": "The process of adjusting a model using data and an objective.",
      "analogy": "Practice time, where the model's knobs get tweaked after each mistake.",
      "example": "Training adjusts parameters to reduce prediction error on training examples.",
      "caveat": "Good training results do not guarantee good results on unseen data.",
      "related": [
        "inference",
        "overfitting"
      ],
      "sources": [
        {
          "title": "Google ML Glossary",
          "url": "https://developers.google.com/machine-learning/glossary"
        }
      ]
    },
    {
      "id": "transaction",
      "term": "Transaction",
      "aliases": [
        "database transaction"
      ],
      "category": "data",
      "level": "intermediate",
      "tags": [
        "data"
      ],
      "definition": "A group of database operations treated as a single unit of work.",
      "analogy": "A 'do the whole thing or put it back' agreement for your data.",
      "example": "A transfer can debit one account and credit another in a transaction.",
      "caveat": "Isolation and durability guarantees depend on the system and settings.",
      "related": [
        "acid",
        "database"
      ],
      "sources": [
        {
          "title": "PostgreSQL documentation",
          "url": "https://www.postgresql.org/docs/current/"
        },
        {
          "title": "Google ML Glossary",
          "url": "https://developers.google.com/machine-learning/glossary"
        }
      ]
    },
    {
      "id": "transformer",
      "term": "Transformer",
      "aliases": [
        "transformer architecture"
      ],
      "category": "ai",
      "level": "advanced",
      "tags": [
        "ai"
      ],
      "definition": "A neural-network architecture that uses attention to combine information from different positions.",
      "analogy": "A reading group where each word can check which other words matter.",
      "example": "Many language models are based on transformer architectures.",
      "caveat": "Transformers are used beyond text, including vision and audio.",
      "related": [
        "attention",
        "neural-network"
      ],
      "sources": [
        {
          "title": "Attention Is All You Need",
          "url": "https://arxiv.org/abs/1706.03762"
        }
      ]
    },
    {
      "id": "transpiler",
      "term": "Transpiler",
      "aliases": [
        "source-to-source compiler",
        "transpilation"
      ],
      "category": "tools",
      "level": "intermediate",
      "tags": [
        "tools"
      ],
      "definition": "A compiler that translates source code into another source-language form, often at a similar abstraction level.",
      "analogy": "Rewriting a recipe for a different kitchen without turning it into machine-code soup.",
      "example": "A TypeScript compiler removes type syntax and emits JavaScript for execution.",
      "caveat": "The compiler/transpiler boundary is informal. Transforming syntax does not automatically supply missing runtime features.",
      "related": [
        "babel",
        "compiler",
        "javascript"
      ],
      "sources": [
        {
          "title": "MDN: Transpiler",
          "url": "https://developer.mozilla.org/en-US/docs/Glossary/Compile"
        },
        {
          "title": "Babel: JavaScript source transformations",
          "url": "https://babeljs.io/docs/"
        }
      ]
    },
    {
      "id": "type-system",
      "term": "Type system",
      "aliases": [
        "static typing",
        "dynamic typing"
      ],
      "category": "programming",
      "level": "intermediate",
      "tags": [
        "programming"
      ],
      "definition": "Rules a language uses to classify values and check how they are used.",
      "analogy": "The bouncer checking whether values belong in the operations they enter.",
      "example": "A static type checker can reject adding a string where a number is required.",
      "caveat": "Static types do not prove every aspect of a program is correct.",
      "related": [
        "data-type",
        "compiler"
      ],
      "sources": [
        {
          "title": "Python language tutorial",
          "url": "https://docs.python.org/3/tutorial/"
        },
        {
          "title": "MDN Glossary",
          "url": "https://developer.mozilla.org/en-US/docs/Glossary"
        }
      ]
    },
    {
      "id": "udp",
      "term": "UDP",
      "aliases": [
        "user datagram protocol"
      ],
      "category": "networking",
      "level": "intermediate",
      "tags": [
        "networking"
      ],
      "definition": "A transport protocol that sends individual messages without built-in delivery or ordering guarantees.",
      "analogy": "Postcards: quick to send, but you manage missing or scrambled mail yourself.",
      "example": "Real-time applications may use UDP-based protocols.",
      "caveat": "Applications can add reliability; UDP itself does not provide it.",
      "related": [
        "tcp",
        "packet"
      ],
      "sources": [
        {
          "title": "MDN Glossary",
          "url": "https://developer.mozilla.org/en-US/docs/Glossary"
        }
      ]
    },
    {
      "id": "ui-component",
      "term": "UI component",
      "aliases": [
        "user interface component"
      ],
      "category": "web",
      "level": "beginner",
      "tags": [
        "web",
        "react"
      ],
      "definition": "A reusable piece of a user interface with a defined purpose, such as a button, date picker, or navigation menu.",
      "analogy": "A LEGO brick with a job description and hopefully no surprise sharp edges.",
      "example": "The same SearchBox component can appear on a dictionary homepage and a documentation page.",
      "caveat": "A UI component need not use React. Keep its inputs, behavior, and accessibility clear instead of splitting everything into tiny pieces.",
      "related": [
        "react-component",
        "ui",
        "accessibility"
      ],
      "sources": [
        {
          "title": "UI component — reference and documentation",
          "url": "https://developer.mozilla.org/en-US/docs/Learn_web_development/Core/Frameworks_libraries/Introduction"
        }
      ]
    },
    {
      "id": "syntax-error-unexpected-token",
      "term": "Uncaught SyntaxError: Unexpected token <",
      "aliases": [
        "Unexpected token <",
        "Unexpected token '<'",
        "SyntaxError"
      ],
      "category": "programming",
      "level": "beginner",
      "tags": [
        "programming",
        "javascript"
      ],
      "definition": "A parsing error that occurs when JavaScript code contains a less-than token where the parser cannot accept it.",
      "analogy": "You ordered JavaScript, but the waiter may have brought an HTML menu.",
      "example": "A script URL returns an HTML fallback page starting with <!doctype html>, so the browser cannot parse it as JavaScript.",
      "caveat": "Other causes include untransformed JSX. Inspect the response and build setup; a similar JSON parsing error can also mean an endpoint returned HTML.",
      "related": [
        "jsx",
        "babel",
        "content-type",
        "browser-console"
      ],
      "sources": [
        {
          "title": "MDN: SyntaxError — unexpected token",
          "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/Unexpected_token"
        }
      ]
    },
    {
      "id": "unicode",
      "term": "Unicode",
      "aliases": [],
      "category": "computer-basics",
      "level": "intermediate",
      "tags": [
        "computer-basics"
      ],
      "definition": "A standard that assigns identifiers to characters from many writing systems.",
      "analogy": "A huge guest list where letters, emojis, and symbols all get a number.",
      "example": "Unicode includes Latin letters, Persian letters, and emoji.",
      "caveat": "Unicode character identifiers and byte encodings are different things.",
      "related": [
        "encoding",
        "byte"
      ],
      "sources": [
        {
          "title": "Unicode Standard",
          "url": "https://www.unicode.org/standard/standard.html"
        }
      ]
    },
    {
      "id": "unit-test",
      "term": "Unit test",
      "aliases": [
        "unit testing"
      ],
      "category": "tools",
      "level": "beginner",
      "tags": [
        "tools"
      ],
      "definition": "A test focused on a small unit of behavior, with a narrow scope and controlled dependencies.",
      "analogy": "Checking one toaster before blaming the entire breakfast buffet.",
      "example": "Test that normalizeTerm('  React  ') returns 'react' without starting a browser or server.",
      "caveat": "A unit is a useful testing boundary, not necessarily one method. Test behavior rather than private implementation details.",
      "related": [
        "integration-test",
        "test-double",
        "assertion"
      ],
      "sources": [
        {
          "title": "Unit test — reference and documentation",
          "url": "https://martinfowler.com/bliki/UnitTest.html"
        }
      ]
    },
    {
      "id": "unsupervised-learning",
      "term": "Unsupervised learning",
      "aliases": [
        "clustering"
      ],
      "category": "ai",
      "level": "intermediate",
      "tags": [
        "ai"
      ],
      "definition": "Finding patterns in data without supplied target answers for each example.",
      "analogy": "Sorting a drawer of mysterious cables without anyone telling you their names.",
      "example": "A clustering method can group similar customer behaviors.",
      "caveat": "A discovered pattern is not automatically useful or meaningful.",
      "related": [
        "machine-learning",
        "embedding"
      ],
      "sources": [
        {
          "title": "Google ML Glossary",
          "url": "https://developers.google.com/machine-learning/glossary"
        }
      ]
    },
    {
      "id": "usability",
      "term": "Usability",
      "aliases": [
        "user testing"
      ],
      "category": "product",
      "level": "beginner",
      "tags": [
        "product"
      ],
      "definition": "How effectively, efficiently, and satisfactorily people can achieve goals with a system.",
      "analogy": "Whether people can use your toaster without enrolling in toaster school.",
      "example": "Watching users find a term can reveal confusing filter labels.",
      "caveat": "Usability depends on the users, task, and context.",
      "related": [
        "ux",
        "prototype"
      ],
      "sources": [
        {
          "title": "GOV.UK: Usability testing",
          "url": "https://www.gov.uk/service-manual/user-research/using-moderated-usability-testing"
        }
      ]
    },
    {
      "id": "ux",
      "term": "User experience",
      "aliases": [
        "UX"
      ],
      "category": "product",
      "level": "beginner",
      "tags": [
        "product"
      ],
      "definition": "A person's overall experience of using a product or service.",
      "analogy": "How the whole dinner feels, not just how shiny the menu looks.",
      "example": "Clear checkout steps and useful error messages improve the experience.",
      "caveat": "UX includes more than visual interface design.",
      "related": [
        "ui",
        "usability"
      ],
      "sources": [
        {
          "title": "GOV.UK: User research",
          "url": "https://www.gov.uk/service-manual/user-research"
        }
      ]
    },
    {
      "id": "ui",
      "term": "User interface",
      "aliases": [
        "UI"
      ],
      "category": "product",
      "level": "beginner",
      "tags": [
        "product"
      ],
      "definition": "The controls and presentation through which people interact with a system.",
      "analogy": "The dashboard, buttons, and labels on your product's spaceship.",
      "example": "A search field and category buttons are interface elements.",
      "caveat": "A polished interface alone does not guarantee a good experience.",
      "related": [
        "ux",
        "accessibility"
      ],
      "sources": [
        {
          "title": "GOV.UK Design System",
          "url": "https://design-system.service.gov.uk/"
        }
      ]
    },
    {
      "id": "uuid",
      "term": "UUID",
      "aliases": [
        "Universally Unique Identifier",
        "GUID"
      ],
      "category": "programming",
      "level": "intermediate",
      "tags": [
        "programming",
        "javascript"
      ],
      "definition": "A standardized 128-bit identifier format designed to make independently generated identifiers very unlikely to collide.",
      "analogy": "A name tag long enough that two strangers probably will not accidentally become the same database row.",
      "example": "crypto.randomUUID() generates a random version 4 UUID in supported secure browser contexts.",
      "caveat": "Uniqueness is probabilistic for random UUIDs. A UUID is not automatically a secret, an authorization check, or a chronologically sortable value.",
      "related": [
        "primary-key",
        "object",
        "database"
      ],
      "sources": [
        {
          "title": "RFC 9562: Universally Unique IDentifiers",
          "url": "https://www.rfc-editor.org/rfc/rfc9562"
        }
      ]
    },
    {
      "id": "var",
      "term": "var",
      "aliases": [
        "var declaration"
      ],
      "category": "programming",
      "level": "beginner",
      "tags": [
        "programming",
        "javascript"
      ],
      "definition": "A JavaScript declaration that creates a function-scoped or global-scoped variable rather than a block-scoped one.",
      "analogy": "The office worker who ignores cubicle walls and treats the whole floor as one desk.",
      "example": "function demo() { if (true) { var x = 1; } return x; } returns 1.",
      "caveat": "var bindings are initialized to undefined before their declaration executes, and redeclaration is allowed. Prefer let or const when block scope is intended.",
      "related": [
        "let",
        "const",
        "hoisting"
      ],
      "sources": [
        {
          "title": "MDN: var",
          "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/var"
        }
      ]
    },
    {
      "id": "variable",
      "term": "Variable",
      "aliases": [],
      "category": "programming",
      "level": "beginner",
      "tags": [
        "programming"
      ],
      "definition": "A name associated with a value that a program can use.",
      "analogy": "A labeled box; whether you can swap its contents depends on the language.",
      "example": "The variable score might hold the number 42.",
      "caveat": "Some bindings are mutable; others cannot be reassigned.",
      "related": [
        "data-type",
        "function"
      ],
      "sources": [
        {
          "title": "Python language tutorial",
          "url": "https://docs.python.org/3/tutorial/"
        },
        {
          "title": "MDN Glossary",
          "url": "https://developer.mozilla.org/en-US/docs/Glossary"
        }
      ]
    },
    {
      "id": "variable-assignment",
      "term": "Variable assignment",
      "aliases": [
        "assignment"
      ],
      "category": "programming",
      "level": "beginner",
      "tags": [
        "programming",
        "javascript"
      ],
      "definition": "Storing a value in an existing variable binding, usually with the = operator.",
      "analogy": "Replacing the contents of a labeled box without renaming the box.",
      "example": "let score = 0; score = 10; assigns a new value to score.",
      "caveat": "A const binding cannot be reassigned, although an object it references can still be mutated.",
      "related": [
        "variable-initialization",
        "const",
        "mutation"
      ],
      "sources": [
        {
          "title": "MDN: Variable assignment",
          "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Assignment"
        }
      ]
    },
    {
      "id": "variable-declaration",
      "term": "Variable declaration",
      "aliases": [],
      "category": "programming",
      "level": "beginner",
      "tags": [
        "programming",
        "javascript"
      ],
      "definition": "Introducing a variable name into a scope using a declaration such as let, const, or var.",
      "analogy": "Putting a name tag on a locker before deciding what goes inside.",
      "example": "let score; declares a block-scoped variable named score.",
      "caveat": "A let declaration without an initializer initializes the binding to undefined when execution reaches it; const requires an initializer.",
      "related": [
        "variable-initialization",
        "let",
        "const",
        "var"
      ],
      "sources": [
        {
          "title": "MDN: Variable declaration",
          "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/let"
        }
      ]
    },
    {
      "id": "variable-definition",
      "term": "Variable definition",
      "aliases": [],
      "category": "programming",
      "level": "beginner",
      "tags": [
        "programming",
        "javascript"
      ],
      "definition": "Establishing what a variable is and, depending on the language, providing its storage or value.",
      "analogy": "Giving a mystery box an identity before asking it to hold your snacks.",
      "example": "In JavaScript, let score = 0; declares score and gives it its first value.",
      "caveat": "Definition and declaration are language-dependent terms; JavaScript has no separate variable-definition keyword.",
      "related": [
        "variable-declaration",
        "variable-initialization",
        "variable-assignment"
      ],
      "sources": [
        {
          "title": "MDN: Variable definition",
          "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Grammar_and_types"
        }
      ]
    },
    {
      "id": "variable-initialization",
      "term": "Variable initialization",
      "aliases": [
        "initialization",
        "variable initialisation"
      ],
      "category": "programming",
      "level": "beginner",
      "tags": [
        "programming",
        "javascript"
      ],
      "definition": "Giving a variable its initial value when its binding becomes initialized.",
      "analogy": "The first snack in the locker, before the snack rotation begins.",
      "example": "let score = 0; initializes score with 0; let name; initializes name with undefined.",
      "caveat": "Initialization is the first value, not every later assignment. A lexical binding cannot be read before initialization.",
      "related": [
        "variable-declaration",
        "variable-assignment",
        "hoisting"
      ],
      "sources": [
        {
          "title": "MDN: Variable initialization",
          "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Grammar_and_types"
        }
      ]
    },
    {
      "id": "vector-database",
      "term": "Vector database",
      "aliases": [
        "vector store",
        "similarity search"
      ],
      "category": "data",
      "level": "intermediate",
      "tags": [
        "data"
      ],
      "definition": "A system designed to store vectors and find items with similar vector representations.",
      "analogy": "A librarian finding books by their 'vibe coordinates', with actual math behind the vibe.",
      "example": "A search tool can retrieve text whose embeddings are close to a query embedding.",
      "caveat": "Similarity depends on the representation and is not proof of truth.",
      "related": [
        "embedding",
        "rag"
      ],
      "sources": [
        {
          "title": "pgvector documentation",
          "url": "https://github.com/pgvector/pgvector"
        }
      ]
    },
    {
      "id": "virtual-dom",
      "term": "Virtual DOM",
      "aliases": [
        "VDOM"
      ],
      "category": "web",
      "level": "intermediate",
      "tags": [
        "web",
        "react"
      ],
      "definition": "An in-memory description of a UI used to help a renderer determine which changes to apply to the actual interface.",
      "analogy": "A stage plan the crew compares before moving real furniture around.",
      "example": "After state changes, React computes the next UI description and commits necessary changes to the browser DOM.",
      "caveat": "It is not a second browser DOM or a guaranteed performance win. React rendering, reconciliation, and DOM commits are distinct steps.",
      "related": [
        "virtual-dom-tree",
        "dom",
        "react"
      ],
      "sources": [
        {
          "title": "Virtual DOM — reference and documentation",
          "url": "https://legacy.reactjs.org/docs/faq-internals.html"
        }
      ]
    },
    {
      "id": "virtual-dom-tree",
      "term": "Virtual DOM tree",
      "aliases": [
        "virtual tree",
        "virtual element tree"
      ],
      "category": "web",
      "level": "intermediate",
      "tags": [
        "web",
        "react"
      ],
      "definition": "The hierarchical arrangement of a UI's in-memory element descriptions, reflecting how elements are nested.",
      "analogy": "The seating chart for an imaginary theatre, before anyone moves the real chairs.",
      "example": "A description of a section can contain a heading and a list whose children describe individual terms.",
      "caveat": "The element tree, component tree, actual DOM tree, and React's internal Fiber structures are related but not identical.",
      "related": [
        "virtual-dom",
        "react-component",
        "dom"
      ],
      "sources": [
        {
          "title": "Virtual DOM tree — reference and documentation",
          "url": "https://react.dev/learn/understanding-your-ui-as-a-tree"
        }
      ]
    },
    {
      "id": "virtual-machine",
      "term": "Virtual machine",
      "aliases": [
        "VM",
        "virtualization"
      ],
      "category": "devops",
      "level": "intermediate",
      "tags": [
        "devops"
      ],
      "definition": "A software-defined computer that runs its own operating system using virtualized hardware.",
      "analogy": "A computer apartment inside a larger computer building.",
      "example": "A VM can run a separate Linux operating system on a host.",
      "caveat": "VMs generally have more overhead than shared-kernel containers.",
      "related": [
        "container",
        "operating-system"
      ],
      "sources": [
        {
          "title": "Docker documentation",
          "url": "https://docs.docker.com/get-started/"
        },
        {
          "title": "AWS cloud concepts",
          "url": "https://aws.amazon.com/what-is/cloud-computing/"
        }
      ]
    },
    {
      "id": "vulnerability",
      "term": "Vulnerability",
      "aliases": [
        "security vulnerability"
      ],
      "category": "security",
      "level": "beginner",
      "tags": [
        "security"
      ],
      "definition": "A weakness that can be exploited to compromise a system or its users.",
      "analogy": "A crack in the fence that matters when someone can crawl through it.",
      "example": "An unpatched library may contain an exploitable flaw.",
      "caveat": "Actual risk depends on exposure, exploitability, and impact.",
      "related": [
        "dependency",
        "least-privilege"
      ],
      "sources": [
        {
          "title": "OWASP Cheat Sheet Series",
          "url": "https://cheatsheetseries.owasp.org/"
        }
      ]
    },
    {
      "id": "web-application",
      "term": "Web application",
      "aliases": [
        "webapp",
        "web app",
        "web application"
      ],
      "category": "web",
      "level": "beginner",
      "tags": [
        "web"
      ],
      "definition": "Software accessed through web technologies that lets users perform tasks and interact with data.",
      "analogy": "A website that gives you a desk and tools instead of only a brochure.",
      "example": "An online issue tracker lets users create tickets, assign owners, and update status in a browser.",
      "caveat": "A web application need not be a single-page application. It can use server-rendered pages, client rendering, or a combination.",
      "related": [
        "website",
        "single-page-application",
        "frontend",
        "backend"
      ],
      "sources": [
        {
          "title": "MDN: Express/Node introduction and web applications",
          "url": "https://developer.mozilla.org/en-US/docs/Learn_web_development/Extensions/Server-side/Express_Nodejs/Introduction"
        }
      ]
    },
    {
      "id": "scraping",
      "term": "Web scraping",
      "aliases": [
        "scraping",
        "web scraper",
        "web data extraction"
      ],
      "category": "web",
      "level": "intermediate",
      "tags": [
        "web"
      ],
      "definition": "Programmatically extracting information from web pages, often by fetching and parsing their content.",
      "analogy": "A very literal assistant copying the menu into a spreadsheet, including any typos the chef insists are intentional.",
      "example": "A script downloads a permitted documentation page and extracts its headings using an HTML parser.",
      "caveat": "Page structures change, and client-rendered content may need different handling. Respect access rules, usage terms, and rate limits; an available API is often more stable.",
      "related": [
        "html",
        "dom",
        "api"
      ],
      "sources": [
        {
          "title": "Web scraping — reference and documentation",
          "url": "https://docs.scrapy.org/en/latest/intro/overview.html"
        }
      ]
    },
    {
      "id": "webhook",
      "term": "Webhook",
      "aliases": [
        "HTTP callback",
        "webhooks"
      ],
      "category": "networking",
      "level": "intermediate",
      "tags": [
        "networking"
      ],
      "definition": "An event notification sent by a service to a configured HTTP endpoint when something happens.",
      "analogy": "The delivery service ringing your doorbell instead of making you check the porch every ten seconds.",
      "example": "A payment provider posts a payment.succeeded event to a merchant's webhook endpoint.",
      "caveat": "Verify signatures and handle retries, duplicates, and out-of-order events. Do not assume one delivery or trust an event just because it arrived.",
      "related": [
        "endpoint",
        "post-request",
        "long-polling"
      ],
      "sources": [
        {
          "title": "Webhook — reference and documentation",
          "url": "https://docs.github.com/en/webhooks/about-webhooks"
        }
      ]
    },
    {
      "id": "website",
      "term": "Website",
      "aliases": [
        "web site"
      ],
      "category": "web",
      "level": "beginner",
      "tags": [
        "web"
      ],
      "definition": "A collection of related web pages and resources presented under a shared site identity.",
      "analogy": "A digital address with rooms for articles, products, and the inevitable contact form.",
      "example": "A documentation website includes a homepage, guides, reference pages, and a search tool.",
      "caveat": "A website can include interactive applications. Website and web application are overlapping descriptions, not strict technical opposites.",
      "related": [
        "web-application",
        "html",
        "static-site"
      ],
      "sources": [
        {
          "title": "MDN: Browsing the web",
          "url": "https://developer.mozilla.org/en-US/docs/Learn_web_development/Getting_started/Environment_setup/Browsing_the_web"
        }
      ]
    },
    {
      "id": "websocket",
      "term": "WebSocket",
      "aliases": [
        "web sockets"
      ],
      "category": "web",
      "level": "intermediate",
      "tags": [
        "web"
      ],
      "definition": "A protocol for ongoing, two-way communication over a connection.",
      "analogy": "A phone call between browser and server, instead of mailing a new letter every time.",
      "example": "A chat app can receive new messages over a WebSocket.",
      "caveat": "Connections can drop and may need reconnection logic.",
      "related": [
        "http",
        "tcp"
      ],
      "sources": [
        {
          "title": "MDN: WebSocket",
          "url": "https://developer.mozilla.org/en-US/docs/Web/API/WebSocket"
        }
      ]
    },
    {
      "id": "windows",
      "term": "Windows",
      "aliases": [
        "Microsoft Windows"
      ],
      "category": "computer-basics",
      "level": "beginner",
      "tags": [
        "computer-basics"
      ],
      "definition": "Microsoft's operating-system family that manages hardware, applications, files, and the user environment.",
      "analogy": "The computer's building manager, with a Start menu instead of a clipboard.",
      "example": "A developer runs VS Code, PowerShell, and a local web server on Windows.",
      "caveat": "Windows differs from Unix-like environments in areas such as paths and shell commands. WSL supplies a Linux environment alongside it.",
      "related": [
        "operating-system",
        "macos",
        "linux"
      ],
      "sources": [
        {
          "title": "Windows — reference and documentation",
          "url": "https://learn.microsoft.com/en-us/windows/"
        }
      ]
    },
    {
      "id": "wrapper",
      "term": "Wrapper",
      "aliases": [
        "wrapper function",
        "wrapper component"
      ],
      "category": "programming",
      "level": "intermediate",
      "tags": [
        "programming",
        "javascript"
      ],
      "definition": "Code that surrounds another function, component, or API to adapt it or add behavior.",
      "analogy": "A lunchbox around an existing sandwich, adding convenience without inventing new bread.",
      "example": "An API wrapper calls fetch, checks response.ok, and parses JSON before returning data.",
      "caveat": "A wrapper need not create a DOM element. Extra layers can obscure errors or leak underlying details if their contract is unclear.",
      "related": [
        "interface",
        "api",
        "react-component"
      ],
      "sources": [
        {
          "title": "MDN: Wrapper",
          "url": "https://developer.mozilla.org/en-US/docs/Glossary/Wrapper"
        }
      ]
    },
    {
      "id": "xml",
      "term": "XML",
      "aliases": [
        "Extensible Markup Language"
      ],
      "category": "web",
      "level": "beginner",
      "tags": [
        "web"
      ],
      "definition": "A text markup language for representing structured information with nested elements, attributes, and application-defined tags.",
      "analogy": "A labeling machine so enthusiastic it labels both the opening and closing of every box.",
      "example": "<term id=\"api\"><name>API</name></term> represents a small structured record.",
      "caveat": "XML is not HTML and does not prescribe one set of application tags. Parsing external XML requires attention to parser configuration and untrusted input.",
      "related": [
        "html",
        "json",
        "dom"
      ],
      "sources": [
        {
          "title": "XML — reference and documentation",
          "url": "https://www.w3.org/XML/"
        }
      ]
    },
    {
      "id": "xmlhttprequest",
      "term": "XMLHttpRequest",
      "aliases": [
        "XHR"
      ],
      "category": "web",
      "level": "intermediate",
      "tags": [
        "web"
      ],
      "definition": "A browser API for making HTTP requests and receiving responses through events, widely used before Fetch became common.",
      "analogy": "The veteran courier with a longer form to fill out and a perfectly usable delivery van.",
      "example": "const xhr = new XMLHttpRequest(); xhr.open('GET', '/api/terms'); xhr.onload = () => console.log(xhr.responseText); xhr.send();",
      "caveat": "It can receive JSON and other formats, not only XML. Asynchronous XHR is still supported; avoid synchronous requests on the main thread.",
      "related": [
        "fetch-api",
        "ajax",
        "http"
      ],
      "sources": [
        {
          "title": "MDN: XMLHttpRequest",
          "url": "https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest"
        }
      ]
    }
  ]
}