Glossary

478 terms from every course, by track. Each one is also a flashcard.

Web Development · 180 terms

:focus-visible: A pseudo-class that matches a focused element only when the browser judges a focus indicator useful, such as keyboard focus or any text field, but not a mouse click on a button.; Modern CSS Mastery · Taught in “Focus Styles That Work”
:focus-visible: A CSS pseudo-class that matches when the browser decides focus should be shown, such as during keyboard navigation. Styling it with a strong outline gives keyboard users a clear indicator without showing rings on mouse clicks.; Web Accessibility in Practice · Taught in “Keyboard Access and Visible Focus”
:has(): A relational pseudo-class that matches an element when the relative selector inside it finds a match, letting a parent or earlier sibling be styled by its descendants or later siblings.; Modern CSS Mastery · Taught in “Native Nesting and :has()”
:is(): A pseudo-class that matches any selector in its list and takes the specificity of its most specific argument; it uses a forgiving selector list, so one invalid argument doesn’t drop the rule.; Modern CSS Mastery · Taught in “Specificity, :is() and :where()”
:where(): A pseudo-class that matches like :is() but always contributes zero specificity, which makes it ideal for resets and base styles that components should override easily.; Modern CSS Mastery · Taught in “Specificity, :is() and :where()”
@property: An at-rule that registers a custom property with a syntax, an inheritance flag and an initial value, so the browser can validate it and interpolate it in transitions and animations.; Modern CSS Mastery · Taught in “Custom Properties and @property”
@starting-style: An at-rule that defines the styles an element transitions from when it is first rendered or goes from display: none to shown, enabling entry transitions in CSS alone.; Modern CSS Mastery · Taught in “Transitions, Keyframes and Reduced Motion”
Accessibility tree: A simplified tree the browser builds from the DOM and CSS, where each node has a role, a name and any states or value. Assistive technologies read this tree, not the pixels on screen.; Web Accessibility in Practice · Taught in “How Assistive Technology Reads Your Page”
Accessible name: The text that identifies an element to assistive technology. Browsers compute it from aria-labelledby, then aria-label, then native labelling such as label or alt, then content, then title.; Web Accessibility in Practice · Taught in “Accessible Names and Descriptions”
Accessible name: The name assistive technology announces for an element, computed from aria-labelledby, aria-label, an associated label or its text. Role queries match on it.; Testing JavaScript Apps · Taught in “Querying the DOM Like a User”
Alt text: The text alternative of an image, given in its alt attribute. It should convey the image’s purpose in context: what it shows if informative, or what it does if it is a link or button.; Web Accessibility in Practice · Taught in “Images, Alt Text and Data Tables”
ARIA: Accessible Rich Internet Applications, a set of attributes for roles, states and properties that change what the accessibility tree exposes. It never adds behaviour, so native HTML is preferred whenever it exists.; Web Accessibility in Practice · Taught in “ARIA: Roles, States and Live Regions”
ARIA Authoring Practices Guide (APG): A W3C guide describing common widget patterns such as tabs, disclosure, dialog and menu button, with the roles, states and keyboard interaction users expect from each.; Web Accessibility in Practice · Taught in “Widget Patterns: Disclosure, Tabs and Menu Button”
Arrange, Act, Assert: A three-part shape for tests: build the inputs, perform the one action under test, then state what should now be true. It makes tests easy to scan.; Testing JavaScript Apps · Taught in “Anatomy of a Test and Reading Failures”
Array: An ordered list of values, written in square brackets and indexed from 0. Arrays have methods such as map, filter, find and reduce for transforming and searching their items.; JavaScript Fundamentals · Taught in “Arrays and Their Everyday Methods”
Arrow function: A shorter function syntax, such as (cents) => cents / 100. With a single expression after the arrow, that expression is returned automatically; with curly braces, an explicit return is needed.; JavaScript Fundamentals · Taught in “Functions: Declarations, Arrows and Defaults”
as const: A const assertion that infers the narrowest type for a value: literals stay literal, arrays become readonly tuples and properties become readonly.; Advanced TypeScript Patterns · Taught in “Literal Types, as const and satisfies”
Assertion: A check inside a test that throws when a value is not what you expected, such as expect(total).toBe(1000). A test fails when an assertion throws.; Testing JavaScript Apps · Taught in “Anatomy of a Test and Reading Failures”
Assertion function: A function whose return type is asserts value is T. It throws when the check fails and narrows the value for the rest of the scope when it returns.; Advanced TypeScript Patterns · Taught in “Parsing Untrusted Data at the Boundary”
Assignability: Whether a value of one type can be used where another type is expected. It works like the subset relation: a narrower set of values fits into a wider one.; Advanced TypeScript Patterns · Taught in “Structural Typing and Assignability”
Assistive technology (AT): Software or hardware people use to operate a computer in a way that suits them, such as screen readers, screen magnifiers, switch devices and voice control. It reads the page through the accessibility tree.; Web Accessibility in Practice · Taught in “How Assistive Technology Reads Your Page”
async/await: Syntax for working with promises. Inside an async function, await pauses that function until a promise settles and gives its value, so asynchronous code reads top to bottom and errors are caught with try/catch.; JavaScript Fundamentals · Taught in “Async JavaScript: Promises, async/await and fetch”
auto-fit: A keyword for repeat() that creates as many tracks as fit and collapses the empty ones, so a few items stretch to fill the row; auto-fill keeps empty tracks instead.; Modern CSS Mastery · Taught in “Grid: Areas, auto-fit and minmax()”
Autocomplete token: A value of the HTML autocomplete attribute, such as name, email or cc-number, that declares a field’s purpose so browsers can fill it in. It satisfies WCAG 1.3.5 Identify Input Purpose.; Web Accessibility in Practice · Taught in “Accessible Forms”
Automatic minimum size: The default min-width: auto of flex and grid items, which stops them shrinking below their content. Setting min-width: 0 lets long text truncate instead of overflowing.; Modern CSS Mastery · Taught in “Flexbox in Depth”
axe-core: An open-source accessibility rules engine by Deque that runs in the page and reports violations with WCAG references. It powers axe DevTools, Lighthouse’s accessibility audit and test integrations such as @axe-core/playwright.; Web Accessibility in Practice · Taught in “Automated Testing with axe”
Boundary value analysis: Testing inputs just below, on and just above each limit in a rule, such as 0 and 0.01 or two and three decimals, because bugs cluster at those edges.; Testing JavaScript Apps · Taught in “Edge Cases and Table-Driven Tests”
Branded type: A primitive intersected with a type-only property, such as number & { readonly [brand]: 'OrderId' }, so values with the same runtime type stop being interchangeable.; Advanced TypeScript Patterns · Taught in “Branded Types and Exhaustive Checks”
Breakpoint: A marker in DevTools, or a debugger statement in code, that pauses execution on a line so you can inspect every variable, the call stack, and step through the code one line at a time.; JavaScript Fundamentals · Taught in “Errors and Debugging with DevTools”
Browse mode: The NVDA mode in which a virtual cursor reads the page and single letters jump between elements, such as H for headings. Focus mode instead sends keys to the focused control for typing.; Web Accessibility in Practice · Taught in “Testing with a Keyboard and Screen Readers”
Callback: A function passed to another function, which decides when to call it. Array methods like map, event listeners and timers all take callbacks.; JavaScript Fundamentals · Taught in “Functions: Declarations, Arrows and Defaults”
Cascade: The algorithm the browser uses to choose one value when several declarations target the same property on the same element: origin and importance, inline styles, layers, specificity, then order of appearance.; Modern CSS Mastery · Taught in “How the Browser Picks a Winner”
Cascade layer: A named group of rules created with @layer. Later-declared layers beat earlier ones before specificity is compared, and unlayered styles beat all layers for normal declarations.; Modern CSS Mastery · Taught in “Cascade Layers with @layer”
children: The prop that holds whatever is nested between a component’s opening and closing tags. Rendering {children} lets a component wrap content it knows nothing about.; React Fundamentals · Taught in “Composition Patterns”
clamp(): A math function that returns a preferred value held between a minimum and a maximum, written clamp(MIN, PREFERRED, MAX). It equals max(MIN, min(PREFERRED, MAX)).; Modern CSS Mastery · Taught in “Intrinsic Sizing: min(), max(), clamp()”
Class: A blueprint for objects that bundles data with the methods that act on it. new runs the constructor and returns an instance; private fields marked with # are hidden from outside code.; JavaScript Fundamentals · Taught in “Classes”
Cleanup function: A function returned from an Effect that undoes it, such as removing a listener or clearing a timer. React runs it before the Effect runs again and on unmount.; React Fundamentals · Taught in “useEffect Essentials”
Closure: A function together with the variables from the scope where it was created. The function keeps access to them even after the outer function has returned, which gives it private, remembered state.; JavaScript Fundamentals · Taught in “Scope and Closures”
Code coverage: The share of statements, branches, functions and lines that ran during the tests. It shows untested code but not whether the executed code was actually checked.; Testing JavaScript Apps · Taught in “Coverage and Its Limits”
Component: A JavaScript function whose name starts with a capital letter and that returns JSX. You use it like a tag, and React calls it to find out what to show.; React Fundamentals · Taught in “Your First Component”
Compositing: The final rendering stage, where painted layers are assembled on the GPU. Changes to transform and opacity can often be handled here alone, skipping layout and paint.; Modern CSS Mastery · Taught in “Rendering Performance”
Conditional rendering: Choosing what a component outputs based on data, using an early return, the ternary operator, or && in JSX. Returning null renders nothing.; React Fundamentals · Taught in “Conditional Rendering”
Conditional type: A type of the form T extends U ? X : Y that chooses between two types depending on whether T is assignable to U.; Advanced TypeScript Patterns · Taught in “Conditional Types, Distribution and infer”
Conformance level (A, AA, AAA): The level at which a success criterion sits and at which conformance is claimed. Level AA, which includes all A criteria, is the target required by most laws and policies.; Web Accessibility in Practice · Taught in “WCAG 2.2, POUR and the Law”
const type parameter: A type parameter declared with const (TypeScript 5.0+), which infers arguments as if the caller had written as const, keeping literals and readonly tuples.; Advanced TypeScript Patterns · Taught in “How Inference Works, and const Type Parameters”
Container query: An @container rule that applies styles based on the size or style of an ancestor container rather than the viewport, so a component adapts to the slot it sits in.; Modern CSS Mastery · Taught in “Container Queries”
Container query units: Units such as cqi and cqb that equal 1% of the nearest size container’s inline or block size, falling back to small viewport units when no container exists.; Modern CSS Mastery · Taught in “Container Queries”
Contrast ratio: WCAG’s measure of the difference in relative luminance between two colours, from 1:1 to 21:1. Level AA needs 4.5:1 for normal text and 3:1 for large text and essential non-text elements.; Web Accessibility in Practice · Taught in “Color and Contrast”
Control-flow analysis: How TypeScript tracks the type of a variable through branches, returns and assignments, so the same name can have a narrower type after a check than before it.; Advanced TypeScript Patterns · Taught in “Narrowing and Control-Flow Analysis”
Controlled input: A form field whose value comes from React state and whose onChange handler updates that state, making state the single source of truth for what the field shows.; React Fundamentals · Taught in “Forms & Controlled Inputs”
CSS nesting: Native syntax for writing rules inside other rules, where & stands for the parent selector. It works on selectors, not text, so it can’t build BEM class names the way Sass does.; Modern CSS Mastery · Taught in “Native Nesting and :has()”
Custom property: A property whose name starts with two dashes, such as --track-color, read with var(). It inherits by default and is substituted where it is used, at computed-value time.; Modern CSS Mastery · Taught in “Custom Properties and @property”
Declaration merging: The rule that several declarations with the same name, such as two interfaces, combine into one. It is how you extend lib types and library interfaces.; Advanced TypeScript Patterns · Taught in “Declaration Files and Module Augmentation”
Decorative image: An image that adds no information in its context, such as a divider or an ambient photo. It gets an empty alt attribute (alt=“”) so screen readers skip it instead of reading its file name.; Web Accessibility in Practice · Taught in “Images, Alt Text and Data Tables”
Dependency array: The second argument to useEffect listing every value the Effect reads. React re-runs the Effect only when one of those values has changed since the last render.; React Fundamentals · Taught in “useEffect Essentials”
Derived value: Data calculated during render from props or state, such as a count or a filtered list. It is never stored in state, so it can never drift out of sync with its source.; React Fundamentals · Taught in “Thinking in Components”
Destructuring: Syntax that unpacks properties or array items into variables in one step, such as const { label, amount } = expense. It supports default values and works in function parameters.; JavaScript Fundamentals · Taught in “Objects, Destructuring and Spread”
Discriminated union: A union of object types that share a property with a different literal value in each member, such as status. Checking that property narrows the whole object to one member.; Advanced TypeScript Patterns · Taught in “Discriminated Unions for Domain States”
Distributive conditional type: A conditional type whose checked type is a naked type parameter. Given a union, it runs once per member and joins the results; wrapping both sides in brackets turns this off.; Advanced TypeScript Patterns · Taught in “Conditional Types, Distribution and infer”
DOM: The Document Object Model: the browser’s live tree of objects representing the page. Changing these objects with JavaScript, for example an element’s textContent, updates what the user sees immediately.; JavaScript Fundamentals · Taught in “The DOM: Select, Create, Update”
Effect: Code passed to useEffect that runs after React updates the screen, used to synchronize with something outside React such as the document title, storage, timers or subscriptions.; React Fundamentals · Taught in “useEffect Essentials”
End-to-end test: A test that drives the real application in a real browser, through the UI, API and data layer. The most realistic and the most expensive kind of test.; Testing JavaScript Apps · Taught in “Locators, Web-First Assertions and Auto-Waiting”
Equivalent mutant: A mutant whose change does not alter any behaviour a caller could observe, so no reasonable test can kill it. It should be ignored, not chased.; Testing JavaScript Apps · Taught in “Mutation Testing”
European Accessibility Act (EAA): EU Directive 2019/882, applying since 28 June 2025, which requires covered products and services such as e-commerce, banking and ticketing to be accessible. Its reference standard, EN 301 549, maps to WCAG 2.1 AA, with a WCAG 2.2 update published in 2026.; Web Accessibility in Practice · Taught in “WCAG 2.2, POUR and the Law”
Event bubbling: The way an event travels from the element where it happened up through its ancestors, triggering their handlers too. e.stopPropagation() stops it.; React Fundamentals · Taught in “Handling Events”
Event delegation: Handling events for many child elements with one listener on their container. Events bubble up to the container, and event.target.closest() finds which child was involved, including children added later.; JavaScript Fundamentals · Taught in “Events and Event Delegation”
Event handler: A function passed to a prop such as onClick or onSubmit that React calls when the event happens. Handlers are where side effects caused by user actions belong.; React Fundamentals · Taught in “Handling Events”
Event loop: The mechanism that lets single-threaded JavaScript wait without freezing. When the call stack is empty, it runs all queued promise callbacks (microtasks), then the next task such as a timer or click.; JavaScript Fundamentals · Taught in “Async JavaScript: Promises, async/await and fetch”
Excess property check: A check that flags unknown properties in a fresh object literal written directly where a type is expected. It catches typos, but values passed through a variable skip it.; Advanced TypeScript Patterns · Taught in “Structural Typing and Assignability”
Exhaustiveness check: A compile-time guarantee that every member of a union is handled, usually by passing the leftover value to a parameter of type never in a default branch.; Advanced TypeScript Patterns · Taught in “Branded Types and Exhaustive Checks”
Fake timers: A test clock that replaces setTimeout, setInterval and Date, so tests can skip ahead with calls like vi.advanceTimersByTime(2000) instead of waiting in real time.; Testing JavaScript Apps · Taught in “Test Doubles and When Mocking Hurts”
findBy query: An asynchronous Testing Library query that retries until a matching element appears, resolving with it or rejecting after a timeout (one second by default).; Testing JavaScript Apps · Taught in “Testing Async UI”
fit-content: An intrinsic sizing keyword that sizes an element to its max-content width, capped at the available space, so a block can hug its content without overflowing.; Modern CSS Mastery · Taught in “Intrinsic Sizing: min(), max(), clamp()”
Fixture: In Playwright, a value a test requests by name, like page or a custom group, with setup before use() and teardown after it, created only for tests that need it.; Testing JavaScript Apps · Taught in “Fixtures and Test Isolation”
Flaky test: A test that sometimes passes and sometimes fails without any code change, usually because of timing, shared data or uncontrolled time. It teaches teams to ignore failures.; Testing JavaScript Apps · Taught in “Debugging and Fixing Flaky Tests”
flex-basis: The starting size of a flex item along the main axis, before leftover space is shared by flex-grow or a shortfall is taken back by flex-shrink.; Modern CSS Mastery · Taught in “Flexbox in Depth”
Floating-point number: A number stored in binary with limited precision, as all JavaScript numbers are. Many decimals cannot be stored exactly, so 0.1 + 0.2 gives 0.30000000000000004; store money as whole cents instead.; JavaScript Fundamentals · Taught in “Numbers, Operators and Comparisons”
Fluid type: Font sizes that change continuously with available width, usually written as clamp() with a rem minimum, a linear preferred value combining rem and vw or cqi, and a rem maximum.; Modern CSS Mastery · Taught in “Fluid Type and Space”
Focus order: The sequence in which Tab moves through focusable elements. It follows the DOM order, so markup should match the visual reading order, and positive tabindex values should never be used.; Web Accessibility in Practice · Taught in “Keyboard Access and Visible Focus”
Form action: A React 19 feature where a function passed to a form’s action prop receives the submitted FormData. React prevents the page reload and resets uncontrolled fields afterwards.; React Fundamentals · Taught in “Forms & Controlled Inputs”
Fragment: A wrapper written as <>…</> or that groups several elements without adding a DOM node, so a component can return siblings as one root.; React Fundamentals · Taught in “Your First Component”
Function: A named, reusable block of code. It declares parameters, receives arguments when called, runs its body and hands a result back with return; without return the result is undefined.; JavaScript Fundamentals · Taught in “Functions: Declarations, Arrows and Defaults”
Generic constraint: An extends clause on a type parameter that limits which types it accepts, such as T extends { id: number }, which also makes those properties usable inside the function.; Advanced TypeScript Patterns · Taught in “Generics as Relationships”
grid-template-areas: A grid property that names regions of the grid with strings, one per row, so you can place items by name and rearrange the layout by redrawing the strings.; Modern CSS Mastery · Taught in “Grid: Areas, auto-fit and minmax()”
Hook: A function whose name starts with “use”, such as useState or useEffect, that lets a component use React features. Hooks must be called at the top level of a component.; React Fundamentals · Taught in “useState Fundamentals”
Immutable update: Changing state by creating new arrays or objects (with spread, map or filter) instead of modifying the existing ones, so React can detect the change.; React Fundamentals · Taught in “useState Fundamentals”
Implementation detail: How code produces its result (private helpers, internal state, call order), as opposed to the behaviour callers observe. Tests coupled to it break on harmless refactors.; Testing JavaScript Apps · Taught in “Test Behaviour, Not Implementation”
Indexed access type: A type such as Order['status'] or T[number] that looks up the type of a property, or of an array’s elements, using bracket syntax.; Advanced TypeScript Patterns · Taught in “keyof, typeof and Indexed Access Types”
inert: An HTML attribute that removes an element and its descendants from focus, pointer interaction and the accessibility tree. It suits closed drawers, off-screen panels and content behind a custom overlay.; Web Accessibility in Practice · Taught in “Managing Focus: Dialogs and Single-Page Apps”
infer: A keyword used inside the extends clause of a conditional type to capture part of a matched type, as in ReturnType, which captures a function’s return type.; Advanced TypeScript Patterns · Taught in “Conditional Types, Distribution and infer”
Inference site: A position in a parameter type where a type parameter appears. At a call, TypeScript collects a candidate from each site to decide what the type parameter is.; Advanced TypeScript Patterns · Taught in “How Inference Works, and const Type Parameters”
Inheritance: When no declaration targets an inherited property such as color or font-family, the element takes its parent’s computed value; non-inherited properties fall back to their initial value instead.; Modern CSS Mastery · Taught in “How the Browser Picks a Winner”
Integration test: A test that checks several units working together, such as a form component using the real parsing code with a faked network. It catches wiring bugs unit tests miss.; Testing JavaScript Apps · Taught in “What Tests Buy You”
Invalid at computed-value time: What happens when a var() substitution produces a value the property can’t use: the property behaves as unset, taking its inherited or initial value rather than an earlier declaration.; Modern CSS Mastery · Taught in “Custom Properties and @property”
Invariant: A property that holds for every valid input, such as “the shares add up to the total”. Asserting an invariant across several inputs catches whole families of bugs.; Testing JavaScript Apps · Taught in “Test Behaviour, Not Implementation”
JSON: JavaScript Object Notation, a text format for data. JSON.stringify turns values into JSON text and JSON.parse turns it back; it holds strings, numbers, booleans, null, arrays and plain objects.; JavaScript Fundamentals · Taught in “Saving Data: JSON and localStorage”
JSX: A syntax extension that lets you write HTML-like markup in JavaScript. A compiler turns each tag into a function call that creates a React element.; React Fundamentals · Taught in “JSX Rules of the Road”
Key: A special prop on list items that tells React which item is which between renders. It must be unique among siblings and stable, usually an id from the data.; React Fundamentals · Taught in “Rendering Lists with Keys”
Key remapping: An as clause in a mapped type that renames each key, often with a template literal. Mapping a key to never removes it, which is how Omit works.; Advanced TypeScript Patterns · Taught in “Mapped Types and Key Remapping”
Label in Name: WCAG 2.5.3: when a control has visible text, its accessible name must contain that text, ideally at the start, so voice control users can activate it by saying what they see.; Web Accessibility in Practice · Taught in “Accessible Names and Descriptions”
Landmark: A region of a page with a role that screen reader users can list and jump to, such as banner, navigation, main and contentinfo. HTML elements like header, nav, main and footer create them.; Web Accessibility in Practice · Taught in “Landmarks and Headings”
let and const: The two modern ways to declare a variable. A const name can never be pointed at another value; a let name can be reassigned. Default to const and use let only when needed.; JavaScript Fundamentals · Taught in “Values, Types and Variables”
Lifting state up: Moving state from a component into the closest common parent of every component that needs it, then passing the value down and change handlers down as props.; React Fundamentals · Taught in “Lifting State Up”
light-dark(): A color function that returns its first value when the element’s used color scheme is light and its second when it’s dark. It needs color-scheme to allow dark.; Modern CSS Mastery · Taught in “Light and Dark with light-dark()”
Live region: An element whose content changes are announced by screen readers without moving focus. role=“status” is polite and role=“alert” is assertive; the region must exist before its text changes.; Web Accessibility in Practice · Taught in “ARIA: Roles, States and Live Regions”
Locator: In Playwright, a lazy, strict description of how to find an element, such as page.getByRole('button', { name: 'Save' }). It is resolved again on every action.; Testing JavaScript Apps · Taught in “Locators, Web-First Assertions and Auto-Waiting”
Logical properties: Properties named by text flow instead of physical sides, such as margin-inline-start and inline-size, so layouts mirror correctly in right-to-left languages like Arabic.; Modern CSS Mastery · Taught in “Logical Properties and RTL”
Logical properties: CSS properties such as margin-inline-start and padding-inline-end that follow the writing direction instead of physical sides, so layouts mirror automatically for right-to-left languages like Arabic.; Web Accessibility in Practice · Taught in “Plain Language, Language and Direction”
Mapped type: A type that loops over a union of keys and builds one property per key, as in { [K in keyof T]?: T[K] }, the definition of Partial.; Advanced TypeScript Patterns · Taught in “Mapped Types and Key Remapping”
Modal dialog: A window that blocks the rest of the page until closed. The native dialog element opened with showModal() moves focus inside, makes the page inert, closes on Escape and restores focus afterwards.; Web Accessibility in Practice · Taught in “Managing Focus: Dialogs and Single-Page Apps”
Module: A JavaScript file with its own scope that shares values with other files only through export and import. In the browser, the entry module is loaded with script type=“module”.; JavaScript Fundamentals · Taught in “Modules: import and export”
Module augmentation: Adding to the types inside a module with declare module 'name' { … } from a file that is itself a module, for example to extend a library’s interface.; Advanced TypeScript Patterns · Taught in “Declaration Files and Module Augmentation”
MSW (Mock Service Worker): A library that intercepts network requests in Node and the browser and answers them with handlers you define, so your real fetch and data code still run in tests.; Testing JavaScript Apps · Taught in “Testing React Components and the Network”
Mutation testing: Grading a test suite by making small deliberate bugs (mutants) in the code and rerunning the tests; killed mutants were caught, survived mutants reveal weak tests.; Testing JavaScript Apps · Taught in “Mutation Testing”
Narrowing: Refining a wide type to a more specific one with a runtime check such as typeof, ===, in, instanceof or a type predicate.; Advanced TypeScript Patterns · Taught in “Narrowing and Control-Flow Analysis”
NoInfer: A built-in type (TypeScript 5.4+) that marks a position as check-only, so it is validated against a type parameter but never contributes an inference candidate.; Advanced TypeScript Patterns · Taught in “Controlling Inference: NoInfer, Defaults and Overloads”
Nullish coalescing (??): An operator that returns its right side only when the left side is null or undefined. Unlike ||, it keeps real values such as 0 and the empty string.; JavaScript Fundamentals · Taught in “Missing Values, Map and Set”
Object: A value that groups named properties, such as { label: “Coffee”, amount: 450 }. Properties are read with dot notation, or with brackets when the name is in a variable.; JavaScript Fundamentals · Taught in “Objects, Destructuring and Spread”
oklch(): A color function using perceptual lightness, chroma and hue, so colors with equal lightness look equally light. It can also express colors beyond the sRGB gamut.; Modern CSS Mastery · Taught in “Modern Color: oklch() and color-mix()”
Optional chaining (?.): An operator that reads a property only if the value on its left is not null or undefined, returning undefined instead of throwing a TypeError, as in expense.receipt?.url.; JavaScript Fundamentals · Taught in “Missing Values, Map and Set”
POUR: The four principles at the top of WCAG: content must be Perceivable, Operable, Understandable and Robust. Every guideline and success criterion sits under one of them.; Web Accessibility in Practice · Taught in “WCAG 2.2, POUR and the Law”
prefers-reduced-motion: A CSS media feature that reflects the user’s operating system setting for less motion. Use it to replace large animations with fades or remove them for people with vestibular disorders.; Web Accessibility in Practice · Taught in “Zoom, Reflow, Target Size and Motion”
Preview deployment: A deployment of a non-production branch or pull request at its own unique URL, so changes can be checked before they are merged and reach the production site.; React Fundamentals · Taught in “Deploying to Vercel”
Project references: A tsconfig feature that splits a codebase into separately built projects (composite: true, built with tsc -b), so unchanged parts are not re-checked.; Advanced TypeScript Patterns · Taught in “Migrating JavaScript to TypeScript, and Keeping It Fast”
Promise: An object standing for a result that is not ready yet. It starts pending and settles once, either fulfilled with a value or rejected with an error; then and catch attach what happens next.; JavaScript Fundamentals · Taught in “Async JavaScript: Promises, async/await and fetch”
Prop drilling: Passing a prop through several components that don’t use it, only to reach a deeply nested one. Composition with elements or context can often remove it.; React Fundamentals · Taught in “Composition Patterns”
Props: The inputs a parent passes to a component as attributes, received as one object. Props are read-only: a component never changes them, it receives new ones when the parent re-renders.; React Fundamentals · Taught in “Props In Depth”
Query priority: Testing Library’s recommended order for finding elements: by role, label, placeholder, text or display value first; then alt text and title; test ids last.; Testing JavaScript Apps · Taught in “Querying the DOM Like a User”
React element: A plain JavaScript object, created by JSX, that describes what should appear on screen: a type such as “h2” or a component, plus its props. React turns elements into DOM.; React Fundamentals · Taught in “JSX Rules of the Road”
reduce: An array method that walks the items while carrying an accumulator, returning the final accumulator. Used for totals and grouping; always pass an initial value as its second argument.; JavaScript Fundamentals · Taught in “Summing and Sorting: reduce and sort”
Reference: What a variable holds for an object or array: a pointer to it, not a copy. Assigning or passing it shares the same object, so a change through one name is visible through all.; JavaScript Fundamentals · Taught in “Objects, Destructuring and Spread”
Reflow: WCAG 1.4.10: content must fit a 320 CSS pixel wide viewport without horizontal scrolling, the width of a 1280px window at 400% zoom. Data tables and maps are exempt.; Web Accessibility in Practice · Taught in “Zoom, Reflow, Target Size and Motion”
Relative color syntax: A way to derive a color from another by unpacking its channels with from, as in oklch(from var(--brand) calc(l - 0.1) c h), and changing only what you need.; Modern CSS Mastery · Taught in “Modern Color: oklch() and color-mix()”
Required status check: A CI job that must pass before a pull request can merge into a protected branch, turning the test pipeline from a suggestion into a gate.; Testing JavaScript Apps · Taught in “Testing in CI and Choosing What Not to Test”
Result type: A discriminated union such as { ok: true; value: T } | { ok: false; error: E } that returns expected failures as values, so callers must handle them.; Advanced TypeScript Patterns · Taught in “Result Types for Expected Failures”
Roving tabindex: A technique for composite widgets where only the active item has tabindex=“0” and the rest have “-1”. The widget is one Tab stop, and arrow keys move focus and the 0 between items.; Web Accessibility in Practice · Taught in “Widget Patterns: Disclosure, Tabs and Menu Button”
satisfies: An operator that checks a value against a type without replacing the value’s inferred type, so you get validation and keep precise keys and literals.; Advanced TypeScript Patterns · Taught in “Literal Types, as const and satisfies”
Scope: The region of code where a name can be used. let and const are scoped to the nearest block, and name lookups go outward from inner scopes to outer ones, never inward.; JavaScript Fundamentals · Taught in “Scope and Closures”
Screen reader: Assistive software that turns the accessibility tree into speech or braille and lets users navigate by headings, landmarks, links and form fields. Common ones are JAWS, NVDA, VoiceOver and TalkBack.; Web Accessibility in Practice · Taught in “How Assistive Technology Reads Your Page”
Scroll-driven animation: A CSS animation whose progress follows a scroll timeline, set with animation-timeline: scroll() or view(), instead of elapsed time.; Modern CSS Mastery · Taught in “Scroll-Driven Animations”
Situational disability: A temporary limitation caused by circumstances rather than a person’s body, such as glare on a screen, a noisy room or holding a baby in one arm. Designs that serve permanent disabilities usually help here too.; Web Accessibility in Practice · Taught in “Who You Are Building For”
Skip link: A link at the very start of a page, usually hidden until focused, that jumps to the main content. It lets keyboard users bypass repeated navigation, meeting WCAG 2.4.1 Bypass Blocks.; Web Accessibility in Practice · Taught in “Keyboard Access and Visible Focus”
Slot prop: A prop that accepts JSX, such as actions={}, so the caller decides what appears and the component decides where it goes.; React Fundamentals · Taught in “Composition Patterns”
Smart constructor: A function that validates a raw value and returns it as a branded type. It is the only place a cast to the brand should appear.; Advanced TypeScript Patterns · Taught in “Branded Types and Exhaustive Checks”
Specificity: A selector’s weight, counted as three separate numbers (IDs; classes, attributes and pseudo-classes; types and pseudo-elements) and compared column by column, never added together.; Modern CSS Mastery · Taught in “Specificity, :is() and :where()”
Spread syntax: Three dots that copy the items of an array or the properties of an object into a new one, as in […list, item] or { …expense, amount: 500 }. The copy is shallow.; JavaScript Fundamentals · Taught in “Objects, Destructuring and Spread”
Spy: A function or method wrapper that records how it was called. vi.spyOn(object, method) watches a real method and can also override it until restored.; Testing JavaScript Apps · Taught in “Test Doubles and When Mocking Hurts”
Stack trace: The list of function calls, with file names and line numbers, that led to an error, most recent first. It shows where the error happened and how the program got there.; JavaScript Fundamentals · Taught in “Errors and Debugging with DevTools”
State: Data a component remembers between renders, declared with useState. Calling its setter stores a new value and makes React render the component again.; React Fundamentals · Taught in “useState Fundamentals”
State snapshot: The fixed set of state values a single render sees. Setting state does not change the current variables; it schedules a new render with new values.; React Fundamentals · Taught in “useState Fundamentals”
Strict equality (===): A comparison that is true only when both values have the same type and the same value. Unlike loose equality (==), it never converts types first, so “5” === 5 is false.; JavaScript Fundamentals · Taught in “Numbers, Operators and Comparisons”
StrictMode: A React wrapper component that adds development-only checks, such as rendering components twice and running Effects twice, to expose impure code and missing cleanups. It has no effect in production.; React Fundamentals · Taught in “Setting Up with Vite”
Structural typing: TypeScript’s rule that a value is compatible with a type when it has the required shape, whatever the type is called. Two differently named types with the same properties are interchangeable.; Advanced TypeScript Patterns · Taught in “Structural Typing and Assignability”
Stub: A stand-in collaborator that returns canned answers so a test can control a dependency, for example an API object whose post method always resolves with an id.; Testing JavaScript Apps · Taught in “Testing Errors and Async Code”
Subgrid: The subgrid value for grid-template-rows or grid-template-columns, which makes a nested grid use the tracks it spans in its parent, so content aligns across sibling components.; Modern CSS Mastery · Taught in “Subgrid for Aligned Cards”
Table-driven test: A test written once and run for each row of a table of inputs and expected outputs. In Vitest, test.each creates one named test per row.; Testing JavaScript Apps · Taught in “Edge Cases and Table-Driven Tests”
Template literal: A string written with backticks that can insert the value of any expression with ${ } and can span several lines, such as Total: ${total}.; JavaScript Fundamentals · Taught in “Strings and Template Literals”
Template literal type: A string type built with backtick syntax from other types, such as `order.${OrderStatus}`. Unions inside it expand into every combination.; Advanced TypeScript Patterns · Taught in “Template Literal Types”
Test double: Any stand-in for a real collaborator in a test: stubs return canned answers, spies record calls, mocks are spies you assert on, and fakes are simpler working versions.; Testing JavaScript Apps · Taught in “Test Doubles and When Mocking Hurts”
Test-driven development: Writing one failing test, making it pass with the simplest code, then refactoring with the tests green, in short repeated cycles known as red, green, refactor.; Testing JavaScript Apps · Taught in “Test-Driven Development as a Tool”
Testing trophy: A model of a test suite with four layers: static analysis, unit, integration and end-to-end tests. It is widest at integration, which usually gives the most confidence for its cost.; Testing JavaScript Apps · Taught in “What Tests Buy You”
Trace: A Playwright recording of a test run with every action, DOM snapshots before and after it, console output and network calls, opened in the trace viewer.; Testing JavaScript Apps · Taught in “Debugging and Fixing Flaky Tests”
Truthy and falsy: How JavaScript treats any value used as a condition. Eight values are falsy: false, 0, -0, 0n, the empty string, null, undefined and NaN. Every other value is truthy.; JavaScript Fundamentals · Taught in “Making Decisions: if, else and Truthiness”
Type: The kind of a value, which decides what you can do with it. JavaScript’s basic types include number, string, boolean, undefined and null; the typeof operator reports a value’s type.; JavaScript Fundamentals · Taught in “Values, Types and Variables”
Type parameter: A placeholder type in a generic function or type, such as T, that links inputs to outputs. It should appear at least twice to add real type safety.; Advanced TypeScript Patterns · Taught in “Generics as Relationships”
Type predicate: A function return type of the form value is T. When the function returns true, the argument is narrowed to T at the call site; the body itself is not verified.; Advanced TypeScript Patterns · Taught in “Parsing Untrusted Data at the Boundary”
Unit test: A test that checks one function or module in isolation, usually in milliseconds. Ideal for pure logic with many edge cases, such as rounding money.; Testing JavaScript Apps · Taught in “What Tests Buy You”
Unmount: When React removes a component from the tree, destroying its DOM and its state. A conditionally rendered component unmounts when its condition becomes false.; React Fundamentals · Taught in “Conditional Rendering”
Updater function: A function passed to a state setter, as in setCount(© => c + 1). React calls it with the latest pending value, so several updates in a row add up correctly.; React Fundamentals · Taught in “useState Fundamentals”
useActionState: A React 19 Hook that wraps an action function and returns the latest result it produced, a dispatch function to pass to a form, and an isPending flag.; React Fundamentals · Taught in “Forms & Controlled Inputs”
user-event: A Testing Library package that simulates whole user interactions, including pointer, focus and keyboard events, instead of dispatching single events like fireEvent does.; Testing JavaScript Apps · Taught in “Simulating User Interaction”
using declaration: A declaration that calls the value’s [Symbol.dispose]() method when its block exits, by return or by throw, disposing several resources in reverse order.; Advanced TypeScript Patterns · Taught in “using Declarations and Standard Decorators”
Utility class: A small CSS class that does one thing, such as p-4 for padding or text-slate-600 for color. Tailwind CSS generates the utilities your files use.; React Fundamentals · Taught in “Styling with Tailwind”
Variable: A name that points at a value so a program can use it later. In JavaScript the value has a type, not the variable, so one variable can point at different types over time.; JavaScript Fundamentals · Taught in “Values, Types and Variables”
View transition: An animation created by document.startViewTransition(): the browser snapshots the old and new states of a DOM update and animates between them through pseudo-elements you can style.; Modern CSS Mastery · Taught in “View Transitions”
Visually hidden text: Text clipped to a 1px box with CSS so it stays in the accessibility tree but takes no visible space. Unlike display: none, screen readers still announce it.; Web Accessibility in Practice · Taught in “How Assistive Technology Reads Your Page”
Vite: A build tool and dev server for front-end projects. It serves your source files with instant updates during development and bundles them into optimized static files in dist/ for production.; React Fundamentals · Taught in “Setting Up with Vite”
Watch mode: Vitest’s default locally: after a run it waits, and when you save a file it reruns only the tests affected by that change, using Vite’s module graph.; Testing JavaScript Apps · Taught in “Setting Up Vitest”
WCAG: The Web Content Accessibility Guidelines, the W3C standard for accessible web content. Version 2.2, published in October 2023, organises testable success criteria under four principles and three conformance levels.; Web Accessibility in Practice · Taught in “WCAG 2.2, POUR and the Law”
Web-first assertion: A Playwright assertion on a locator, such as toHaveText, that re-checks the page until it passes or times out, instead of reading a value once.; Testing JavaScript Apps · Taught in “Locators, Web-First Assertions and Auto-Waiting”

Data Science · 60 terms

Ambiguous date: A date string such as 05/08/2025 that is valid under both day-first and month-first readings; only outside information can decide which one is correct.; Python for Data Analysis · Taught in “Parsing Messy Dates”
Anti-join: A filter that keeps rows with no match in another table, written as NOT EXISTS or LEFT JOIN … WHERE right_key IS NULL. NOT IN fails when the subquery contains NULL.; SQL for Analysts · Taught in “Self-Joins and Anti-Joins”
Assertion: An assert condition, message statement that does nothing when the condition holds and stops the program with the message when it fails; used to state what clean data must look like.; Python for Data Analysis · Taught in “Duplicates and a Repeatable Cleaning Function”
Bare column: A selected column that is neither grouped nor aggregated. SQLite allows it and fills it from an arbitrary row of each group; PostgreSQL rejects the query.; SQL for Analysts · Taught in “GROUP BY, HAVING and the Grain of a Result”
Boolean mask: A Series of True and False values, usually from a comparison, used to select rows with df[mask]; its sum counts matches and its mean gives their share.; Python for Data Analysis · Taught in “Filtering and Sorting Rows”
CASE expression: An expression that returns the result of the first WHEN condition that is TRUE, or the ELSE value; without an ELSE, unmatched rows get NULL.; SQL for Analysts · Taught in “NULL Logic and CASE Expressions”
Chained assignment: Assigning through two selections, such as df["col"][mask] = value; it may change a temporary copy instead of the DataFrame, so use one .loc call instead.; Python for Data Analysis · Taught in “Adding and Changing Columns”
COALESCE: A function that returns its first non-NULL argument, used to give missing values a display default such as ‘none’. Replacing NULL with 0 in averages distorts results.; SQL for Analysts · Taught in “NULL Logic and CASE Expressions”
Cohort retention: The share of a group of customers who started in the same period, such as their first-order month, who are active again a given number of periods later.; SQL for Analysts · Taught in “Funnels, Cohorts and Retention”
Common table expression (CTE): A named intermediate result defined with WITH name AS (…). CTEs let a long analysis read as ordered steps, each of which can be run and checked on its own.; SQL for Analysts · Taught in “Subqueries, CTEs and Recursive CTEs”
Copy-on-Write: pandas behaviour, default from version 3.0 and optional in 2.x, in which every selection acts as a copy, so the only way to change a DataFrame is to assign to it directly.; Python for Data Analysis · Taught in “Adding and Changing Columns”
Correlation: A number from -1 to 1 measuring how strongly two numeric columns move together in a straight-line pattern; it signals association, not cause.; Python for Data Analysis · Taught in “Descriptive Statistics and Distributions”
Data-quality check: A query that returns the rows breaking a stated rule, such as orphaned references or impossible dates, so an empty result means the rule holds.; SQL for Analysts · Taught in “Data-Quality Checks”
DataFrame: The pandas table: columns that are Series sharing one row index, with methods to load, select, filter, group, join and reshape data.; Python for Data Analysis · Taught in “Series and DataFrames”
Derived table: A subquery in the FROM clause that acts like a temporary table with its own grain, often used to aggregate a detailed table before joining it.; SQL for Analysts · Taught in “Fan-Out: When Joins Double-Count”
Dictionary: A Python container of key: value pairs, such as a product’s name mapped to its price; you look values up by key with d[key] or d.get(key, default).; Python for Data Analysis · Taught in “Lists and Dictionaries”
dtype: The data type shared by every value in a pandas column, such as int64, float64, object (text), bool or datetime64; a wrong dtype is behind many data bugs.; Python for Data Analysis · Taught in “Series and DataFrames”
f-string: A string literal prefixed with f that embeds values in braces with optional formatting, such as f"{revenue:,.2f}" for 1,234.50 or f"{share:.1%}" for 12.5%.; Python for Data Analysis · Taught in “Functions, f-strings and Reading Errors”
Fan-out: The row multiplication that happens when a join follows a one-to-many relationship. Values stored on the ‘one’ side repeat once per match, so summing them inflates totals.; SQL for Analysts · Taught in “Fan-Out: When Joins Double-Count”
FILTER clause: A standard SQL addition to an aggregate, as in COUNT(*) FILTER (WHERE channel = ‘web’), that restricts that one aggregate to matching rows inside each group.; SQL for Analysts · Taught in “GROUP BY, HAVING and the Grain of a Result”
Funnel: A sequence of steps, such as session, add to cart and purchase, reported as counts and step-to-step conversion rates to show where people drop off.; SQL for Analysts · Taught in “Funnels, Cohorts and Retention”
Grain: What one row of a table or query result represents, such as one row per order or one row per country per month. Stating it before writing GROUP BY prevents most aggregation mistakes.; SQL for Analysts · Taught in “GROUP BY, HAVING and the Grain of a Result”
groupby (split-apply-combine): The pandas operation that splits rows into groups by key, applies a calculation to each group and combines the results into one table.; Python for Data Analysis · Taught in “groupby and Named Aggregation”
Half-open date range: A period filter that includes its start and excludes the start of the next period, such as order_date >= ‘2025-11-01’ AND order_date < ‘2025-12-01’, so the last day is never cut off.; SQL for Analysts · Taught in “Working with Dates in SQLite”
HAVING: The clause that filters groups after aggregation, so it can test values like COUNT(*) or SUM(revenue). Row conditions belong in WHERE, which runs before grouping.; SQL for Analysts · Taught in “GROUP BY, HAVING and the Grain of a Result”
Index alignment: pandas’ rule that operations between two Series or DataFrames match values by index label, not by position; labels present on only one side produce NaN.; Python for Data Analysis · Taught in “Series and DataFrames”
IS DISTINCT FROM: A NULL-safe comparison that treats NULL as an ordinary value, so rows with NULL are not silently dropped the way they are with the plain not-equal operator.; SQL for Analysts · Taught in “NULL Logic and CASE Expressions”
ISO-8601 date text: Dates stored as text in the form ‘YYYY-MM-DD HH:MM:SS’. Because the largest unit comes first, alphabetical order equals chronological order, so string comparison works as a date filter.; SQL for Analysts · Taught in “Working with Dates in SQLite”
Join type: The rule for unmatched keys in a merge: inner keeps keys found on both sides, left keeps every left row, right every right row, and outer keeps all keys.; Python for Data Analysis · Taught in “Joining Tables with merge”
julianday(): A SQLite function that converts a date to a fractional number of days. Subtracting two julianday values gives a duration in days; multiplying by 24 gives hours.; SQL for Analysts · Taught in “Working with Dates in SQLite”
LAG and LEAD: Window functions that return a value from the previous (LAG) or next (LEAD) row in the window order, used for period-over-period comparisons.; SQL for Analysts · Taught in “Running Totals, LAG and Moving Averages”
LEFT JOIN: A join that keeps every row of the left table and fills the right table’s columns with NULL where no match exists. Right-table filters belong in its ON clause.; SQL for Analysts · Taught in “Inner and Left Joins”
List comprehension: A one-line way to build a list, [expr for x in items if condition], that applies an expression to each item and optionally filters which items are kept.; Python for Data Analysis · Taught in “Loops, Conditions and Comprehensions”
loc and iloc: The two precise selectors in pandas: .loc[rows, columns] selects by label and includes the end of a slice, while .iloc selects by integer position and excludes it.; Python for Data Analysis · Taught in “Selecting with loc and iloc”
Long and wide data: Two shapes for the same data: long has one row per observation, wide spreads one variable across columns; pivot_table goes from long to wide and melt back.; Python for Data Analysis · Taught in “Reshaping with pivot_table and melt”
Median: The middle value of a sorted column, with half the values below it; in skewed data such as order values it describes a typical value better than the mean.; Python for Data Analysis · Taught in “Descriptive Statistics and Distributions”
merge: The pandas method that combines two tables side by side by matching key values; how sets the join type and validate checks the expected key relationship.; Python for Data Analysis · Taught in “Joining Tables with merge”
Named aggregation: A form of agg in which each keyword names an output column and its value is a (column, function) pair, such as revenue=("revenue", "sum").; Python for Data Analysis · Taught in “groupby and Named Aggregation”
NaN: Short for not a number: the classic pandas marker for a missing value in float columns; it is not equal to anything, so test for it with isna().; Python for Data Analysis · Taught in “Missing Values”
Nullable dtype: A pandas dtype such as Int64, Float64, boolean or string that stores missing values as pd.NA, so integer columns stay integers even with gaps.; Python for Data Analysis · Taught in “Missing Values”
Operator precedence (AND before OR): The rule that SQL evaluates AND before OR, so a filter mixing them groups conditions unexpectedly unless every OR group is wrapped in parentheses.; SQL for Analysts · Taught in “Filtering and Sorting with Purpose”
PARTITION BY: The part of a window definition that splits rows into groups so the window calculation, such as a ranking or running total, restarts for each group.; SQL for Analysts · Taught in “Window Functions for Ranking”
qcut: A pandas function that splits values into groups of about equal size at quantiles, such as quartiles, unlike cut, which uses boundaries you choose.; Python for Data Analysis · Taught in “Ranking and Binning”
Query plan: The database’s description of how it will execute a query, shown in SQLite with EXPLAIN QUERY PLAN. SEARCH means an index narrowed the work; SCAN means every row was read.; SQL for Analysts · Taught in “Indexes and Query Plans”
Recursive CTE: A CTE with an anchor query, UNION ALL and a step that joins back to the CTE itself, repeating until no new rows appear. Used to walk hierarchies of any depth.; SQL for Analysts · Taught in “Subqueries, CTEs and Recursive CTEs”
Regular expression: A pattern language for text in which characters like $ and . have special meanings; pass regex=False to treat them as plain characters.; Python for Data Analysis · Taught in “Turning Money Strings into Numbers”
Reproducible analysis: An analysis that anyone can rerun from the raw files, top to bottom, with no manual steps, and get the same results, using parameters, functions and assertions.; Python for Data Analysis · Taught in “Reproducible Analysis”
resample: A pandas method that groups rows with a datetime index into regular periods such as days, weeks (W), month ends (ME) or quarter ends (QE), including empty periods.; Python for Data Analysis · Taught in “Time Series: resample and the dt Accessor”
Sargable: Describes a condition the database can answer with an index, typically a bare column compared with a constant. Wrapping the column in a function usually makes it non-sargable.; SQL for Analysts · Taught in “Indexes and Query Plans”
Scalar subquery: A subquery that returns exactly one row and one column, such as an overall average, and can be used anywhere a single value is allowed.; SQL for Analysts · Taught in “Subqueries, CTEs and Recursive CTEs”
Self-join: A join of a table to itself using two aliases for two roles, such as employee and manager, to follow a link stored within the same table.; SQL for Analysts · Taught in “Self-Joins and Anti-Joins”
Semi-join: A filter that keeps rows having at least one match in another table, written with EXISTS or IN (subquery). Unlike a join, it never duplicates rows.; SQL for Analysts · Taught in “Self-Joins and Anti-Joins”
Series: A one-dimensional pandas array of values with an index of labels; a single column of a DataFrame is a Series.; Python for Data Analysis · Taught in “Series and DataFrames”
str accessor: The .str attribute of a text Series that applies string methods such as strip, title, replace, split and contains to every value at once.; Python for Data Analysis · Taught in “Cleaning Text Columns”
Three-valued logic: SQL’s logic in which a condition is TRUE, FALSE or NULL (unknown). Any comparison with NULL is unknown, and WHERE keeps only rows whose condition is TRUE.; SQL for Analysts · Taught in “NULL Logic and CASE Expressions”
Traceback: The report Python prints when an exception stops a program; read it from the bottom, where the last line names the error type and message, then up to the failing line.; Python for Data Analysis · Taught in “Functions, f-strings and Reading Errors”
Variable: A name attached to a value with =, such as unit_price = 39, so the value can be used later; the right side is computed first, then the name points at the result.; Python for Data Analysis · Taught in “Values, Types and Variables”
Window frame: The range of rows around the current row that a window aggregate sees, such as ROWS BETWEEN 6 PRECEDING AND CURRENT ROW for a 7-row moving average.; SQL for Analysts · Taught in “Running Totals, LAG and Moving Averages”
Window function: A function followed by OVER (…) that computes a value from a set of related rows while keeping every row, unlike GROUP BY, which collapses them.; SQL for Analysts · Taught in “Window Functions for Ranking”
Year-over-year growth: The change compared with the same period a year earlier, such as pct_change(4) on quarterly data; it removes seasonal patterns from the comparison.; Python for Data Analysis · Taught in “Time Series: resample and the dt Accessor”

Design · 58 terms

:focus-visible: A CSS pseudo-class that matches when the browser decides focus should be visible, typically after keyboard navigation, used to show focus rings without showing them on most mouse clicks.; Design Systems That Scale · Taught in “States and Accessibility, Built In”
8-point system: A spacing convention where sizes and spacing are multiples of 8, with 4 as a half step, so values scale cleanly across screen densities and teams choose from a short list.; UI Design with Figma · Taught in “Layout Guides and the 8-Point System”
Adoption rate: The share of UI elements in a product that are rendered by the real design system components, measured with signals only those components produce, tracked as a trend.; Design Systems That Scale · Taught in “Measuring Adoption and Saying No”
Alias (token reference): A token whose value refers to another token by its path in curly braces, such as {color.blue.600}. It must point at a token, never at a group.; Design Systems That Scale · Taught in “The DTCG Token Format”
Auto layout: A frame setting that arranges children automatically in a vertical, horizontal or grid flow, with a set gap between them and padding around them, re-flowing whenever content changes.; UI Design with Figma · Taught in “Auto Layout: Direction, Gap and Padding”
Brand tier: A small layer of tokens between primitives and semantic tokens, such as a color ramp, fonts and radii, that each brand points at its own values.; Design Systems That Scale · Taught in “Multi-Brand Theming at Scale”
Breakpoint: A width at which a layout changes its structure, such as a stats grid going from two to four columns. Good breakpoints come from where the content stops working, not from device lists.; UI Design with Figma · Taught in “Responsive Resizing Across Screen Sizes”
Changeset: A small file added to a pull request that states the version bump a change needs and a consumer-facing summary, later combined into the release version and changelog.; Design Systems That Scale · Taught in “Semver and Changelogs for a Design System”
Codemod: A script that rewrites source code automatically, such as renaming a deprecated prop across a repository, so migrations become reviews instead of manual work.; Design Systems That Scale · Taught in “Deprecation Paths”
Component property: A switch on a component that instances can change without new variants: boolean for visibility, text for editable strings, instance swap for nested components, and slots for flexible content areas.; UI Design with Figma · Taught in “Variants and Component Properties”
Component token: A token scoped to one component, such as --nw-button-bg, that points at a semantic token and lets that component be adjusted without affecting others.; Design Systems That Scale · Taught in “Three Tiers: Primitive, Semantic, Component”
Compound component: A component made of cooperating pieces, such as Tabs.List and Tabs.Trigger, that the consumer arranges freely while the pieces share state through context.; Design Systems That Scale · Taught in “Composition Over Configuration”
Constraints: Rules on a child of a regular frame that decide how it moves or stretches when the frame is resized, such as Left and right, Bottom, Center or Scale.; UI Design with Figma · Taught in “Frames, Groups, Layers and Constraints”
Contrast ratio: A measure of the luminance difference between two colors, from 1:1 to 21:1. WCAG AA requires 4.5:1 for normal text and 3:1 for large text and essential non-text elements.; UI Design with Figma · Taught in “Type Scale and Color with Contrast”
Deprecation: Marking an API, token or component as scheduled for removal while it still works, naming its replacement and removal version so teams can migrate before it disappears.; Design Systems That Scale · Taught in “Deprecation Paths”
Design critique: A structured session where people evaluate a design against its stated goals, offering observations, effects and questions rather than personal preferences or approval.; UI Design with Figma · Taught in “Design Critique and Your Case Study”
Design principle: A short statement that picks a side in a real trade-off, such as accessible before beautiful, so it can settle design arguments without a long meeting.; Design Systems That Scale · Taught in “Principles and Team Models”
Design system: The shared tokens, components, patterns, documentation and the people and processes that keep them current, so many teams can build consistent interfaces without re-deciding everything.; Design Systems That Scale · Taught in “A Product, Not a Project”
Design token: A named design decision, such as a color, spacing value or font size, stored once and referenced by name from design tools and code instead of repeating raw values.; Design Systems That Scale · Taught in “Three Tiers: Primitive, Semantic, Component”
DTCG format: The JSON format for design tokens defined by the W3C Design Tokens Community Group, whose first stable version, 2025.10, covers tokens, types, groups, aliases and color.; Design Systems That Scale · Taught in “The DTCG Token Format”
Figma variable mode: One of several sets of values for the variables in a Figma collection, such as Light and Dark, applied to frames the way theme selectors apply to page sections.; Design Systems That Scale · Taught in “Figma Variables and Libraries, in Sync with Code”
Frame: A Figma container with its own size, fill, clipping, constraints and optional auto layout or layout guides. Screens, rows, buttons and cards are all built from frames.; UI Design with Figma · Taught in “Frames, Groups, Layers and Constraints”
Gap and padding: In auto layout, gap is the space between sibling children, and padding is the space between the children and the edges of their parent frame. Both belong to the parent.; UI Design with Figma · Taught in “Auto Layout: Direction, Gap and Padding”
Group: A bundle of layers whose size is derived from its children. It has no fill, padding or auto layout of its own, so it suits loose visual clusters rather than interface parts.; UI Design with Figma · Taught in “Frames, Groups, Layers and Constraints”
Hug, Fill and Fixed: Auto layout sizing options. Hug contents sizes a frame to its children, Fill container takes the parent’s available space, and Fixed keeps an exact size regardless of content.; UI Design with Figma · Taught in “Resizing: Hug, Fill, Fixed and Wrap”
Hybrid team model: A way of running a design system in which a small dedicated core owns tokens, reviews and releases while product teams contribute components and fixes through a defined process.; Design Systems That Scale · Taught in “Principles and Team Models”
Ignore auto layout: A setting, formerly called absolute position, that takes one child out of its auto layout flow so it can be positioned with constraints, such as a badge on an icon’s corner.; UI Design with Figma · Taught in “Resizing: Hug, Fill, Fixed and Wrap”
Instance: A linked copy of a main component. It can override content and appearance such as text, fills, visibility and nested instances, but cannot change its layer structure.; UI Design with Figma · Taught in “Components and Instances”
Interactive component: A component set with prototype interactions between its variants, such as On tap Change to Done, so every instance responds in prototypes without extra screens.; UI Design with Figma · Taught in “Prototyping: Interactions, Smart Animate and Overlays”
Interface inventory: An audit that collects every instance of each UI element across products, grouped by type, to make duplication visible and to decide what a design system should own first.; Design Systems That Scale · Taught in “The Interface Inventory”
Layout guide: A visual aid attached to a frame, formerly called a layout grid, in the form of columns, rows or a uniform grid, defined by count, margin and gutter. It never moves layers by itself.; UI Design with Figma · Taught in “Layout Guides and the 8-Point System”
Library: A published Figma file whose components, styles and variables other files can use. Subscribing files are told about updates and choose when to accept them.; UI Design with Figma · Taught in “Building the Steady Mini Kit”
Main component: The source definition of a reusable Figma element. Changes to it flow to every linked instance, except for properties an instance has overridden.; UI Design with Figma · Taught in “Components and Instances”
Mode axis: An independent dimension of theming, such as color scheme, brand or density, that owns its own set of tokens so combinations compose without separate files for each.; Design Systems That Scale · Taught in “Themes and Modes”
Output references: A pipeline setting that keeps aliases as var() references in generated CSS instead of resolved values, so the token tiers and runtime overrides survive into the browser.; Design Systems That Scale · Taught in “Token Pipelines: From JSON to Every Platform”
Primitive token: A token that names a raw value by what it is, such as --nw-blue-600, without saying where it is used. Primitives form the system’s palette and scales.; Design Systems That Scale · Taught in “Three Tiers: Primitive, Semantic, Component”
Proximity: The Gestalt principle that elements placed close together are seen as related. In UI design it means space inside a group must be smaller than space between groups.; UI Design with Figma · Taught in “Hierarchy, Alignment and Spacing”
Ready for dev: A Dev Mode status on sections, frames or components that signals a design is stable enough to build. Edits afterwards automatically mark it as Changed.; UI Design with Figma · Taught in “Dev Mode and Handoff”
RFC (request for comments): A written proposal for a significant change, such as a new component, laying out the problem, evidence, API sketch and accessibility plan for open review before building.; Design Systems That Scale · Taught in “Contribution and Governance”
Semantic token: A variable named by its role, such as color/action/primary, that aliases a raw palette value. Components bind to semantic tokens so themes and palette changes stay one edit.; UI Design with Figma · Taught in “Styles vs Variables”
Semantic token: A token that names an intent, such as --nw-color-action-bg, and points at a primitive. Themes and brands change which primitive each semantic token points at.; Design Systems That Scale · Taught in “Three Tiers: Primitive, Semantic, Component”
Semantic versioning: A MAJOR.MINOR.PATCH version scheme where patches fix bugs, minors add backward-compatible features, and majors contain changes that can break existing usage.; Design Systems That Scale · Taught in “Semver and Changelogs for a Design System”
Slot: A place in a component where the consumer passes content, such as children or a startIcon element, instead of configuring that content through more props.; Design Systems That Scale · Taught in “Component APIs: Props, Variants and Slots”
Smart animate: A prototype animation that matches layers with the same name and hierarchy in two frames and animates the differences in position, size, rotation, opacity and fill.; UI Design with Figma · Taught in “Prototyping: Interactions, Smart Animate and Overlays”
State matrix: A grid of every variant against every interaction state, such as hover, focus visible, disabled, loading and pressed, used to design, build and test a component completely.; Design Systems That Scale · Taught in “States and Accessibility, Built In”
Style: A named, reusable composite of visual properties in Figma, such as a text style’s font, size, weight and line height, or an effect style holding stacked shadows.; UI Design with Figma · Taught in “Styles vs Variables”
Target size: The tappable area of an interactive element. WCAG 2.2 AA requires at least 24 by 24 CSS pixels; Apple recommends 44 points and Material 48 dp.; UI Design with Figma · Taught in “Designing for Accessibility”
Theme: A remapping of semantic tokens to different primitives, such as a dark theme, applied with a selector like [data-theme="dark"] while components stay unchanged.; Design Systems That Scale · Taught in “Themes and Modes”
Token naming grammar: A fixed order of name parts, such as category, concept, property, variant and state, that makes token names predictable to guess, sortable, and checkable by a lint rule.; Design Systems That Scale · Taught in “Naming Tokens So They Survive”
Token pipeline: A build step that parses token files, resolves aliases, transforms names and values per platform, and writes formats such as CSS custom properties, Swift and Kotlin.; Design Systems That Scale · Taught in “Token Pipelines: From JSON to Every Platform”
Type scale: A short, fixed list of text sizes, each paired with a line height and weight and given a named job such as Title, Body or Caption, used consistently across every screen.; UI Design with Figma · Taught in “Type Scale and Color with Contrast”
Variable: A named single value in Figma, such as a color, number, string or boolean, that can be bound to layer properties, alias another variable and hold different values per mode.; UI Design with Figma · Taught in “Styles vs Variables”
Variable mode: One column of values in a variable collection, such as Light or Dark. Setting a mode on a frame or page swaps every bound value at once, and children inherit it.; UI Design with Figma · Taught in “Variable Modes: Light and Dark”
Variant: One version of a component inside a component set, described by variant properties such as State=Done, used for differences that restyle several layers together.; UI Design with Figma · Taught in “Variants and Component Properties”
Variant: One of a fixed set of mutually exclusive styles of a component, such as primary, secondary or danger, best expressed as a single enum prop rather than separate booleans.; Design Systems That Scale · Taught in “Component APIs: Props, Variants and Slots”
Visual hierarchy: The order in which people notice elements on a screen, created on purpose with size, weight, color, position and space so the most important content is seen first.; UI Design with Figma · Taught in “Hierarchy, Alignment and Spacing”
Visual regression test: A test that screenshots a component state and compares it with an approved baseline, failing on differences that a human then accepts as intended or rejects as bugs.; Design Systems That Scale · Taught in “Storybook, Visual Regression and Releases”
Wrap: An auto layout option for horizontal and vertical flows that moves children onto a new line when they no longer fit, useful for chips and tags on narrow screens.; UI Design with Figma · Taught in “Resizing: Hug, Fill, Fixed and Wrap”

Mobile Development · 60 terms

@MainActor: An attribute that isolates code or a type to the main actor, the main thread where UI runs. New Xcode app projects make it the default isolation.; Swift Essentials for iOS · Taught in “async/await and Swift 6 Concurrency”
@Model (SwiftData): A macro that turns a class into persisted SwiftData data. You read models with @Query and insert or delete them through the model context, which autosaves.; Swift Essentials for iOS · Taught in “Saving Data with SwiftData”
@Observable: A macro from the Observation framework that makes a class’s properties trackable, so SwiftUI re-renders only the views whose body read a property that changed.; Swift Essentials for iOS · Taught in “State, Bindings and @Observable”
@State: A SwiftUI property wrapper that stores a value the view owns outside the view struct, so it survives re-renders and triggers an update when it changes.; Swift Essentials for iOS · Taught in “State, Bindings and @Observable”
Actor: A reference type that protects its mutable state by running one call at a time. Code outside the actor must use await to reach it, which prevents data races.; Swift Essentials for iOS · Taught in “async/await and Swift 6 Concurrency”
Associated value: Data attached to a specific enum case for each instance, such as case card(lastFour: String). You read it back with pattern matching like case .card(let lastFour).; Swift Essentials for iOS · Taught in “Enums with Associated Values”
AsyncStorage: An asynchronous, unencrypted key-value store for strings. It suits small preferences, not secrets or large collections of records you need to query.; Build Mobile Apps with React Native · Taught in “Storing Data on the Device”
Binding: A two-way connection to a value owned elsewhere, written with a $ prefix. Controls such as Toggle and TextField take bindings so they can read and write the source of truth.; Swift Essentials for iOS · Taught in “State, Bindings and @Observable”
canAskAgain: A field in an Expo permission response. When false, the system won’t show the permission prompt again, so only the Settings app can change the user’s answer.; Build Mobile Apps with React Native · Taught in “Permissions: Asking at the Right Moment”
Closure: A block of code without a name that can be stored, passed to functions like filter or map, and called later. It captures the variables it uses from its surrounding scope.; Swift Essentials for iOS · Taught in “Functions and Closures”
Codable: The combination of Decodable and Encodable, which lets the compiler generate code to convert your types to and from formats such as JSON.; Swift Essentials for iOS · Taught in “Networking with URLSession and Codable”
Config plugin: An app.json entry that writes native configuration, such as iOS permission descriptions or Android manifest entries, when the app is built. Changes need a new build.; Build Mobile Apps with React Native · Taught in “Permissions: Asking at the Right Moment”
Database migration: A versioned step that upgrades an existing database schema, such as adding a column, run once per device in order, typically tracked with PRAGMA user_version in SQLite.; Build Mobile Apps with React Native · Taught in “Storing Data on the Device”
Decimal: A Foundation number type that stores base-10 digits exactly, which makes it the right choice for money. Unlike Double, adding 0.1 ten times gives exactly 1.; Swift Essentials for iOS · Taught in “Constants, Variables and Types”
Deep link: A URL, such as trailhead://hikes/42, that opens the app directly on a specific screen. Expo Router maps it to a route file automatically.; Build Mobile Apps with React Native · Taught in “Modals, Protected Routes and Deep Links”
Density-independent point: The unit behind every unitless number in React Native styles. The platform converts points to physical pixels, so sizes look the same on low- and high-density screens.; Build Mobile Apps with React Native · Taught in “StyleSheet in a World Without the Cascade”
Development build: Your own app binary, with your native modules, identity and configuration, plus dev tools like Fast Refresh. You create one with npx expo run or EAS Build.; Build Mobile Apps with React Native · Taught in “Starting a Project with Expo”
Dynamic route: A route file named with square brackets, like [id].tsx, that matches any single URL segment and exposes it as a string param through useLocalSearchParams.; Build Mobile Apps with React Native · Taught in “Tabs, Dynamic Routes and Params”
EAS Build: Expo’s cloud service that compiles and signs Android and iOS binaries from your project using profiles defined in eas.json, such as development, preview and production.; Build Mobile Apps with React Native · Taught in “Building and Submitting with EAS”
EAS Update: Expo’s service for publishing new JavaScript and assets to installed builds over the air, without a store release. It can’t deliver native code changes.; Build Mobile Apps with React Native · Taught in “Over-the-Air Updates and Your Release Routine”
Exhaustive switch: Swift’s rule that a switch must handle every possible value. Over enums it makes the compiler list every switch you need to update when you add a case.; Swift Essentials for iOS · Taught in “Collections and Control Flow”
Expo Go: A store app with a fixed set of native modules that loads your project’s JavaScript from the dev server. Great for learning, but it can’t include custom native code.; Build Mobile Apps with React Native · Taught in “Starting a Project with Expo”
File-based routing: Expo Router’s model where every file in src/app is a screen and its path is the URL, with _layout files wrapping sibling routes in a navigator.; Build Mobile Apps with React Native · Taught in “File-Based Routing with Expo Router”
Force unwrap (!): Writing ! after an optional to take its value without checking. If the optional is nil, the app crashes immediately, so use it only when nil would be a programmer error.; Swift Essentials for iOS · Taught in “Optionals Without Crashes”
guard let: A statement that unwraps an optional or checks a condition and must exit the scope in its else branch. After it, the unwrapped value is available for the rest of the function.; Swift Essentials for iOS · Taught in “Optionals Without Crashes”
Hermes: The JavaScript engine built for React Native. It runs your app’s JavaScript on its own thread, separate from the UI thread that draws views and receives touches.; Build Mobile Apps with React Native · Taught in “What React Native Really Is”
hitSlop: A Pressable prop that enlarges the touch area beyond the visible element, so small icons can still meet the 44-point minimum tap target.; Build Mobile Apps with React Native · Taught in “Touch and Typing: Pressable and TextInput”
jest-expo: A Jest preset that configures transforms for React Native and mocks the native side of Expo modules, so tests run in Node without a device.; Build Mobile Apps with React Native · Taught in “Testing with Jest and React Native Testing Library”
keyExtractor: A FlatList prop that returns a stable, unique key for each item, usually its id, so rows keep the right identity as items are added, removed or reordered.; Build Mobile Apps with React Native · Taught in “Lists That Stay Fast: FlatList and SectionList”
Main axis: The direction a flex container lays out its children, set by flexDirection. It is vertical by default in React Native, and justifyContent positions children along it.; Build Mobile Apps with React Native · Taught in “Flexbox with Mobile Defaults”
Metro: The JavaScript bundler and dev server that npx expo start runs. It serves your code to Expo Go or a development build and powers Fast Refresh.; Build Mobile Apps with React Native · Taught in “Starting a Project with Expo”
mutating: A keyword on struct and enum methods that change the value’s own properties. Mutating methods can only be called on a var, never on a let.; Swift Essentials for iOS · Taught in “Structs, Classes and Value Semantics”
Native view: A platform UI element, such as UIView on iOS or android.view.View on Android, that React Native creates and updates from your components instead of rendering HTML.; Build Mobile Apps with React Native · Taught in “What React Native Really Is”
NavigationStack: A SwiftUI container that pushes and pops screens. NavigationLink(value:) selects a value and .navigationDestination(for:) decides which screen shows it.; Swift Essentials for iOS · Taught in “Lists, Navigation and Forms”
New Architecture: React Native’s rendering and native-module system built on JSI, the Fabric renderer and TurboModules. It has been the only architecture since React Native 0.82.; Build Mobile Apps with React Native · Taught in “What React Native Really Is”
Nil-coalescing operator (??): The ?? operator, which returns the value inside an optional or a default when the optional is nil, as in note ?? "No note".; Swift Essentials for iOS · Taught in “Optionals Without Crashes”
Optional: A type such as Decimal? that holds either a value or nil. Swift won’t let you use it as a plain value until you unwrap it safely.; Swift Essentials for iOS · Taught in “Optionals Without Crashes”
Pressable: The core component for anything tappable. It reports presses and long presses, and its style can be a function of the pressed state for instant feedback.; Build Mobile Apps with React Native · Taught in “Touch and Typing: Pressable and TextInput”
Protected route: A route wrapped in Stack.Protected with a guard condition. While the guard is false the route is unavailable, and navigation to it, including from deep links, is redirected.; Build Mobile Apps with React Native · Taught in “Modals, Protected Routes and Deep Links”
Protocol: A named set of requirements, such as properties and methods, that structs, classes and enums can adopt. Code written against the protocol works with every conforming type.; Swift Essentials for iOS · Taught in “Protocols and Extensions”
Protocol extension: An extension on a protocol that provides default implementations, so every conforming type gains that behaviour without writing it again.; Swift Essentials for iOS · Taught in “Protocols and Extensions”
Raw value: A fixed String or number stored for each case of an enum declared like enum Category: String. init(rawValue:) converts back and returns nil for unknown values.; Swift Essentials for iOS · Taught in “Enums with Associated Values”
React Native DevTools: The built-in debugger, opened with j in the Metro terminal, offering a console, breakpoints, a Components inspector and a Profiler for your running app.; Build Mobile Apps with React Native · Taught in “Debugging and Performance”
Reference semantics: The behaviour of classes and actors: assigning an instance copies a reference, so several names can point at the same object and see each other’s changes.; Swift Essentials for iOS · Taught in “Structs, Classes and Value Semantics”
Retain cycle: Two objects, or an object and a closure, holding strong references to each other so neither can be freed by ARC. Capturing [weak self] in the closure breaks the cycle.; Swift Essentials for iOS · Taught in “Structs, Classes and Value Semantics”
Route group: A folder whose name is in parentheses, like (tabs). It shares a layout among its routes without adding a segment to their URLs.; Build Mobile Apps with React Native · Taught in “Tabs, Dynamic Routes and Params”
Runtime version: A label shared by a build and its compatible updates. An update only applies to builds with the same runtime version, which protects old builds from JavaScript needing newer native code.; Build Mobile Apps with React Native · Taught in “Over-the-Air Updates and Your Release Routine”
Safe area: The part of the screen not covered by notches, rounded corners, the home indicator or system bars. Screens without headers pad themselves using insets from react-native-safe-area-context.; Build Mobile Apps with React Native · Taught in “Screen Sizes, Safe Areas and Platform Code”
SecureStore: The expo-secure-store module, which encrypts small values such as tokens using the iOS Keychain and the Android Keystore.; Build Mobile Apps with React Native · Taught in “Storing Data on the Device”
Sendable: A protocol marking types that are safe to pass between concurrency domains. Structs made of Sendable values qualify automatically; plain classes with mutable properties don’t.; Swift Essentials for iOS · Taught in “async/await and Swift 6 Concurrency”
Stack navigator: A navigator that pushes screens on top of each other with native animations and back gestures. Screens underneath stay mounted, keeping their state and scroll position.; Build Mobile Apps with React Native · Taught in “File-Based Routing with Expo Router”
Structured concurrency: Running async work as child tasks, with async let or task groups, that must finish before their parent returns. Cancelling the parent cancels every child automatically.; Swift Essentials for iOS · Taught in “async/await and Swift 6 Concurrency”
Style array: A style prop given as an array of style objects. React Native merges it left to right, later keys win, and falsy entries are skipped.; Build Mobile Apps with React Native · Taught in “StyleSheet in a World Without the Cascade”
Swift Testing: Apple’s testing framework where tests are functions marked @Test, checked with #expect and #require, and parameterized with arguments:.; Swift Essentials for iOS · Taught in “Testing and TestFlight”
TestFlight: Apple’s beta distribution service. Builds uploaded to App Store Connect reach up to 100 internal testers immediately and up to 10,000 external testers after Beta App Review.; Swift Essentials for iOS · Taught in “Testing and TestFlight”
Type inference: Swift’s ability to work out a value’s type from the value you assign, so let cups = 3 is an Int without an annotation. The type is fixed from then on.; Swift Essentials for iOS · Taught in “Constants, Variables and Types”
Typed throws: Swift 6 syntax such as throws(BudgetError) that names the exact error type a function can throw, so callers can switch over the error exhaustively without a catch-all.; Swift Essentials for iOS · Taught in “Error Handling and Typed Throws”
Value semantics: The behaviour of structs and enums: assigning or passing a value makes an independent copy, so changing the copy never affects the original.; Swift Essentials for iOS · Taught in “Structs, Classes and Value Semantics”
View modifier: A method like .padding() or .font(.headline) that wraps a SwiftUI view in a new view with a change applied. Modifiers apply in order, so their order matters.; Swift Essentials for iOS · Taught in “Views and Modifiers”
Virtualization: The technique FlatList and SectionList use to mount only the rows near the viewport and replace the rest with empty space, keeping long lists fast and memory-light.; Build Mobile Apps with React Native · Taught in “Lists That Stay Fast: FlatList and SectionList”

DevOps & Cloud · 90 terms

.dockerignore: A file listing patterns to exclude from the build context, such as node_modules, .git and .env files, which speeds up builds and keeps secrets out of images.; Docker & Kubernetes: Ship with Confidence · Taught in “Multi-Stage Builds and .dockerignore”
.gitignore: A file listing patterns of untracked files Git should never track, such as node_modules/, build output and .env. It doesn’t affect files that are already tracked.; Git & GitHub · Taught in “Stash and .gitignore”
Annotated tag: A permanent, named marker on a commit that also stores the tagger, date and a message. Created with git tag -a, it’s the usual way to mark a release.; Git & GitHub · Taught in “Commit Messages, Tags and Releases”
ARN (Amazon Resource Name): The unique identifier for an AWS resource, in the form arn:partition:service:region:account-id:resource. Policies use ARNs to say exactly which resources a statement covers.; AWS Cloud Foundations · Taught in “IAM Users, Groups, Roles and Policies”
Availability Zone (AZ): One or more discrete data centres inside a Region, with independent power and networking. Running a workload in two or more AZs lets it survive the loss of one.; AWS Cloud Foundations · Taught in “Regions, Availability Zones and Edge Locations”
AWS Budgets: A service that tracks actual and forecasted spend against an amount you set and sends alerts when thresholds are crossed. It warns you but does not stop spending on its own.; AWS Cloud Foundations · Taught in “The Shared Responsibility Model and a Safe Account”
AWS CLI v2: The command-line tool that calls the same AWS APIs as the console. Commands follow the pattern aws , with global options such as --profile, --region, --query and --output.; AWS Cloud Foundations · Taught in “Console and AWS CLI v2”
aws sts get-caller-identity: A CLI command that returns the account ID and ARN of the identity your credentials represent. It needs no permissions, so it is the standard check before destructive commands.; AWS Cloud Foundations · Taught in “Console and AWS CLI v2”
AWS Well-Architected Framework: AWS’s set of design questions grouped into six pillars: operational excellence, security, reliability, performance efficiency, cost optimization and sustainability.; AWS Cloud Foundations · Taught in “Observe with CloudWatch, Review with Well-Architected”
Branch: A named, movable pointer to one commit. Committing while on a branch moves it forward to the new commit; creating one copies no files.; Git & GitHub · Taught in “Branches Are Pointers, HEAD Is You”
Build cache: Stored results of earlier build steps. A step is reused when its instruction and inputs are unchanged; the first changed step and every step after it rebuild.; Docker & Kubernetes: Ship with Confidence · Taught in “Layers and the Build Cache”
Build context: The set of files sent to the builder by docker build, usually the directory you pass as the last argument, minus anything matched by .dockerignore. COPY can only read from it.; Docker & Kubernetes: Ship with Confidence · Taught in “Your First Dockerfile”
CloudWatch alarm: A rule that watches one metric against a threshold over a period and changes state when crossed, typically notifying an Amazon SNS topic that alerts people.; AWS Cloud Foundations · Taught in “Observe with CloudWatch, Review with Well-Architected”
Commit: A recorded snapshot of every tracked file, with an author, date, message and a pointer to its parent commit. Its ID is a hash of all of that, so it never changes.; Git & GitHub · Taught in “Why Version Control, and How Git Thinks”
Commit graph (DAG): Git history as a directed acyclic graph: each commit points to its parent or parents, and following those links backwards from any commit gives its history.; Git & GitHub · Taught in “Reading History: Commits as a Graph”
Compose service: One component of a Compose application, such as api or db, defined in compose.yaml and reachable from other services on the project network by its service name.; Docker & Kubernetes: Ship with Confidence · Taught in “Compose Fundamentals: Services and Networks”
Compose watch: A development mode, started with docker compose up --watch, that syncs edited files into running containers or rebuilds the image when files such as the lockfile change.; Docker & Kubernetes: Ship with Confidence · Taught in “Env Files, Overrides and Watch Mode”
Condition key: A value from the request context, such as aws:SecureTransport or aws:MultiFactorAuthPresent, that a policy’s Condition block tests to decide whether a statement applies.; AWS Cloud Foundations · Taught in “Reading and Writing IAM Policies”
Conditional write: A DynamoDB write with a ConditionExpression, such as attribute_not_exists(email), that succeeds only if the condition holds, checked atomically to prevent duplicates.; AWS Cloud Foundations · Taught in “A Serverless API with Lambda, API Gateway and DynamoDB”
ConfigMap and Secret: Objects that hold configuration for Pods, injected as environment variables or files. Secrets are for credentials but are only base64-encoded, so access control matters.; Docker & Kubernetes: Ship with Confidence · Taught in “ConfigMaps, Secrets and Namespaces”
Container: An ordinary process that the Linux kernel isolates with namespaces and limits with cgroups, running from an image’s filesystem plus a private, disposable writable layer.; Docker & Kubernetes: Ship with Confidence · Taught in “What a Container Really Is”
Control loop: The pattern behind Kubernetes controllers: continuously observe actual state, compare it with the desired state stored in the API, and act to close the difference.; Docker & Kubernetes: Ship with Confidence · Taught in “The Control Loop and Your First Cluster”
Conventional Commits: A commit message format, type(optional scope): description, using types like feat, fix and docs, so tools can generate changelogs and semantic version numbers.; Git & GitHub · Taught in “Commit Messages, Tags and Releases”
Deployment: A Kubernetes object that keeps a set of identical Pods running through ReplicaSets and replaces them gradually when the Pod template changes.; Docker & Kubernetes: Ship with Confidence · Taught in “Pods, ReplicaSets and Deployments”
Detached HEAD: The state where HEAD points straight at a commit instead of a branch. New commits made there belong to no branch until you create one with git switch -c.; Git & GitHub · Taught in “Branches Are Pointers, HEAD Is You”
Distroless image: A minimal base image containing only a language runtime and its libraries, with no shell or package manager, which shrinks the attack surface and the vulnerability report.; Docker & Kubernetes: Ship with Confidence · Taught in “Small Bases and Non-Root Users”
Edge location: One of many small AWS sites close to users, where Amazon CloudFront caches and serves content and Amazon Route 53 answers DNS queries.; AWS Cloud Foundations · Taught in “Regions, Availability Zones and Edge Locations”
Exec form: Writing CMD or ENTRYPOINT as a JSON array, such as ["node", "dist/server.js"], so the program runs as PID 1 without a shell and receives stop signals directly.; Docker & Kubernetes: Ship with Confidence · Taught in “Your First Dockerfile”
Explicit deny: A Deny statement in any applicable policy that matches a request. It always overrides any Allow, which makes it the basis of reliable guardrails.; AWS Cloud Foundations · Taught in “IAM Users, Groups, Roles and Policies”
Fast-forward: A merge where the current branch hasn’t moved since the other branch started, so Git simply slides the pointer forward and creates no merge commit.; Git & GitHub · Taught in “Merging: Fast-Forward and Merge Commits”
Fork: Your own copy of someone else’s repository on GitHub. You push branches to it and open pull requests back to the original, conventionally called upstream.; Git & GitHub · Taught in “Issues, Projects, Forks and Open Source”
Gateway API: The Kubernetes successor to Ingress for routing external traffic, split into GatewayClass, Gateway and HTTPRoute resources so platform and app teams each own their part.; Docker & Kubernetes: Ship with Confidence · Taught in “Traffic In, Trouble Out: Gateway API and Debugging”
GB-second: Lambda’s unit of compute billing: the memory allocated in gigabytes multiplied by the run time in seconds, measured to the millisecond.; AWS Cloud Foundations · Taught in “Compute: Amazon EC2 and AWS Lambda”
git push --force-with-lease: A force-push that only overwrites the remote branch if it still points where you last saw it, so you won’t silently erase commits someone else pushed since your last fetch.; Git & GitHub · Taught in “Rebase vs Merge, and the Golden Rule”
git revert: A command that creates a new commit applying the exact opposite of an earlier commit. It undoes changes without rewriting history, so it’s safe on shared branches.; Git & GitHub · Taught in “Undoing Safely: Revert, Reset and the Reflog”
GitHub Actions workflow: A YAML file in .github/workflows/ that runs jobs on GitHub’s machines when events like pull_request happen. Each job reports a status check on the pull request.; Git & GitHub · Taught in “Guarding main: CI with Actions and Rulesets”
HEAD: Git’s pointer to where you are. It usually names the current branch, which names a commit; HEAD~1 means the commit before the one you’re on.; Git & GitHub · Taught in “Branches Are Pointers, HEAD Is You”
Healthcheck: A command Docker runs inside a container on a schedule to decide whether it is healthy. Compose can make other services wait for it with condition: service_healthy.; Docker & Kubernetes: Ship with Confidence · Taught in “Startup Order with Healthchecks”
Helm chart: A package of templated Kubernetes manifests plus default values. helm upgrade --install deploys it as a numbered release revision that helm rollback can return to.; Docker & Kubernetes: Ship with Confidence · Taught in “Rolling Updates, Rollbacks and Helm”
HorizontalPodAutoscaler: A controller (autoscaling/v2) that adjusts a workload’s replica count to keep a metric, such as average CPU utilization relative to requests, near a target.; Docker & Kubernetes: Ship with Confidence · Taught in “Requests, Limits and Autoscaling”
IAM Identity Center: The AWS service where people sign in once, with MFA, and receive short-term access to the accounts and permission sets assigned to them, without IAM users or access keys.; AWS Cloud Foundations · Taught in “Identity Center for People, Roles for Workloads”
IAM role: An identity with permissions but no long-term credentials. A trusted principal assumes it and receives temporary credentials from AWS STS that expire after the session.; AWS Cloud Foundations · Taught in “IAM Users, Groups, Roles and Policies”
Image: A read-only, layered filesystem snapshot plus metadata such as the default command and user. One image can be the template for any number of containers.; Docker & Kubernetes: Ship with Confidence · Taught in “What a Container Really Is”
Image digest: A SHA-256 hash that identifies an image’s exact content. Unlike a tag, it can never point to different bytes, so pinning by digest guarantees every node runs the same image.; Docker & Kubernetes: Ship with Confidence · Taught in “Tags, Digests and Registries”
Index (staging area): The next commit being assembled. git add copies a file’s current content into it, git commit turns it into a commit, and git restore --staged takes content back out.; Git & GitHub · Taught in “The Three Areas: Working Tree, Index, Repository”
Instance type: The name that sets an EC2 instance’s hardware, such as m7g.large: family m, generation 7, Graviton processor g, and size large. Each size step roughly doubles resources.; AWS Cloud Foundations · Taught in “Compute: Amazon EC2 and AWS Lambda”
Label selector: A query over key-value labels that Kubernetes objects use to find each other, for example a Service selecting the Pods it sends traffic to.; Docker & Kubernetes: Ship with Confidence · Taught in “Pods, ReplicaSets and Deployments”
Lambda execution role: The IAM role a Lambda function assumes when it runs. The AWS SDKs pick up its temporary credentials automatically, so function code never contains access keys.; AWS Cloud Foundations · Taught in “Identity Center for People, Roles for Workloads”
Least privilege: Granting an identity only the specific actions on the specific resources its job needs, and widening permissions only when a real AccessDenied shows something is missing.; AWS Cloud Foundations · Taught in “Reading and Writing IAM Policies”
Liveness probe: A periodic check that decides whether a container is stuck. Failing restarts the container, so it must not depend on databases or other services.; Docker & Kubernetes: Ship with Confidence · Taught in “Probes and Graceful Shutdown”
Merge base: The most recent commit two branches share. Git compares each branch tip with it during a three-way merge to decide which changes to take.; Git & GitHub · Taught in “Merging: Fast-Forward and Merge Commits”
Merge commit: A commit with two parents, created when Git combines two branches that have both moved on. Its snapshot contains the work from both lines of history.; Git & GitHub · Taught in “Reading History: Commits as a Graph”
Merge conflict: What happens when both branches changed the same lines since their merge base. Git writes both versions between markers and waits for you to edit, git add and continue.; Git & GitHub · Taught in “Resolving Merge Conflicts Step by Step”
Multi-AZ deployment: An Amazon RDS setup with a synchronous standby database in a second Availability Zone that takes over automatically if the primary’s AZ fails.; AWS Cloud Foundations · Taught in “Databases: Amazon RDS vs Amazon DynamoDB”
Multi-stage build: A Dockerfile with several FROM stages where only the final stage ships, so compilers, dev dependencies and sources stay in earlier stages and out of the production image.; Docker & Kubernetes: Ship with Confidence · Taught in “Multi-Stage Builds and .dockerignore”
Named volume: Docker-managed storage that exists independently of containers, used for data such as database files that must survive container removal. docker compose down -v deletes it.; Docker & Kubernetes: Ship with Confidence · Taught in “Volumes: Data That Survives”
Namespace: A Kubernetes scope for object names, permissions and quotas, typically one per app or team. It does not block network traffic without a NetworkPolicy.; Docker & Kubernetes: Ship with Confidence · Taught in “ConfigMaps, Secrets and Namespaces”
Namespaces and cgroups: The two kernel features behind containers: namespaces control what a process can see (processes, network, mounts), and cgroups limit what it can use (CPU, memory, I/O).; Docker & Kubernetes: Ship with Confidence · Taught in “What a Container Really Is”
Network ACL: A stateless list of numbered allow and deny rules applied at a subnet boundary. Because it is stateless, return traffic needs its own rules.; AWS Cloud Foundations · Taught in “Networking: Amazon VPC, Subnets and Security Groups”
Origin access control (OAC): A CloudFront feature that signs requests to a private S3 bucket so that a bucket policy can allow only that distribution to read, keeping the bucket closed to everyone else.; AWS Cloud Foundations · Taught in “Host a Static Site on S3 and CloudFront”
Partition key: The DynamoDB key attribute that decides where an item is stored. A Query must name one partition key value, which is why keys are designed around the questions you ask.; AWS Cloud Foundations · Taught in “Databases: Amazon RDS vs Amazon DynamoDB”
Pod: The smallest unit Kubernetes schedules: one or more containers that share a network identity and volumes. Pods are disposable and replaced, not repaired.; Docker & Kubernetes: Ship with Confidence · Taught in “Pods, ReplicaSets and Deployments”
Public subnet: A VPC subnet whose route table sends 0.0.0.0/0 to an internet gateway. Private subnets have no such route, so the internet cannot start connections to them.; AWS Cloud Foundations · Taught in “Networking: Amazon VPC, Subnets and Security Groups”
Pull request: A GitHub proposal to merge one branch into another, where reviewers comment, automated checks run, and the change is finally merged. New pushes to the branch update it.; Git & GitHub · Taught in “Pull Requests and Code Review”
Readiness probe: A periodic check that decides whether a Pod should receive traffic. Failing removes the Pod from Service endpoints without restarting it, and it gates rolling updates.; Docker & Kubernetes: Ship with Confidence · Taught in “Probes and Graceful Shutdown”
Rebase: Replaying a branch’s commits on top of another commit, producing new commits with new IDs and a linear history. Safe only for commits nobody else has built on.; Git & GitHub · Taught in “Rebase vs Merge, and the Golden Rule”
Reflog: A local log of every position HEAD has had, such as commits, resets, rebases and switches. It lets you find and restore commits that no branch points to any more.; Git & GitHub · Taught in “Undoing Safely: Revert, Reset and the Reflog”
Region: A separate geographic area where AWS runs its own copy of most services, such as eu-west-1 in Ireland. Your data stays in the Region you choose unless you move or replicate it.; AWS Cloud Foundations · Taught in “Regions, Availability Zones and Edge Locations”
Remote: A named URL for another copy of the repository, usually on GitHub. origin is the conventional name for the one you cloned from or push to.; Git & GitHub · Taught in “Remotes: Push, Fetch, Pull and Tracking Branches”
Remote-tracking branch: A local, read-only record such as origin/main of where a branch was on a remote at your last fetch, pull or push. It moves only when you talk to the remote.; Git & GitHub · Taught in “Remotes: Push, Fetch, Pull and Tracking Branches”
Repository: A project’s complete history and settings, stored in the hidden .git folder; it holds every commit, branch and tag, and is created with git init or git clone.; Git & GitHub · Taught in “Install, Configure, and Make Your First Commit”
Requests and limits: Per-container resource settings: requests are what the scheduler reserves, limits are enforced ceilings. Exceeding a CPU limit throttles; exceeding a memory limit triggers an OOM kill.; Docker & Kubernetes: Ship with Confidence · Taught in “Requests, Limits and Autoscaling”
Rolling update: The default Deployment strategy: a new ReplicaSet scales up while the old one scales down, paced by maxSurge and maxUnavailable and gated by readiness.; Docker & Kubernetes: Ship with Confidence · Taught in “Rolling Updates, Rollbacks and Helm”
Root user: The identity created with an AWS account’s sign-up email. It can do anything, including closing the account, so it gets strong MFA, no access keys and only rare use.; AWS Cloud Foundations · Taught in “The Shared Responsibility Model and a Safe Account”
Ruleset: A named set of GitHub rules for branches or tags, such as requiring a pull request, requiring status checks to pass and blocking force pushes on main.; Git & GitHub · Taught in “Guarding main: CI with Actions and Rulesets”
S3 Block Public Access: Bucket- and account-level settings, on by default for new buckets, that override any policy or ACL that would make data public.; AWS Cloud Foundations · Taught in “Storage: Amazon S3, EBS and EFS”
S3 storage class: A per-object setting, such as S3 Standard or S3 Glacier Deep Archive, that trades storage price against retrieval cost, retrieval time and minimum storage duration.; AWS Cloud Foundations · Taught in “Storage: Amazon S3, EBS and EFS”
Secret mount: A BuildKit feature, RUN --mount=type=secret, that exposes a credential to one build step as a file or environment variable without writing it into any image layer.; Docker & Kubernetes: Ship with Confidence · Taught in “Scanning Images and Keeping Secrets Out”
Security group: A stateful allow-list firewall attached to a resource’s network interface. Replies to allowed traffic are permitted automatically, and rules can name another security group as the source.; AWS Cloud Foundations · Taught in “Networking: Amazon VPC, Subnets and Security Groups”
Service: A stable virtual IP and DNS name in front of a changing set of ready Pods chosen by a label selector. Types include ClusterIP, NodePort and LoadBalancer.; Docker & Kubernetes: Ship with Confidence · Taught in “Services: Stable Addresses for Moving Pods”
Shared responsibility model: The split of security duties in which AWS secures the cloud itself, such as hardware, facilities and service software, while customers secure their data, access, configuration and code.; AWS Cloud Foundations · Taught in “The Shared Responsibility Model and a Safe Account”
SIGTERM: The polite stop signal Docker and Kubernetes send to PID 1 before a forced SIGKILL. Apps should handle it by finishing in-flight work and exiting cleanly.; Docker & Kubernetes: Ship with Confidence · Taught in “Running Containers: Ports, Env, Logs and Signals”
Spot Instance: Spare EC2 capacity offered at a deep discount that AWS can reclaim with a two-minute warning. It suits batch work that can restart, not databases or user-facing servers.; AWS Cloud Foundations · Taught in “Compute: Amazon EC2 and AWS Lambda”
SSH key pair: Two linked keys used to prove who you are to GitHub: the private key stays on your machine, and the .pub public key is added to your GitHub account.; Git & GitHub · Taught in “Authenticating with SSH Keys or HTTPS”
Stash: A place to park uncommitted changes and get a clean working tree. git stash push saves them, git stash pop brings them back; add -u to include untracked files.; Git & GitHub · Taught in “Stash and .gitignore”
Trust policy: The resource-based policy on an IAM role that names which principals, such as lambda.amazonaws.com, may assume the role.; AWS Cloud Foundations · Taught in “Identity Center for People, Roles for Workloads”
Untracked file: A file in the working tree that Git has never recorded and that isn’t staged. It stays out of commits until you git add it, and .gitignore can hide it.; Git & GitHub · Taught in “Install, Configure, and Make Your First Commit”
Upstream branch: The remote branch a local branch tracks, set with git push -u. It lets plain git push and git pull work and lets git status report ahead and behind counts.; Git & GitHub · Taught in “Remotes: Push, Fetch, Pull and Tracking Branches”
Version control: A system that records snapshots of a project over time, so you can see what changed, when and why, return to earlier versions, and combine work from several people.; Git & GitHub · Taught in “Why Version Control, and How Git Thinks”
Working tree: The project files on disk that you open and edit. Git compares them with the index and the last commit to report what has changed.; Git & GitHub · Taught in “The Three Areas: Working Tree, Index, Repository”

AI & Machine Learning · 30 terms

Baseline: A simple reference model, such as predicting the majority class or a one-line business rule, that any real model must clearly beat to be worth its cost.; Machine Learning Crash Course · Taught in “Baselines: The Model to Beat”
Confusion matrix: A table counting true negatives, false positives, false negatives and true positives. In scikit-learn, rows are the actual classes and columns the predicted ones.; Machine Learning Crash Course · Taught in “Classification Metrics Beyond Accuracy”
Cross-validation: Splitting the training data into k folds and training k models, each validated on a different fold, to get a steadier performance estimate and a sense of its spread.; Machine Learning Crash Course · Taught in “Cross-Validation”
Data drift: A change over time in the distribution of a model’s inputs compared with its training data, which can make predictions less reliable and should be monitored.; Machine Learning Crash Course · Taught in “Responsible ML: Bias, Fairness and Drift”
Data leakage: Information available during training or evaluation that will not be available at prediction time, such as features recorded after the prediction date or preprocessing fitted on validation rows.; Machine Learning Crash Course · Taught in “Data Leakage”
Decision threshold: The probability cut-off above which a classifier labels a case positive. The default is 0.5, but it should be chosen from the costs of each kind of mistake.; Machine Learning Crash Course · Taught in “Thresholds and Class Imbalance”
Decision tree: A model that predicts by asking a sequence of yes/no questions about single features, chosen to make the resulting groups as pure as possible.; Machine Learning Crash Course · Taught in “Decision Trees”
Embedding: A fixed-length vector produced by a model to represent a text or other item, arranged so that items with similar meaning have nearby vectors.; Machine Learning Crash Course · Taught in “Where LLMs and Embeddings Fit”
Epoch: One complete pass of a neural network’s training algorithm over the whole training set. Training usually runs for many epochs while the loss falls.; Machine Learning Crash Course · Taught in “Neural Networks and Deep Learning”
Estimator: Any scikit-learn object that learns from data with fit. Models, scalers and encoders are all estimators, and models add predict and score.; Machine Learning Crash Course · Taught in “Models in scikit-learn: fit, predict, score”
Feature: An input column the model uses to make a prediction, such as days since last order. Features must be known at the moment the prediction is made.; Machine Learning Crash Course · Taught in “The Workflow and the Train/Test Split”
Feature scaling: Rescaling columns to comparable ranges, typically mean 0 and standard deviation 1 with StandardScaler, fitted on training data only. Needed for distance-based, gradient-trained and penalised models.; Machine Learning Crash Course · Taught in “How Models Learn: Loss and Gradient Descent”
Gradient boosting: An ensemble that adds shallow trees one at a time, each fitted to the errors of the trees before it, with a learning rate controlling each tree’s contribution.; Machine Learning Crash Course · Taught in “Random Forests and Gradient Boosting”
Gradient descent: An optimisation method that repeatedly computes the slope of the loss for each parameter and moves the parameters a small step downhill, scaled by the learning rate.; Machine Learning Crash Course · Taught in “How Models Learn: Loss and Gradient Descent”
Hyperparameter: A setting chosen before training that controls how a model learns, such as max_depth or C, as opposed to parameters the model learns during fit.; Machine Learning Crash Course · Taught in “Models in scikit-learn: fit, predict, score”
k-means: A clustering algorithm that alternates between assigning each point to its nearest centre and moving each centre to the mean of its points, for a chosen number of clusters k.; Machine Learning Crash Course · Taught in “Clustering and PCA”
Logistic regression: A linear classification model that passes a weighted sum of features through the sigmoid function to output a probability between 0 and 1.; Machine Learning Crash Course · Taught in “Logistic Regression: Predicting Probabilities”
One-hot encoding: Turning a categorical column into one 0/1 column per category so models can use it. OneHotEncoder with handle_unknown set to ignore copes with unseen categories.; Machine Learning Crash Course · Taught in “Pipelines and ColumnTransformer”
Overfitting: When a model learns noise in its training data, so it scores far better on training rows than on new ones. The cure is less flexibility, more data or regularisation.; Machine Learning Crash Course · Taught in “Models in scikit-learn: fit, predict, score”
PCA (principal component analysis): A technique that finds new axes, each a weighted mix of the original columns, ordered by how much of the data’s variance they capture, so a few can summarise many.; Machine Learning Crash Course · Taught in “Clustering and PCA”
Pipeline: A scikit-learn object that chains preprocessing steps and a final model into one estimator, so every step is fitted on training data only and applied identically later.; Machine Learning Crash Course · Taught in “Pipelines and ColumnTransformer”
Precision and recall: Precision is the share of flagged cases that are truly positive; recall is the share of truly positive cases that get flagged. Raising one usually lowers the other.; Machine Learning Crash Course · Taught in “Classification Metrics Beyond Accuracy”
R² (coefficient of determination): The share of the target’s variance a regression explains compared with always predicting the mean: 1 is perfect, 0 is no better than the mean, and it can be negative.; Machine Learning Crash Course · Taught in “Linear Regression and Its Metrics”
Regularisation: Adding a penalty on coefficient size to the loss so the model prefers simpler fits. Ridge uses squared coefficients; Lasso uses absolute values and can set some to zero.; Machine Learning Crash Course · Taught in “Regularisation with Ridge and Lasso”
Residual: The difference between an actual value and the model’s prediction for it. Regression metrics such as MAE and RMSE summarise residuals.; Machine Learning Crash Course · Taught in “Linear Regression and Its Metrics”
ROC AUC: A threshold-free measure of ranking quality: the probability that a randomly chosen positive gets a higher score than a randomly chosen negative. 0.5 is random, 1.0 perfect.; Machine Learning Crash Course · Taught in “Classification Metrics Beyond Accuracy”
Supervised learning: Learning a mapping from features to a known target using labelled examples, so the model can predict the target for new cases. Classification and regression are its two main forms.; Machine Learning Crash Course · Taught in “Learning from Examples”
Target (label): The column a supervised model learns to predict, such as whether a customer churned. In scikit-learn it is usually called y.; Machine Learning Crash Course · Taught in “The Workflow and the Train/Test Split”
Train/test split: Holding back part of the labelled data, never used during training or model choice, to measure how well the final model works on unseen cases.; Machine Learning Crash Course · Taught in “The Workflow and the Train/Test Split”
Unsupervised learning: Finding structure in data that has no target column, such as groups of similar rows (clustering) or a compact summary of many columns (dimensionality reduction).; Machine Learning Crash Course · Taught in “Learning from Examples”