[
  {
    "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"
      }
    ]
  }
]