Programming & Web Development Glossary

Designing websites so everyone can use them, including people who use screen readers, keyboards only, or have low vision. "a11y" is short for the 11 letters between a and y. Learn more in HTML Accessibility.

A MongoDB feature that processes documents through a series of stages, such as filtering, grouping and sorting, to calculate totals and reports inside the database. See MongoDB Aggregation Basics.

AJAX lets browser JavaScript request data from a PHP server and update part of a page without a full navigation. See AJAX with PHP for examples and practice.

A step-by-step set of instructions for solving a problem, like a recipe. Sorting a list of names alphabetically uses an algorithm.

Application Programming Interface: a set of rules that lets one program talk to another. A weather website uses a weather API to get today's forecast. See JavaScript Fetch API.

The actual value you pass into a function when you call it. In greet("Ada"), "Ada" is the argument. Compare with parameter. See JavaScript Functions.

An ordered list of values stored in one variable, like ["red", "green", "blue"]. Each item has a numbered position called an index, starting from 0. See JavaScript Arrays.

A shorter way to write a function in JavaScript: const double = (n) => n * 2;. See Arrow Functions.

JavaScript keywords that let you write code that waits for slow tasks (like loading data) in a way that reads top-to-bottom. See Async/Await.

Extra information added to an HTML start tag, written as name="value". In <img src="cat.jpg" alt="A cat">, src and alt are attributes. See HTML Attributes.

The part of a website that runs on a server: databases, logins, payments. Users never see it directly. Compare with frontend. Backend code is often written in Python, PHP or Java, with data stored using SQL.

An HTML element that starts on a new line and stretches the full width available, like <p>, <h1> and <div>. See Block vs Inline.

A value that is either true or false. Used for yes/no decisions in code. See Booleans & Comparisons.

The way CSS treats every element as a box made of content, padding, border and margin. See CSS Box Model.

A separate line of work in a Git repository, so you can try changes without affecting the main version. See Git Branches.

The app you use to visit websites, such as Chrome, Firefox, Safari or Edge. It downloads HTML, CSS and JavaScript and turns them into the page you see.

A mistake in code that makes it behave in an unexpected way. Finding and fixing bugs is called debugging.

Authentication establishes a trusted principal, while authorization evaluates whether that principal may perform an operation on a resource. See C# Security: Authentication and Policies for worked examples and practice.

Attributes attach declarative metadata to code, and reflection inspects available runtime type and member information. See C# Reflection: Attributes and Metadata for worked examples and practice.

Configuration combines ordered key-value providers, while typed options bind and validate a feature's settings under an explicit lifetime policy. See C# Configuration: Options and Safe Secrets for worked examples and practice.

Date and time types distinguish calendar dates, clock readings, represented instants and elapsed durations. See C# Dates: Instants, Calendars and Time Zones for worked examples and practice.

A dependency-injection lifetime determines when a container creates, shares and disposes a service instance within its ownership scopes. See C# DI: Lifetimes, Scopes and Ownership for worked examples and practice.

Disposal releases explicitly owned resources at a defined boundary, independently of when managed memory is reclaimed. See C# Disposal: Ownership and Async Cleanup for worked examples and practice.

Entity Framework Core maps a model to a database and coordinates translated queries, tracked entities and explicit persistence operations. See C# EF Core: Queries, Tracking and Changes for worked examples and practice.

Equality defines whether values represent the same thing, while compatible hash codes enable correct hash-based lookup. See C# Equality: Hash Codes and Comparers for worked examples and practice.

An extension method is a static method callable with instance-like syntax when its namespace and receiver type are applicable. See C# Extensions: Methods and API Design for worked examples and practice.

Variance permits specific reference conversions between constructed interfaces or delegates while preserving type-safe producer and consumer contracts. See C# Variance: Covariance and Contravariance for worked examples and practice.

IHttpClientFactory configures client creation while managing handler lifetimes, so application code can express a bounded HTTP request contract. See C# HTTP: Clients, Cancellation and Testing for worked examples and practice.

An iterator produces a sequence incrementally, preserving its execution state between requests for the next element. See C# Iterators: Yield and Deferred Execution for worked examples and practice.

Namespaces organize type names, projects define compilation boundaries, and NuGet supplies versioned package dependencies. See C# Projects: Namespaces, References and NuGet for worked examples and practice.

A numeric conversion changes a value's numeric representation; parsing additionally interprets text under explicit formatting rules. See C# Conversions: Numbers, Parsing and Culture for worked examples and practice.

A regular expression describes a text-matching pattern, with explicit options and resource limits defining its matching behavior. See C# Regex: Validation, Groups and Timeouts for worked examples and practice.

Text processing separates mutable construction, Unicode representations and byte encodings so character meaning survives storage and transmission. See C# Text: Builders, Unicode and UTF-8 for worked examples and practice.

Structured logging records an event template and named values so diagnostics can be filtered and analyzed independently of rendered text. See C# Logging: Templates, Levels and Scopes for worked examples and practice.

Thread safety preserves a shared state's invariants under concurrent access through an explicit synchronization and ownership policy. See C# Thread Safety: Locks and Concurrent Data for worked examples and practice.

Array owns fixed-size elements, while span borrows contiguous storage with a fixed or dynamic extent. See C++ Arrays: Fixed Storage and Span Views for worked examples and practice.

Safe numeric conversion validates representation range, precision and domain rules before applying a cast. See C++ Conversions: Casts and Numeric Safety for worked examples and practice.

Chrono represents clock-specific time points and unit-aware durations, with C++20 civil-calendar facilities. See C++ Chrono: Clocks, Durations and Dates for worked examples and practice.

CMake declares a target dependency graph and generates a native build system, while reproducibility depends on controlled source, tools, dependencies and configuration. See C++ CMake: Targets and Reproducible Builds for worked examples and practice.

A concept names compile-time constraints, while requires expressions test whether selected expressions and types satisfy stated requirements. See C++ Concepts: Requirements and Constraints for worked examples and practice.

Const correctness expresses which operations may modify state through an access path and preserves that promise in interfaces. See C++ Const: Read-Only Interfaces and Pointers for worked examples and practice.

A debugging workflow reproduces a failure, inspects relevant state, fixes the cause and retains a check, while sanitizers detect selected instrumented runtime errors. See C++ Debugging: Tests and Sanitizer Evidence for worked examples and practice.

Friendship grants selected nonmembers or collaborators private access without changing membership or inheritance. See C++ Friends: Access and Encapsulation for worked examples and practice.

Invalidation ends the permitted use of a handle when a mutation changes storage, position or the referred element's lifetime. See C++ Iterators: Mutation and Invalidation for worked examples and practice.

List and deque supply distinct sequence storage contracts for node operations, endpoint access, traversal and handle validity. See C++ Containers: List and Deque Tradeoffs for worked examples and practice.

Multiple inheritance combines base subobjects, while virtual inheritance shares an applicable repeated base initialized by the most-derived class. See C++ Inheritance: Multiple Bases and Diamonds for worked examples and practice.

A random engine advances pseudorandom state, while a distribution maps it under a probability model. See C++ Random: Engines, Seeds and Distributions for worked examples and practice.

Ranges describe traversable sequences, and views provide composable range behavior whose storage and evaluation rules must be understood explicitly. See C++ Ranges: Views and Lazy Pipelines for worked examples and practice.

Scope controls name lookup, lifetime controls object existence, and linkage relates declarations across translation units. See C++ Scope: Namespaces and Linkage for worked examples and practice.

Special members define object lifecycle operations, and exception guarantees state which invariants or prior values survive a failed operation. See C++ Ownership: Special Members and Guarantees for worked examples and practice.

Container adaptors restrict access to LIFO, FIFO or heap-priority operations over underlying storage. See C++ Queues: Stack, FIFO and Priority Order for worked examples and practice.

String_view is a non-owning text window whose pointer and length do not extend the source's lifetime. See C++ String Views: Lifetime and Ownership for worked examples and practice.

Template deduction finds arguments from a declaration's pattern, specialization selects explicit implementations, and parameter packs represent variable template argument lists. See C++ Templates: Deduction and Parameter Packs for worked examples and practice.

Unordered containers organize keys under compatible equality and hashing without a sorted traversal-order promise. See C++ Hashing: Unordered Maps and Key Rules for worked examples and practice.

A saved copy of something so it can be loaded faster next time. Browsers cache images and files so pages you revisit load quickly.

A function you pass into another function so it can be called later, for example the function that runs when a button is clicked. See JavaScript Events.

The "C" in CSS. The set of rules that decides which style wins when several rules target the same element. See Specificity & the Cascade.

A reusable label you give to HTML elements with class="..." so CSS or JavaScript can target them as a group. See Classes and IDs.

A blueprint for creating objects that share the same properties and methods. See JavaScript Classes.

Command-Line Interface: a text-based way of controlling a computer by typing commands, also called the terminal.

A note in code that the computer ignores. Used to explain code to humans. HTML: <!-- note -->, CSS: /* note */, JavaScript: // note. See HTML Comments.

A saved snapshot of a project in Git, with a message describing what changed. See git add and commit.

A program that translates code written by humans into a form the computer can run. JavaScript in the browser doesn't need a separate compile step, but C++ and Java do.

A PHP MySQL connection establishes a database session using a driver, server address, credentials, database name, and connection policy. See Connecting PHP to MySQL for examples and practice.

A panel in the browser's developer tools where JavaScript can print messages with console.log(). Every example on this site has one built in. See JavaScript Output.

A variable whose value can't be reassigned, created with const in JavaScript. See JavaScript Variables.

Schema setup runs DDL to create databases and tables under controlled administrative privileges, usually through migrations rather than public requests. See Creating Databases and Tables with PHP for examples and practice.

Short for Create, Read, Update, Delete: the four basic things an app does with stored data. Most admin screens and web apps are CRUD at heart. See Building a CRUD App with PHP.

Cross-site request forgery: an attack where another website makes a logged-in user's browser submit a form to your site. Prevented with secret tokens in forms. See PHP Security Essentials.

Cascading Style Sheets: the language that controls how HTML looks, including colours, fonts, spacing and layout. Start the CSS tutorial.

A common table expression: a named step in an SQL query written with WITH, which makes long queries readable. Recursive CTEs can walk hierarchies. See SQL Common Table Expressions.

An organised store of data that programs can search and update, such as a list of users or products. SQL is the most common language for talking to databases. Start with the SQL introduction.

The process of finding and fixing bugs. Reading error messages, adding console.log() and testing small pieces are the main techniques.

A Python function that wraps another function to add behaviour, such as timing or caching, applied with @name above a definition. See Python Decorators.

Putting your website on a server so other people can visit it on the internet.

Developer tools built into every browser (press F12). They let you inspect HTML, edit CSS live, read the console and see network requests.

A database that stores records as flexible, JSON-like documents instead of rows in tables. MongoDB is the best-known example. See MongoDB Introduction.

Document Object Model: the browser's live, tree-shaped version of your HTML that JavaScript can read and change. See Selecting DOM Elements.

The human-friendly address of a website, like example.com.

A complete piece of HTML: a start tag, content and an end tag, like <p>Hello</p>. See HTML Elements.

A type with a fixed set of named values, such as Size.SMALL or Status::Shipped. Typos become errors instead of silent bugs. See Java Enums.

Something that happens in the browser that code can react to, such as a click, a key press or a form submission. See JavaScript Events.

An object that signals an error and interrupts the normal flow of a program until some code catches and handles it. See C++ Exceptions and Python Error Handling.

The most popular web framework for Node.js. It handles routes, requests, responses and middleware so you can build APIs quickly. See Express Basics.

A CSS layout system for arranging items in a row or column, with easy alignment and spacing. See CSS Flexbox.

A ready-made structure of code that helps you build apps faster by following its conventions. React, Vue and Angular are JavaScript frameworks.

Everything users see and interact with in the browser, built with HTML, CSS and JavaScript. Compare with backend.

A named, reusable block of code that performs a task. You define it once and call it whenever you need it. See JavaScript Functions.

A Python function that uses yield to produce values one at a time, pausing between them, so it can handle huge data with little memory. See Python Iterators and Generators.

Classes and methods written with a type placeholder, like List<T>, so one piece of code works safely with many types. See Java Generics.

A version control tool that records every change to your code so you can go back in time and work with others safely. Learn it in the Git tutorial.

HEAD identifies the current checkout, usually through a branch reference; revision syntax selects commits, parents, paths and ranges precisely. See Git HEAD: Detached States and Revision Syntax for worked examples and practice.

A script Git runs automatically at certain moments, such as before a commit or a push, often used to check code. See Git Hooks.

Git LFS stores small pointer files in Git while managing the referenced large-file content through separate LFS object storage. See Git LFS: Track Large Files and Verify Objects for worked examples and practice.

Partial staging selects specific changes for the index so the next commit records a focused snapshot while other edits remain in the working tree. See Git Partial Staging: Build Focused Commits for worked examples and practice.

A patch describes changes between file versions; Git can apply raw diffs to files or import mailbox-style patches as a series of new commits. See Git Patches: Apply Changes and Transfer Commits for worked examples and practice.

A refspec maps source and destination references; an explicit push lease allows a remote ref update only if its current value matches a named expected object. See Git Remote Refs: Fetch Rules and Safe Leases for worked examples and practice.

A Git bundle packages selected references and Git objects for offline transfer, potentially requiring prerequisite commits already available at the destination. See Git Bundles: Offline History and Verification for worked examples and practice.

Git rerere records how a conflict was resolved and can reuse that resolution when a corresponding conflict appears again. See Git Rerere: Reuse Reviewed Conflict Resolutions for worked examples and practice.

Sparse checkout limits which tracked paths appear in a working tree; partial clone limits which Git objects are initially downloaded and can fetch omitted objects later. See Git Sparse Checkout: Select Paths and Objects for worked examples and practice.

Git SSH signing associates a commit or annotated tag with a cryptographic key; an allowed-signers policy supplies the identities trusted during verification. See Git Signing: Verify Commits and Release Tags for worked examples and practice.

A .gitattributes file assigns path-based rules for content handling, including text normalization, checkout line endings and filters. See Git Attributes: Line Endings and File Rules for worked examples and practice.

A website that hosts Git repositories online and adds tools for working together, such as pull requests and issues. See the GitHub tutorial.

A cache reuses eligible files to speed later work; an artifact stores a produced result that jobs or reviewers can retrieve explicitly. See GitHub Actions: Cache Inputs and Share Artifacts for worked examples and practice.

Actions contexts supply workflow data to expression evaluation; runner environment variables and explicit outputs carry values during and between job execution. See GitHub Actions: Contexts, Expressions and Outputs for worked examples and practice.

Actions permissions bound token capabilities; event choice and code provenance determine whether a job executes trusted automation or untrusted contribution content. See GitHub Actions: Token Permissions and Fork Trust for worked examples and practice.

A CODEOWNERS file maps repository paths to eligible reviewers; a separate repository rule can require code-owner approval before merging. See GitHub CODEOWNERS: Route and Require Reviews for worked examples and practice.

GHCR stores container packages with their own access policy; a digest identifies image content while a tag is a human-readable reference that can move. See GitHub Packages: Container Publishing and Digests for worked examples and practice.

An Actions job can request a short-lived OIDC identity token; a provider verifies it and applies a trust policy that can restrict the repository and environment. See GitHub Deployment: Environments and OIDC Trust for worked examples and practice.

An issue form gathers structured reporter input before creating an editable issue; triage then assesses completeness, reproducibility and the appropriate next action. See GitHub Issue Forms: Reproduction and Triage for worked examples and practice.

GitHub REST pagination exposes additional result pages through response links; clients should follow the next relation with explicit origin, size and traversal limits. See GitHub REST API: Pagination and Rate Limits for worked examples and practice.

A reusable workflow declares workflow_call inputs, optional secrets and outputs so another workflow can call its jobs through an explicit interface. See GitHub Reusable Workflows: Inputs and Contracts for worked examples and practice.

Rulesets enforce repository constraints; a merge queue tests eligible changes against the target branch and queued changes before merging them. See GitHub Rulesets: Reviews, Checks and Merge Queues for worked examples and practice.

A CSS layout system for two-dimensional layouts, with rows and columns at once. See CSS Grid.

A one-way, scrambled version of a password. Websites store the hash, never the password, and check logins by hashing what was typed. See Building a Login System in PHP.

HyperText Markup Language: the language that describes the content and structure of web pages. Start the HTML tutorial.

The protocol browsers use to request web pages from servers. HTTPS is the secure, encrypted version; look for the padlock in the address bar.

Integrated Development Environment: a code editor with extra tools such as debugging and autocomplete. VS Code is a popular choice. See HTML Editors.

The numbered position of an item in an array or string. In JavaScript, indexes start at 0, so the first item is at index 0.

An HTML element that sits inside a line of text without starting a new line, like <a>, <strong> and <span>. See Block vs Inline.

A constructor initializes a new object and has the same name as its class. It has no declared return type, including void. A constructor can validate required state. Rejecting an invalid duration during creation prevents an object from starting in a broken condition. See the Java lesson for an original example and practice questions.

Dynamic programming reuses solutions to overlapping subproblems. It works when a larger result can be expressed through smaller states with an appropriate recurrence. Memoization caches results in a top-down recursive solution. Tabulation fills states in a bottom-up order that respects dependencies. See the Java lesson for an original example and practice questions.

Encapsulation groups related data and operations while controlling access to internal state. It protects the rules that make an object valid. Private fields are useful, but unrestricted setters can still expose every state change. Provide operations such as bookSeat when that better represents the domain. See the Java lesson for an original example and practice questions.

ExecutorService separates task submission from the threads that execute tasks. A fixed-size pool reuses a bounded number of worker threads. submit can return a Future holding a result or task failure. get waits for completion and wraps a task exception in ExecutionException. See the Java lesson for an original example and practice questions.

A functional interface has one abstract method after the relevant inheritance rules are applied. @FunctionalInterface lets the compiler verify the intended contract. Predicate tests a value, Function transforms it, Consumer performs an action, and Supplier provides a value without an input. See the Java lesson for an original example and practice questions.

Generics parameterize a type or method with reference types. Box<String> and Box<Integer> share a definition while providing different compile-time checks. Generic type arguments cannot be primitive types. Use Integer rather than int. Avoid raw types because they bypass useful type checking. See the Java lesson for an original example and practice questions.

A named module declares its identity in module-info.java. requires states a module dependency, while exports exposes selected packages to other modules. Public classes in an unexported package remain encapsulated from ordinary access by other named modules. Public visibility alone does not cross every module boundary. See the Java lesson for an original example and practice questions.

Optional represents either one non-null value or no value. It is commonly useful as a method return type when absence is an expected outcome. of requires a non-null value, ofNullable accepts a possibly null reference, and empty represents absence. See the Java lesson for an original example and practice questions.

Polymorphism lets a common reference type refer to different implementations. Calling an overridden instance method chooses behavior from the actual object type. Overriding replaces inherited instance behavior with a compatible method. @Override asks the compiler to catch accidental signature mistakes. See the Java lesson for an original example and practice questions.

A race condition occurs when correctness depends on an uncontrolled ordering of concurrent operations. count++ is a read-modify-write sequence rather than one automatically atomic action. synchronized protects a block or method with a monitor. All competing operations must use the same relevant lock for the intended protection. See the Java lesson for an original example and practice questions.

Try-with-resources closes declared AutoCloseable resources when the block finishes. Cleanup happens on successful and exceptional exits. Resources are closed in reverse declaration order. This is useful when one resource wraps another and should finish before the underlying resource closes. See the Java lesson for an original example and practice questions.

Widening conversions usually happen automatically, such as int to long. Some widening conversions to floating point can still lose precision for sufficiently large values. Narrowing conversions need an explicit cast, such as double to int. Casting a finite in-range decimal to int drops its fractional part rather than rounding to the nearest integer. See the Java lesson for an original example and practice questions.

The programming language of the web. It makes pages interactive: reacting to clicks, updating content and loading data. Start the JavaScript tutorial.

Combining rows from two tables using a related column, such as orders with their customers. See SQL Joins and More SQL Joins.

JavaScript Object Notation: a text format for storing and sending data, like {"name": "Ada", "age": 36}. Most APIs use it. See JavaScript JSON.

A fixed-size indexed container whose elements may change; primitive-array types store specialized numeric or Boolean values. See Kotlin Arrays: Primitive and Nested Arrays for worked examples and practice.

A policy governing how a producer responds when downstream processing cannot keep pace. See Kotlin Flow: Buffering and Sharing Lifetime for worked examples and practice.

A property whose access behavior is supplied by another object through Kotlin delegation conventions. See Kotlin Delegated Properties: lazy and lateinit for worked examples and practice.

Kotlin-based Gradle configuration scripts defining plugins, dependencies, toolchains and tasks. See Kotlin Gradle: Kotlin DSL and Dependencies for worked examples and practice.

The requirement that equal values have equal hash codes while equality-relevant key state stays stable during collection use. See Kotlin Equality: hashCode and Stable Map Keys for worked examples and practice.

A function whose body and eligible lambda arguments can be substituted into call sites by compilation. See Kotlin Inline Functions: Returns and Modifiers for worked examples and practice.

A nested class marked inner that retains access to an instance of its enclosing class. See Kotlin Nested Classes: inner and Outer State for worked examples and practice.

A time value identifying a point on the global timeline, interpreted through a zone only when local fields are needed. See Kotlin JVM Time: Dates, Instants and Zones for worked examples and practice.

An implementation technique using by to forward an interface contract to a supplied delegate object. See Kotlin Delegation: Interfaces with by for worked examples and practice.

A nonreentrant mutual-exclusion primitive whose acquisition can suspend a coroutine while protecting cooperating state access. See Kotlin Shared State: Mutex and Atomic Updates for worked examples and practice.

An operator-marked function implementing a predefined Kotlin symbolic operation convention. See Kotlin Operators: Overloading Custom Types for worked examples and practice.

A Kotlin view of a Java type whose usable nullability contract is not fully specified at the language boundary. See Kotlin Java Interop: Platform Types and APIs for worked examples and practice.

A compiled regular expression used to recognize, search, capture or replace text according to a pattern. See Kotlin Regex: Matching and Safe Text Parsing for worked examples and practice.

A synchronous producer abstraction that evaluates elements lazily through iteration. See Kotlin Sequences: Lazy Collection Pipelines for worked examples and practice.

Conversion between typed application models and an external representation such as JSON. See Kotlin Serialization: JSON Models and Validation for worked examples and practice.

A compiler-supported narrowing of a value type when stable control-flow evidence makes the narrower type safe. See Kotlin Type Checks: Safe Casts and Smart Casts for worked examples and practice.

A coroutine failure policy that isolates sibling child failures while preserving ownership by the parent scope. See Kotlin Coroutines: Supervision and Cleanup for worked examples and practice.

A declaration rule controlling where a Kotlin member or top-level declaration can be accessed. See Kotlin Packages: Imports and Visibility for worked examples and practice.

A small function without a name, written right where it's needed, often passed to sorting or filtering functions. See C++ Algorithms and Lambdas and Java Lambdas and Streams.

A collection of pre-written code you can use in your project, like a toolbox. Unlike a framework, you decide when to use it.

Language Integrated Query: a set of C# methods such as Where, Select and GroupBy for filtering and transforming collections in readable chains. See C# LINQ.

Code that repeats a set of instructions, for example once for every item in a list. See JavaScript For Loops.

A CSS rule that applies styles only when a condition is true, like "screen is narrower than 600px". The key to responsive design. See CSS Media Queries.

What happens when two Git branches change the same lines differently, so you must choose the right version yourself. See Git Merge.

An HTML tag in the <head> that gives information about the page, such as its description, character set or viewport settings. See HTML Head & Meta Tags.

A function that belongs to an object or value. In "hello".toUpperCase(), toUpperCase is a string method. See String Methods.

A function that runs between receiving a request and sending a response, used for logging, security checks, parsing data and more. See Express Middleware.

Records declare transparent data carriers with generated accessors, equality, hash code and a readable toString. Their component fields are final, but mutable component objects still need care. Sealed classes and interfaces restrict which direct types may extend or implement them. Permitted subclasses must follow the relevant final, sealed or non-sealed rules. See the Java lesson for an original example and practice questions.

A separate JavaScript file that exports pieces of code so other files can import them. See JavaScript Modules.

bulkWrite submits multiple write models with an ordering policy and reports successes and per-operation failures without making the whole batch automatically atomic. See MongoDB Bulk Writes: Ordering and Errors for worked examples and practice.

A change stream exposes qualifying database changes from a replica set or sharded deployment, with opaque tokens supporting documented resumption. See MongoDB Change Streams: Resume and Processing for worked examples and practice.

Collation supplies locale-aware string comparison rules that affect equality, sorting, and compatible index use. See MongoDB Collation: Comparison and Index Matching for worked examples and practice.

Keyset pagination selects rows after the last returned ordering tuple instead of skipping a growing number of earlier rows. See MongoDB Pagination: Compound Keyset Cursors for worked examples and practice.

A cursor is a stateful handle to query results that retrieves batches and advances as the application consumes documents. See MongoDB Cursors: Batches and Cleanup for worked examples and practice.

BSON Date stores an instant, while timezone-aware aggregation expressions interpret that instant under the reporting calendar chosen by the application. See MongoDB Dates: Timezones and Daily Buckets for worked examples and practice.

densify adds missing sequence positions to aggregation output, while fill supplies missing or null field values under an explicit interpolation policy. See MongoDB Gaps: Densify and Fill Missing Values for worked examples and practice.

The Node driver manages per-server connection pools and separate waiting, connection, selection, and execution limits under an application lifecycle. See MongoDB Driver: Pools, Timeouts, and Shutdown for worked examples and practice.

Geospatial queries evaluate locations and geometries using documented spatial operators and suitable indexes rather than ordinary numeric comparisons. See MongoDB Geospatial: GeoJSON and Nearby Queries for worked examples and practice.

GridFS stores a file as chunk documents plus a metadata document and exposes streaming upload and download through supported drivers. See MongoDB GridFS: Upload, Download, and Versions for worked examples and practice.

A materialized summary stores aggregation results and needs an explicit identity, refresh, stale-row, and publication policy beyond the merge stage itself. See MongoDB Merge: Materialized Refresh Policies for worked examples and practice.

A multikey index creates index entries from array values and follows specialized compound, bounds, coverage, and uniqueness rules. See MongoDB Multikey: Array Bounds and Uniqueness for worked examples and practice.

A missing field has no stored value, while null is a stored BSON value; MongoDB equality-to-null queries can match both. See MongoDB Null: Missing Fields and Exact Types for worked examples and practice.

Optimistic concurrency accepts an update only when the stored version still matches the version the editor read, then advances that version atomically. See MongoDB Concurrency: Versioned Update Filters for worked examples and practice.

A standard MongoDB view is a stored read pipeline over source data whose results are computed when queried rather than stored as an independent writable collection. See MongoDB Views: Read-Only Query Interfaces for worked examples and practice.

A native time-series collection groups timestamped measurements by stable metadata into MongoDB-managed storage buckets. See MongoDB Time Series: Metadata and Retention for worked examples and practice.

A wildcard index indexes values under varying document field paths within its configured scope, helping queries on flexible schemas. See MongoDB Wildcard Indexes: Dynamic Field Paths for worked examples and practice.

Window functions compute values across an ordered partition while retaining individual rows rather than collapsing them into group summaries. See MongoDB Windows: Running Totals and Ranking for worked examples and practice.

In C++, transferring an object's resources, such as its memory, to another object instead of copying them, which makes code much faster. See C++ Move Semantics.

A runtime that runs JavaScript outside the browser, on servers and computers, for building APIs, real-time apps and tools. See Node.js Introduction.

AsyncLocalStorage associates a store with an asynchronous execution scope so supported descendant work can retrieve contextual data without a global current-request variable. See Node.js AsyncLocalStorage: Request Context for worked examples and practice.

A bounded upload enforces input and storage limits while keeping client metadata separate from server-controlled filenames and accepted content rules. See Node.js Uploads: Byte Limits and Safe Storage for worked examples and practice.

A Buffer is a fixed-length sequence of bytes with methods for binary values and explicit text encodings. See Node.js Buffer: Bytes and UTF-8 for worked examples and practice.

Compression transforms bytes into a smaller encoded representation whose format and resource limits must be agreed by producer and consumer. See Node.js Compression: Brotli and HTTP Bodies for worked examples and practice.

diagnostics_channel connects optional synchronous instrumentation subscribers to named publication points without making those observers the application workflow. See Node.js Diagnostics: Optional Instrumentation for worked examples and practice.

lookup resolves names through operating-system facilities, while resolve methods query DNS servers for particular record types. See Node.js DNS: Lookup and Resolver Queries for worked examples and practice.

fetch returns an HTTP Response whose status and single-use body need explicit handling, while AbortSignal supplies cancellation to supported request processing. See Node.js Fetch: Bodies, Cancellation, Retries for worked examples and practice.

HTTP/2 multiplexes request-response streams within a session, using its own headers, flow control, and lifecycle rules. See Node.js HTTP/2: Sessions and Streams for worked examples and practice.

HTTPS carries HTTP over TLS, verifying certificate trust and the requested hostname before accepting an authenticated server connection. See Node.js HTTPS: TLS Trust and Hostnames for worked examples and practice.

An HMAC authenticates exact message bytes using a shared secret; a plain hash detects changes only when its expected digest is trusted. See Node.js Crypto: Integrity and Webhook HMAC for worked examples and practice.

A readline interface coordinates line-oriented input and prompts, with promise-based questions for sequential interactive command-line workflows. See Node.js Readline: Interactive CLI Questions for worked examples and practice.

Native type stripping removes erasable TypeScript syntax before execution; it does not perform type checking or act as a full TypeScript compiler. See Node.js TypeScript: Native Type Stripping for worked examples and practice.

The Node permission model restricts selected resource APIs for trusted code under explicit startup grants; it is not a sandbox for hostile JavaScript. See Node.js Permissions: Explicit Resource Grants for worked examples and practice.

Package exports declares supported external entry points; package imports declares private specifier mappings beginning with # inside that package. See Node.js Packages: Exports and Import Maps for worked examples and practice.

Message framing defines application message boundaries on TCP, which delivers an ordered byte stream rather than individual messages. See Node.js TCP: Connections and Message Framing for worked examples and practice.

Timers schedule eligible future callbacks, while microtasks and nextTick callbacks run at their defined scheduling boundaries rather than after a precise clock delay. See Node.js Timers: Phases and Microtasks for worked examples and practice.

The URL API parses structured addresses, while URLSearchParams manages their encoded query name-value pairs. See Node.js URL: Parsing and Query Parameters for worked examples and practice.

Web Streams provide readable, writable, and transform interfaces shared by browser-style APIs, with Node adapters bridging traditional Node streams. See Node.js Web Streams: Transform and Interop for worked examples and practice.

Organising database tables so each fact is stored in exactly one place, which prevents contradictory data. See Database Normalization.

Two JavaScript values that mean "nothing". undefined means a value was never set; null means it was deliberately set to empty. See Data Types.

Language features that stop a program from using a missing value by accident, by making "might be missing" part of the type, such as String? in Kotlin, Swift and C#. See Kotlin Null Safety.

A collection of related data stored as pairs of keys and values, like { name: "Biscuit", age: 3 }. See JavaScript Objects.

A symbol that performs an action on values, such as +, === or &&. See JavaScript Operators.

In Swift, a type that may hold a value or nil, written with a question mark such as String?. You unwrap it safely with if let, guard let or ??. See Swift Optionals.

A named placeholder in a function definition that receives a value when the function is called. In function greet(name), name is a parameter.

A parameterized query separates SQL structure from supplied values so those values cannot become additional SQL syntax. See Parameterized Queries and SQL Injection Prevention for examples and practice.

A non-instantiable base that can share implementation and require concrete subclasses to implement compatible methods. See PHP Abstract Classes: Contracts and Shared Code for examples and practice.

File permissions control filesystem access; reliable PHP file handling also checks paths, operation failures, and concurrent changes. See Advanced File Handling and File Permissions for examples and practice.

Operations that order keys or values, preserve or reset keys and optionally apply a custom three-way comparator. See PHP Array Sorting: Keys, Values and Comparators for examples and practice.

A single-expression Closure written with fn that returns its expression and automatically captures referenced outer variables by value. See PHP Arrow Functions: Syntax and Capture for examples and practice.

PHP-supplied APIs for common tasks whose accepted inputs, return values, mutation and failure behavior form a contract. See PHP Built-in Functions: Practical Reference for examples and practice.

Callable behavior passed to another operation; an anonymous Closure can capture selected surrounding values. See PHP Callbacks: Anonymous Functions and Closures for examples and practice.

A fixed class-owned value accessed with double-colon syntax and governed by visibility and inheritance rules. See PHP Class Constants: Visibility and Inheritance for examples and practice.

Composer resolves package requirements and records exact installed versions in a lockfile for repeatable dependency installation. See Composer Dependencies and Version Constraints for examples and practice.

php.ini and related runtime configuration set PHP extension loading, limits, error behavior, and environment-specific execution policy. See PHP Configuration and php.ini for examples and practice.

A named fixed value declared with const or define(), available after declaration without a dollar sign. See PHP Constants: const and define() for examples and practice.

Object lifecycle hooks for initialization and eventual cleanup; critical persistence and cleanup need explicit observable operations. See PHP Constructors: Initialization and Destructors for examples and practice.

CSV processing uses a CSV parser to preserve quoted fields, validates rows, and converts accepted values into application data. See CSV Processing for examples and practice.

A connection policy defines configuration, privileges, transport, lifecycle, and error handling for every database session. See PHP Database Connection Best Practices for examples and practice.

Database error handling separates expected data conflicts from infrastructure failures and records diagnostics without exposing secrets. See Database Error Handling for examples and practice.

Deployment installs a reviewed application artifact into a configured runtime and verifies that code, schema, secrets, and services are compatible. See Deployment and Production Configuration for examples and practice.

PHP email code hands a message to a configured transport; acceptance by that transport does not prove delivery to the recipient. See Email Sending and Mail Configuration for examples and practice.

Enums constrain a value to declared cases; readonly protects an initialized property binding without deep-freezing nested objects. See PHP Enums: Cases and Readonly Properties for examples and practice.

Environment-based configuration supplies deployment-specific values separately from code; a .env file requires an explicit loader and protection. See Environment Variables and .env Configuration for examples and practice.

Error reporting selects which diagnostics PHP reports, while logging records safe operational evidence without exposing it to visitors. See Error Reporting and Logging for examples and practice.

A secure upload flow checks upload status, permitted content and size, then stores a generated file where it cannot execute. See File Upload Security and MIME-Type Validation for examples and practice.

PHP filters validate a value against a rule or transform its representation; validation does not replace output escaping. See PHP Filters and Validation Filters for examples and practice.

HTTP headers describe a response and its status before the body, including content type, caching, redirection, and download behavior. See HTTP Headers, Redirects and Response Codes for examples and practice.

The ++ and -- operations change a writable numeric value by one; prefix and postfix produce different expression results. See PHP Increment: Prefix and Postfix Operators for examples and practice.

Two common shapes of PHP ordered maps: positional lists and keyed records or lookup maps. See PHP Arrays: Indexed vs Associative for examples and practice.

MySQLi CRUD runs create, read, update, and delete row operations through a MySQL-specific PHP connection. See Insert, Select, Update and Delete with MySQLi for examples and practice.

PHP interview practice combines language reasoning, safe application design, and small coding tasks whose behavior can be explained and tested. See PHP Interview Questions and Coding Exercises for examples and practice.

Language constructs for checking non-null presence, checking false-like emptiness and removing a variable binding or array entry. See PHP isset, empty and unset: Value Checks for examples and practice.

An iterable supports foreach; a Generator produces values lazily through yield and retains traversal state. See PHP Iterables: Generators and Lazy Processing for examples and practice.

An interface exposing deliberate object traversal through a Traversable returned by getIterator(), often with a fresh cursor per pass. See PHP Object Iteration: Iterator and Aggregates for examples and practice.

A last-insert-ID API reports a generated key associated with the same database session; batch insertion needs an explicit result and transaction policy. See Last Insert ID and Multiple Inserts for examples and practice.

Class-context resolution in which static follows the called class while self refers to the declaring implementation. See PHP Late Static Binding: self vs static for examples and practice.

Live search requests bounded results as a user types and must coordinate input timing, query safety, and response ordering. See PHP Live Search with AJAX for examples and practice.

A PHP-supplied source-context value such as __DIR__, __FILE__ or __METHOD__ that depends on where it appears. See PHP Magic Constants: File and Code Context for examples and practice.

A documented double-underscore method PHP invokes during a specific object operation such as virtual access, string conversion or invocation. See PHP Magic Methods: __get, __set and __call for examples and practice.

A PHP 8 expression that uses strict comparison to select one result and throws when no arm handles the value. See PHP switch vs match: Comparison and Branching for examples and practice.

Built-in numeric operations for rounding, division, bounds and other calculations, with integer and floating-point limits. See PHP Numbers: Math Functions and Rounding for examples and practice.

An array containing other arrays, commonly used for lists of records, keyed collections or nested configuration trees. See PHP Multidimensional Arrays: Common Operations for examples and practice.

MySQLi is a MySQL-specific PHP API, while PDO provides a common access interface through database-specific drivers. See MySQLi vs. PDO for examples and practice.

A file-local imported name mapping that shortens a qualified symbol name without loading its source or changing its identity. See PHP Namespaces: Imports, Aliases and Resolution for examples and practice.

Operators that supply defaults for missing or null values and short-circuit optional object access when an object is null. See PHP Null Operators: Coalescing and Nullsafe for examples and practice.

Cloning creates a shallow independent outer instance; triple-equals checks shared instance identity while equality compares current values. See PHP Object Cloning: Copies and Comparison for examples and practice.

Pagination splits ordered query results into bounded pages; stable ordering and a defined search policy prevent inconsistent navigation. See Pagination and Search with SQL for examples and practice.

OPcache caches compiled PHP bytecode; application performance still depends on database, network, memory, and workload behavior. See PHP Performance and OPcache Basics for examples and practice.

A MySQLi prepared statement separates SQL structure from bound values and can execute repeatedly with new variable values. See Prepared Statements with MySQLi for examples and practice.

PSR-4 maps a namespace prefix to directories so an autoloader can locate class files consistently. See PSR Standards and Autoloading for examples and practice.

Always-accessible arrays providing server metadata, configured request sources and environment values, each requiring appropriate validation. See PHP Superglobals: $_SERVER, $_REQUEST and $_ENV for examples and practice.

A PHP security checklist reviews application trust boundaries and tests controls for input, authorization, output, storage, and deployment. See PHP Security Checklist for examples and practice.

A class-level method or property; static methods have no current instance and mutable static state has a runtime-dependent lifetime. See PHP Static Members: Methods and Properties for examples and practice.

A conditional expression that selects one of two values; short ternary uses truthiness while null coalescing uses null or absence. See PHP Ternary: Shorthand If and Defaults for examples and practice.

Trait adaptations choose competing method implementations with insteadof and add alternate names or visibility with as. See PHP Traits: Sharing Code and Resolving Conflicts for examples and practice.

A PDO transaction groups supported database changes so they commit together or roll back together under the engine's isolation rules. See Transactions with PDO for examples and practice.

A language-level contract for parameter, property or return types that complements domain validation and per-file strict typing. See PHP Type Declarations: Parameters and Returns for examples and practice.

A unit test checks a focused piece of PHP behavior with explicit assertions under a repeatable test environment. See Unit Testing with PHPUnit for examples and practice.

The boundary determining where a variable is available, including local function scopes, global access and retained static locals. See PHP Variable Scope: Locals and $GLOBALS for examples and practice.

Variadic parameters collect remaining arguments, while PHP 8 named calls select parameters explicitly by their public names. See PHP Arguments: Variadic and Named Calls for examples and practice.

PHP's Expat-style XML parser emits element and character-data events so code can process a document without building a full tree. See XML Parsing with Expat for examples and practice.

The DOM represents XML as document, element, attribute, and text nodes that PHP can inspect, edit, and serialize. See XML Processing with DOM for examples and practice.

SimpleXML presents an XML document as a traversable object tree for reading elements, attributes, and namespace-aware paths. See XML Processing with SimpleXML for examples and practice.

A C++ variable that holds the memory address of another value instead of the value itself. See C++ Pointers.

A column, usually id, whose value is unique for every row in a database table. Other tables use it to refer to that row. See SQL Introduction.

A JavaScript object that represents a value you'll get later, such as data from a server. See JavaScript Promises.

A named value inside an object (dog.name), or in CSS, the thing you're styling (color, margin). See CSS Syntax.

A CSS keyword that targets an element in a particular state, like :hover or :first-child. See CSS Pseudo-classes.

A proposal on GitHub to merge one branch into another, where teammates can review and discuss the changes first. See GitHub Pull Requests.

A popular, readable programming language used for automation, data analysis, websites and machine learning. Start with the Python tutorial.

A protocol that pairs entry and exit work around a with block, often ensuring resource cleanup. Read the Python lesson.

A procedure that repeatedly fits on selected training folds and evaluates on their held out counterparts. Read the Python lesson.

Information from held out observations influencing model fitting, preprocessing or choices and making evaluation misleading. Read the Python lesson.

A reusable test dependency with a defined setup, lifetime and cleanup policy. Read the Python lesson.

A value with a hash that remains stable while used as a key and an equality contract compatible with that hash. Read the Python lesson.

An object that supplies successive values through next and signals completion with StopIteration. Read the Python lesson.

The singleton commonly used to mark the absence of a meaningful value. Read the Python lesson.

Attribute style access implemented by getter, setter or deleter methods, often used to validate state. Read the Python lesson.

Solving a problem through a function calling itself on smaller cases until a base case completes. Read the Python lesson.

A new outer container whose nested objects can still be shared with the original. Read the Python lesson.

An annotation expressing an expected type for readers and static analysis tools; it does not normally enforce runtime validation. Read the Python lesson.

A project environment with its own installed packages and interpreter related configuration. Read the Python lesson.

A Git operation that replays your branch's commits on top of another branch, giving a straight, linear history. See Git Rebase.

A compact, immutable Java class for holding data, which generates its constructor, accessors, equals and toString automatically. See Java Records.

When a function solves a problem by calling itself on a smaller version of it, stopping at a simple base case. See C++ Recursion.

A pattern that describes the shape of text, such as "three digits then a dash", used to search, validate and replace text. See Python Regular Expressions and PHP Regular Expressions.

A group of MongoDB servers that keep copies of the same data, so the database keeps working if one server fails. See MongoDB Replication.

A project folder tracked by Git, including its full history of commits. Often shortened to "repo". See GitHub Repositories.

Building pages that adapt to any screen size, from phones to big monitors. See CSS Media Queries.

A style of web API where each kind of data has its own address and HTTP methods like GET, POST and DELETE say what to do with it, usually exchanging JSON. See Building a REST API in PHP.

A filter an optimizer can use effectively as a search argument for a suitable access path, such as a direct range on an indexed value. See SQL Query Optimization and Index Selection for examples and practice.

Where in your code a variable can be used. A variable created inside a function can't be used outside it. See JavaScript Scope.

The part of a CSS rule that chooses which HTML elements to style, like h1, .card or #menu. See CSS Selectors.

Using HTML elements that describe their meaning, such as <nav>, <article> and <button>, instead of generic boxes. It helps accessibility and SEO. See Semantic Elements.

Search Engine Optimisation: making pages easy for search engines to understand and rank. Good headings, meta descriptions and semantic HTML all help. See HTML Head & Meta Tags.

A computer that stores websites and sends them to browsers when they ask. Server-side languages such as PHP build pages there before they are sent.

How CSS decides which rule wins when two rules target the same element. IDs beat classes, classes beat element names. See Specificity.

Structured Query Language: the language used to read and change data in relational databases. See the SQL tutorial.

Ordinary aggregation collapses rows into groups, while a window function calculates across related rows and keeps the individual result rows. See SQL Aggregates vs Windows: Rows and Groups for examples and practice.

An SQL alias gives a column expression or table reference a temporary name within a query without renaming the stored database object. See SQL Aliases: Column and Table Names for examples and practice.

An anti-join returns rows from one input that have no qualifying match in another, commonly expressed with NOT EXISTS or LEFT JOIN and a missing-key test. See SQL Anti-Joins: Find Unmatched Records for examples and practice.

A database trigger that records selected data changes automatically; its transaction behavior and access controls determine what history it preserves. See SQL Triggers and Their Use Cases for examples and practice.

Generated identity columns assign identifier values during insertion using an engine-specific mechanism such as AUTO_INCREMENT, identity or an SQLite integer primary key. See SQL Generated IDs: AUTO_INCREMENT and Identity for examples and practice.

AVG() calculates the arithmetic mean of non-NULL input values, with a denominator equal to the number of known values. See SQL AVG(): Means, NULL and Weighted Averages for examples and practice.

Business SQL problems require translating metric definitions, record relationships and completeness rules into queries that can be reconciled with their source events. See SQL Business Problems: Revenue and Reconciliation for examples and practice.

CAST converts an expression to a specified type; CONVERT provides database-specific conversion features whose syntax and meaning vary. See SQL CAST and CONVERT: Types and Precision for examples and practice.

COALESCE returns the first non-NULL expression, while NULLIF returns NULL when its two expressions compare equal. See SQL NULL Handling: COALESCE and NULLIF for examples and practice.

SQL coding challenges practise transforming a precise result requirement into a query and validating it with deliberately chosen edge-case records. See SQL Coding Challenges: Deduplication and Ranking for examples and practice.

A common table expression, or CTE, names a query result with WITH so it can be used within the single statement that follows. See SQL CTEs: WITH, Scope and Query Stages for examples and practice.

An index on several columns in a defined order; its leading columns and query conditions influence which access paths it can support. See SQL Index Types and Composite Indexes for examples and practice.

Conditional aggregation applies CASE inside an aggregate to calculate selected categories or measures in one grouped query. See SQL Conditional Aggregation: SUM and CASE for examples and practice.

A correlated subquery references a value from an enclosing query, making its logical result depend on the current outer row. See SQL Correlated Subqueries: Outer-Row Values for examples and practice.

COUNT(*) counts input rows, COUNT(expression) counts rows with a non-NULL expression, and COUNT(DISTINCT expression) counts different known values. See SQL COUNT(): Rows, NULL and DISTINCT for examples and practice.

CREATE DATABASE creates a database container in a server system; DROP DATABASE removes that container and its data, with permissions and syntax depending on the engine. See SQL Databases: CREATE, DROP and Dialects for examples and practice.

CREATE TABLE defines a new table, ALTER TABLE changes an existing definition, and DROP TABLE removes the table object and its stored rows. See SQL Tables: CREATE, ALTER and DROP for examples and practice.

Data cleaning applies documented corrections, while deduplication identifies equivalent records and selects survivors under a reviewed rule. See SQL Data Cleaning and Deduplication for examples and practice.

Data integrity keeps stored facts valid; referential integrity requires non-null references to match permitted parent keys. See Data Integrity and Referential Integrity for examples and practice.

A data type defines how a column represents values and which ranges, comparisons and calculations are appropriate for those values. See SQL Data Types: Numbers, Text and Dates for examples and practice.

A database backup is a recoverable copy under a defined consistency and retention policy; restoration tests prove whether recovery works. See Database Backup and Restore Basics for examples and practice.

A cycle in which transactions wait for resources held by one another, commonly resolved by aborting a participant and safely retrying its operation. See SQL Deadlocks and Locking for examples and practice.

Requirements-driven database design translates business facts and rules into entities, keys, relationships, and enforceable constraints. See Database Design from Requirements for examples and practice.

Reusable logic stored in a database as a function or procedure, with engine-specific rules for calling, returned values, permissions and side effects. See SQL Stored Procedures vs Functions for examples and practice.

A schema describes database objects and relationships, while metadata catalogs expose information about those objects, their columns and constraints. See SQL Schema: Inspect Tables and Metadata for examples and practice.

Date and time functions extract calendar parts, perform temporal arithmetic and format values, with substantial syntax and time-zone differences between databases. See SQL Date Functions: Ranges, Parts and Zones for examples and practice.

DEFAULT supplies an omitted value, CHECK restricts allowed row values, and UNIQUE prevents duplicate key values according to the engine’s rules. See SQL Constraints: DEFAULT, CHECK and UNIQUE for examples and practice.

A derived table is a query result used as a table input within an enclosing statement, usually written as a parenthesised SELECT in FROM. See SQL Derived Tables: Subqueries in FROM for examples and practice.

SQL dialect differences are variations in syntax, types and semantics between database systems that must be checked when translating a query or schema. See SQL Dialects: MySQL, PostgreSQL, Server and SQLite for examples and practice.

An ER diagram shows entities and relationship cardinality; keys, foreign keys, uniqueness, and nullability translate it into a relational schema. See Entity-Relationship (ER) Diagrams for examples and practice.

Difficulty-based SQL exercises build from row filters to relationship summaries and window calculations, with clear prerequisites and checkable expected results. See SQL Exercises: Beginner, Intermediate and Advanced for examples and practice.

EXISTS is true when a subquery returns at least one row; NOT EXISTS is true when it returns no rows. See SQL EXISTS: Related Rows and NOT EXISTS for examples and practice.

A foreign key requires a child reference to match an allowed parent key, with referential actions defining what happens when that parent is updated or deleted. See SQL Foreign Keys: CASCADE and SET NULL for examples and practice.

GROUP BY forms summary groups, WHERE filters input rows before grouping, and HAVING filters the resulting groups by a group-level condition. See SQL GROUP BY: HAVING and Advanced Examples for examples and practice.

CSV import maps parsed text fields into validated database columns; export serializes selected results under a documented format and access policy. See Importing and Exporting CSV Data for examples and practice.

IN tests membership, BETWEEN tests an inclusive range, and ANY or ALL compare a value with values returned by a subquery. See SQL Comparisons: IN, BETWEEN, ANY and ALL for examples and practice.

An attack where text typed by a user is joined into an SQL query and changes what it does. Prevented with parameterized queries. See SQL Injection and Database Security.

INNER JOIN returns combinations of input rows that satisfy the join condition, excluding input rows that have no qualifying match. See SQL INNER JOIN: Matches, Keys and Row Counts for examples and practice.

INSERT INTO SELECT adds rows to an existing target table using the result of a query rather than a literal VALUES list. See SQL INSERT INTO SELECT: Copy Query Results for examples and practice.

INTERSECT returns selected rows common to two query results, while EXCEPT returns selected rows from the first result that are absent from the second. See SQL INTERSECT and EXCEPT: Compare Sets for examples and practice.

SQL interview preparation combines relational concepts, precise result-shape reasoning and queries whose behaviour is tested on ties, NULL values and missing matches. See SQL Interview Questions: Worked Query Answers for examples and practice.

IS NULL tests whether a value is missing, while IS NOT NULL tests whether it is present; neither uses ordinary equality. See SQL IS NULL: Find and Handle Missing Values for examples and practice.

SQL keywords form statements that read data, change rows, define database objects, control transactions and manage permissions. See SQL Commands: Keywords, DDL and DML for examples and practice.

Window functions that read values from earlier or later rows in a defined order, independently within each partition. See SQL LAG and LEAD for examples and practice.

Outer joins preserve unmatched rows from one or both inputs, adding NULL placeholders for the side that has no qualifying match. See SQL Outer Joins: LEFT, RIGHT and FULL for examples and practice.

LIKE compares text with a pattern in which percent matches zero or more characters and underscore matches exactly one character. See SQL LIKE: Wildcards and Escaping for examples and practice.

LIMIT, TOP and FETCH FIRST restrict the number of returned rows, using syntax that depends on the database system. See SQL Row Limits: LIMIT, TOP and FETCH FIRST for examples and practice.

MAX() returns the largest non-NULL value in a group, with NULL returned when the group contains no known candidate. See SQL MAX(): Largest Values, Dates and Groups for examples and practice.

MIN() returns the smallest non-NULL value in a group of rows, or NULL when no known value is available. See SQL MIN(): Smallest Values, Groups and NULL for examples and practice.

An average calculated over a changing window of observations; a row-based window counts records rather than calendar periods. See SQL Running Totals and Moving Averages for examples and practice.

ORDER BY compares its expressions in sequence, and an explicit NULL sort key makes missing-value placement predictable across engines. See SQL Sorting: Multiple Columns and NULL for examples and practice.

MySQL is a relational database server with its own SQL dialect, connection accounts and InnoDB transaction and relationship features. See MySQL Tutorial: Tables, Queries and Transactions for examples and practice.

Normalization organizes relations according to functional dependencies to reduce insertion, update, and deletion anomalies. See Normalization: 1NF, 2NF, 3NF and BCNF for examples and practice.

Numeric functions calculate or reshape numbers, while input types and rounding rules determine the precision of their results. See SQL Math Functions: ROUND, ABS and Division for examples and practice.

Relationship types describe maximum related-row counts and are implemented with foreign keys, uniqueness, and junction tables. See One-to-One, One-to-Many and Many-to-Many Relationships for examples and practice.

SQL operators compare or calculate values; precedence decides how a compound expression is grouped when parentheses do not specify the grouping. See SQL Operators: AND, OR and Precedence for examples and practice.

Pivoting reshapes category values into separate output columns, often using conditional aggregation for a fixed set of categories. See SQL Pivoting: Categories into Columns for examples and practice.

PostgreSQL is a relational database server with strong type support, schemas, transactional features and a rich SQL dialect. See PostgreSQL Tutorial: Queries, Keys and Writes for examples and practice.

A primary key uniquely identifies every row and requires non-NULL key values; a composite key identifies a row through a combination of columns. See SQL Primary Keys: Composite Keys and Identity for examples and practice.

The database's chosen operations for producing a query result, including access paths, joins, filters, sorts and aggregates. See SQL Query Execution Plans with EXPLAIN for examples and practice.

Window functions that assign row positions or ranks within an ordered partition; RANK and DENSE_RANK preserve ties in different ways. See SQL ROW_NUMBER, RANK and DENSE_RANK for examples and practice.

A recursive query combines an initial result with repeated query steps that consume the previous result, making it possible to traverse hierarchies of variable depth. See SQL Recursive Queries: Hierarchies and Depth for examples and practice.

A SQL analytics project combines defined metrics, reproducible source data, layered queries and validation so report values can be explained and maintained. See SQL Analytics Projects: Metrics and Validation for examples and practice.

Database permissions grant principals specific actions on objects; role design groups those permissions according to required responsibilities. See SQL Security, Roles and Permissions for examples and practice.

SELECT DISTINCT removes duplicate rows from a query result by comparing the complete combination of selected expressions. See SELECT DISTINCT: SQL Duplicates and NULL for examples and practice.

SELECT INTO has dialect-specific meanings: SQL Server can create a table from a query, while other contexts use it to assign variables. See SQL SELECT INTO: Tables vs Variables for examples and practice.

A self join uses the same table in multiple roles, while CROSS JOIN returns every combination of rows from its two inputs. See SQL Self and CROSS Joins: Roles and Products for examples and practice.

T-SQL is SQL Server’s SQL dialect, extending relational queries with variables, batches, identity columns and procedural features. See SQL Server Basics: T-SQL Queries and Identity for examples and practice.

SQLite is an embedded relational database engine that usually stores a database in a file and runs inside the application rather than as a separate server. See SQLite Tutorial: Files, Tables and Queries for examples and practice.

String functions transform, measure or extract text, allowing queries to clean labels and produce consistent display values without changing stored data. See SQL String Functions: Case, Trim and Length for examples and practice.

SUM() adds the non-NULL numeric values in an input group, returning NULL when there are no known values to add. See SQL SUM(): Totals, NULL and Duplicate Rows for examples and practice.

SQL syntax defines how keywords, names, values and punctuation form valid database statements; comments explain a statement without becoming part of its calculation. See SQL Syntax: Comments, Quotes and Statements for examples and practice.

A temporary table stores intermediate rows with an engine-defined session or transaction lifetime, separate from ordinary persistent application tables. See SQL Temporary Tables: Scope and Staging for examples and practice.

The rules controlling what concurrent transactions can observe and how conflicting operations interact; guarantees differ by level and engine. See SQL ACID Properties and Transaction Isolation for examples and practice.

UNION combines compatible query results and removes duplicate selected rows, while UNION ALL preserves every row from each branch. See SQL UNION vs UNION ALL: Duplicates and Types for examples and practice.

The subset of a window partition used for a current-row calculation, with boundaries such as preceding rows and the current row. See SQL Window Frames and PARTITION BY for examples and practice.

A language feature where every variable has a declared type that is checked before the program runs, as in Java and C++.

A piece of text in code, wrapped in quotes: "hello", 'world' or `hi`. See JavaScript Strings.

A compiler-enforced rule controlling declaration visibility across type, file, module, package and importing-client boundaries. See Swift Access Control: Modules and Public APIs for worked examples and practice.

The ability for other actor work to run while an actor operation is suspended, making earlier state observations potentially stale. See Swift Actors: Reentrancy and Stale Results for worked examples and practice.

A producer capability that offers values and terminates an asynchronous stream under explicit buffering rules. See Swift Async Streams: Iteration and Buffering for worked examples and practice.

A whole-file writing strategy using an auxiliary file and replacement to avoid exposing a partially written new destination. See Swift Files: Atomic Codable Persistence for worked examples and practice.

The calendar and time-zone rules used to interpret an absolute Date and perform date-based calculations. See Swift Dates: Calendar Rules and Time Zones for worked examples and practice.

A multipass indexed sequence abstraction, with refinements for backward traversal and efficient random access. See Swift Collections: Sequences, Slices and lazy for worked examples and practice.

A runtime compatibility check using as? that returns an optional narrower view without converting unrelated representations. See Swift Type Casting: Any and Safe Downcasts for worked examples and practice.

An initializer that returns an optional instance and can reject construction by returning nil. See Swift Initialization: Failable and Class Rules for worked examples and practice.

A Unicode text unit represented by Swift Character that can contain several scalars and encoding code units. See Swift Unicode: String Indices and Text Views for worked examples and practice.

An endpoint-specific policy validating status, payload representation and domain meaning separately from transport success. See Swift Networking: URLSession HTTP Contracts for worked examples and practice.

A typed route from a root value to a property result, with distinct read-only and writable capabilities. See Swift Subscripts: Key Paths and Safe Lookup for worked examples and practice.

A SwiftData owner that tracks inserted, changed and deleted persistent model instances against a configured container. See SwiftData: Models, Contexts and Persistence for worked examples and practice.

A producer-selected concrete result type hidden behind protocol capabilities while retaining stable type identity. See Swift Protocol Types: some, any and Identity for worked examples and practice.

A SwiftPM build unit defining sources, a module or executable role, and explicit dependencies on other build units. See Swift Packages: Targets, Products and Tests for worked examples and practice.

A type implementing reusable wrapped-property access or storage behavior through wrappedValue and an optional projection. See Swift Properties: lazy and Property Wrappers for worked examples and practice.

A concurrency contract describing values that may be transferred safely across supported isolation boundaries. See Swift 6 Concurrency: Sendable and Isolation for worked examples and practice.

A matched text component exposed through the output structure of a native Swift Regex or a builder transformation. See Swift Regex: Native Matching and Typed Captures for worked examples and practice.

An immutable domain value created only after editable form drafts satisfy the supported input rules. See SwiftUI Forms: Validation and Accessibility for worked examples and practice.

Apple's framework for building user interfaces in Swift by describing what the screen should show for the current data. See SwiftUI Basics.

The grammar rules of a programming language: where brackets, quotes and semicolons go. A syntax error means the code breaks those rules.

The angle-bracket labels in HTML, like <p> (start tag) and </p> (end tag). See HTML Elements.

A JavaScript string written with backticks that can include variables directly: `Hi ${name}`. See JavaScript Strings.

A separate path of execution inside a program, letting several pieces of code run at the same time on different processor cores. See C++ Threads and Concurrency.

A small automated check that runs a piece of code with known input and confirms the result. See Testing Python Code and Unit Testing with JUnit.

Uniform Resource Locator: the full address of a page or file on the web, like https://www.codevra.org/html.

A named container that stores a value so you can use it later. See JavaScript Variables.

A system that records changes to files over time so you can review history, undo mistakes and collaborate. Git is the most widely used one.

The visible area of a web page on the screen. Phones have small viewports, desktops large ones. See CSS Units.

Web Content Accessibility Guidelines: the international standard for making websites accessible. See HTML Accessibility.

Cross-site scripting: an attack where a page shows text from a user as HTML, letting their script run in other visitors' browsers. Prevented by escaping output. See PHP Security Essentials.