Lexicon / back matter
Say the abbreviation correctly.
112 coding terms, A11Y to YAML — the first tab, on purpose. LabRat AI loaded this entire list. Ask the rat “what is SSR” or type terms. This page does not execute anything.
| Term / Abbreviation | Full Expansion | Technical Definition & Contextual Usage |
|---|---|---|
| A11Y | Accessibility | A numeronym for "accessibility" — the 11 stands for the letters between the a and the y. It names the discipline of building interfaces usable by people with visual, auditory, motor, or cognitive impairments, backed by semantic HTML and ARIA. |
| ABI | Application Binary Interface | The low-level contract between two binary modules — covering calling conventions, register usage, data-type sizes, and symbol layout. A stable ABI lets compiled libraries link against each other without being recompiled from source. |
| ACID | Atomicity, Consistency, Isolation, Durability | The four guarantees that make database transactions reliable. Atomicity makes a transaction all-or-nothing, Consistency preserves invariants, Isolation hides concurrent work, and Durability survives crashes once committed. |
| ACSS | Atomic Cascading Style Sheets | A CSS methodology where each class applies exactly one immutable rule (for example .mt-10 sets only a top margin). Composing these atomic utilities keeps stylesheets small and highly reusable across large frontends. |
| AJAX | Asynchronous JavaScript and XML | A browser technique for exchanging data with a server in the background and updating the page without a full reload. Modern AJAX almost always carries JSON via the fetch API rather than XML. |
| AOT | Ahead-Of-Time Compilation | Compiling source or bytecode to native machine code before the program runs, rather than during execution. AOT trades slower builds for faster startup and predictable runtime performance, the opposite tradeoff from JIT. |
| API | Application Programming Interface | A standardized set of protocols, routines, and tools allowing distinct software applications to securely communicate. APIs abstract underlying database implementations, exposing only necessary endpoints (e.g., RESTful URLs or GraphQL schemas) for authorized data exchange. |
| AR | ActiveRecord | An object-relational mapping pattern — popularized by Ruby on Rails — that represents each database row as a manipulable object and couples persistence logic to the domain model. Saving the object writes the row. |
| ARIA | Accessible Rich Internet Applications | A set of HTML attributes (roles, states, and properties) that expose semantics to assistive technologies when native elements are insufficient. WAI-ARIA lets custom widgets announce themselves correctly to screen readers. |
| ASCII | American Standard Code for Information Interchange | A 7-bit character encoding that maps 128 codes to English letters, digits, punctuation, and control characters. It is the historical foundation that UTF-8 extends while remaining backward compatible. |
| AST | Abstract Syntax Tree | A hierarchical tree representation of the abstract syntactic structure of source code. Compilers (like rustc) and interpreters (like V8) utilize ASTs to deeply analyze and ultimately convert human-readable source code into executable machine code. |
| BaaS | Backend as a Service | A cloud model that outsources backend concerns — database, authentication, storage, push notifications — to a third-party provider so teams can ship a frontend without operating servers. Firebase and Supabase are common examples. |
| BDD | Behavior-Driven Development | A collaborative practice that describes software behavior in plain, example-driven language (often Given/When/Then) before implementation. It extends TDD so that tests double as living, business-readable specifications. |
| Big-O | Big O Notation | A notation describing how an algorithm's time or memory grows relative to input size, focusing on the dominant term. O(1), O(log n), O(n), and O(n²) let engineers compare scalability independent of hardware. |
| BLOB | Binary Large Object | A data type for storing large unstructured binary content — images, audio, video, or serialized files — inside a database column or object store rather than as parsed structured fields. |
| BOM | Browser Object Model | The browser-specific object hierarchy that lets scripts interact with the window and environment rather than the document — covering window, navigator, location, and screen. Unlike the DOM, it is not defined by a single standard specification. |
| CDN | Content Delivery Network | A geographically distributed fleet of edge servers that cache static assets close to users. CDNs cut latency, absorb traffic spikes, and offload bandwidth from the origin server. |
| CI/CD | Continuous Integration / Continuous Delivery | An automation pipeline that builds and tests every change on merge (CI) and then reliably ships it to staging or production (CD). It shortens feedback loops and makes releases routine rather than risky. |
| CLI | Command Line Interface | A text-based user interface utilized by developers to interact with operating systems and development environments. Instead of clicking graphical buttons, developers execute complex commands in a terminal emulator (e.g., using git commit or cargo build). |
| CORS | Cross-Origin Resource Sharing | A strict security mechanism enforced by web browsers. It restricts web applications running at one origin (domain/port) from maliciously making unauthorized HTTP requests to a different origin, requiring explicit server-side headers to bypass. |
| CPU | Central Processing Unit | The general-purpose processor that fetches, decodes, and executes program instructions. Its clock speed, core count, and cache hierarchy set the ceiling for most sequential workloads. |
| CRON | Command Run On | A time-based job scheduler on Unix-like systems that runs commands on a fixed schedule defined by a five-field expression. It automates recurring work like backups, cache purges, and batch emails without human intervention. |
| CRUD | Create, Read, Update, Delete | The four foundational lifecycle operations required for persistent data storage. These operations map directly to SQL database commands (INSERT, SELECT, UPDATE, DELETE) and standard HTTP methods (POST, GET, PUT, DELETE). |
| CSR | Client-Side Rendering | A web architecture paradigm where raw code (JavaScript, Wasm) is transmitted to the user's browser, which then executes the logic to fetch data and dynamically build the user interface locally. |
| CSRF | Cross-Site Request Forgery | An attack that tricks an authenticated user's browser into sending an unwanted request to a site where they are logged in. Anti-CSRF tokens and SameSite cookies are the standard defenses. |
| CSS | Cascading Style Sheets | The declarative language that styles HTML — controlling layout, color, typography, and responsive behavior. The cascade and specificity rules decide which conflicting declarations ultimately apply. |
| DNS | Domain Name System | The internet's distributed directory that resolves human-readable hostnames into IP addresses. Records like A, AAAA, CNAME, and MX route traffic and email for a domain. |
| DOM | Document Object Model | A standard programming interface for web documents. It treats the HTML structure as a hierarchical, searchable tree of nodes, allowing scripting languages like JavaScript to dynamically alter styles, text, and elements in real-time. |
| DRY | Don't Repeat Yourself | A design principle stating that every piece of knowledge should have a single, authoritative representation in a codebase. Removing duplication reduces the risk that one copy drifts out of sync during maintenance. |
| DTO | Data Transfer Object | A plain object used to carry data across boundaries — between layers, services, or over the network. DTOs decouple internal domain models from the shape clients actually receive. |
| ES | ECMAScript | The standardized specification that defines the JavaScript language. Yearly editions (ES2015 onward) add syntax and APIs that engines like V8 then implement. |
| ETL | Extract, Transform, Load | A data-pipeline pattern that pulls records from sources, reshapes and cleans them, then writes them into a warehouse. The modern ELT variant loads first and transforms inside the destination. |
| FaaS | Function as a Service | A cloud computing execution model (e.g., AWS Lambda) where developers write discrete, single-purpose functions. The cloud provider dynamically manages the allocation of server resources, executing the code only in response to specific triggers. |
| FIFO | First In, First Out | An ordering discipline where the earliest item added is the first removed — the behavior of a queue. It contrasts with LIFO and models fair, arrival-order processing. |
| FP | Functional Programming | A declarative paradigm that builds programs by composing pure functions and avoiding shared mutable state. Eliminating side effects makes behavior predictable and code far easier to test and parallelize. |
| FTP | File Transfer Protocol | An older protocol for moving files between a client and server over a network. Because it transmits credentials in plaintext, it is largely replaced by SFTP and HTTPS transfers today. |
| GC | Garbage Collection | Automatic memory management that reclaims objects no longer reachable by the program. Runtimes like the JVM and V8 use GC so developers avoid manual allocation and freeing. |
| GPU | Graphics Processing Unit | A massively parallel processor built for throughput over thousands of lightweight cores. Beyond rendering, GPUs accelerate machine learning, simulation, and other data-parallel workloads. |
| GraphQL | Graph Query Language | An API query language where clients request exactly the fields they need from a typed schema through a single endpoint. It reduces over-fetching common in REST but shifts complexity onto resolver design. |
| gRPC | gRPC Remote Procedure Call | A high-performance RPC framework using HTTP/2 transport and Protocol Buffers for compact, strongly typed messages. It excels at low-latency service-to-service communication and streaming. |
| GUI | Graphical User Interface | A visual interface built from windows, icons, buttons, and pointers rather than typed commands. It lowers the barrier to entry compared with a CLI at the cost of scriptability. |
| HTML | HyperText Markup Language | The markup language that structures web content into elements like headings, links, forms, and media. Browsers parse HTML into the DOM that CSS styles and JavaScript manipulates. |
| HTTP | HyperText Transfer Protocol | The stateless request/response protocol underpinning the web. Methods (GET, POST, PUT, DELETE) and status codes (200, 404, 500) define how clients and servers exchange resources. |
| HTTPS | HyperText Transfer Protocol Secure | HTTP layered over TLS so requests and responses are encrypted and the server's identity is authenticated. It protects data in transit from eavesdropping and tampering. |
| IaaS | Infrastructure as a Service | A cloud model that rents raw compute, storage, and networking — virtual machines and disks — leaving the operating system and everything above it to the customer. It sits below PaaS and SaaS in abstraction. |
| IDE | Integrated Development Environment | Comprehensive software suites designed to maximize developer productivity. Modern IDEs—such as Visual Studio Code, which holds roughly 76% of developer preference—combine intelligent code editors, syntax highlighting, debuggers, and build automation. |
| I/O | Input/Output | The movement of data between a program and the outside world — disk, network, or peripherals. Because I/O is far slower than the CPU, asynchronous and buffered strategies keep programs responsive. |
| IP | Internet Protocol | The addressing and routing layer that delivers packets across networks. IPv4 and IPv6 define the numeric addresses that identify every host on the internet. |
| IPC | Inter-Process Communication | The mechanisms — pipes, sockets, shared memory, message queues — that let separate processes exchange data and coordinate. It is essential to multi-process and microservice architectures. |
| ISR | Incremental Static Regeneration | A rendering strategy (popularized by Next.js) that serves pre-built static pages but rebuilds them in the background after a set interval. It blends the speed of SSG with fresh data. |
| JDK | Java Development Kit | The full toolchain for building Java software: the compiler (javac), standard libraries, and a bundled JVM to run the result. The JRE is the runtime-only subset of the JDK. |
| JIT | Just-In-Time Compilation | Compiling bytecode or script to native machine code at runtime, guided by profiling of hot paths. Engines like V8 and the JVM use JIT to approach native speed while keeping portability. |
| JSON | JavaScript Object Notation | A lightweight, universally adopted data-interchange format. While syntactically derived from JavaScript objects, it is language-independent and serves as the primary payload format for modern REST and web API communications. |
| JSX | JavaScript XML | A syntax extension that lets developers write HTML-like markup directly inside JavaScript. Build tools transpile JSX into function calls that frameworks like React use to describe UI. |
| JVM | Java Virtual Machine | An execution engine that provides a runtime environment to drive Java Code or applications. It converts Java bytecode into machine language, embodying the "write once, run anywhere" philosophy. |
| JWT | JSON Web Token | An open standard utilized for securely transmitting information between network parties. JWTs are highly prevalent in stateless web authentication architectures, allowing servers to verify user identity via cryptographic signatures without maintaining session state. |
| KISS | Keep It Simple, Stupid | A design maxim urging the simplest solution that works, avoiding needless cleverness. Simpler systems are easier to read, test, and change under pressure. |
| LIFO | Last In, First Out | An ordering discipline where the most recently added item is removed first — the behavior of a stack. The call stack and undo histories rely on LIFO semantics. |
| LLM | Large Language Model | Advanced artificial intelligence systems trained on massive datasets of text and code. LLMs, such as Claude Sonnet or OpenAI models, form the basis of generative tools that assist modern developers in code generation, debugging, and documentation synthesis. LabRat AI is not an LLM; it is an offline shell. |
| LTS | Long-Term Support | A release designated for extended maintenance and security patches, letting teams stay on a stable version without chasing every feature update. Node.js and Ubuntu ship LTS lines on predictable schedules. |
| MIME | Multipurpose Internet Mail Extensions | A standard for labeling content types (like text/html or application/json) so clients know how to interpret a payload. The Content-Type header carries the MIME type on every HTTP response. |
| MVC | Model-View-Controller | A fundamental software architectural pattern that separates an application into three interconnected components. The Model manages data logic, the View handles the graphical UI, and the Controller acts as the routing interface managing inputs and updating the other two components. |
| MVP | Minimum Viable Product | The smallest releasable version of a product that delivers core value and validates assumptions with real users. It prioritizes learning over completeness before heavier investment. |
| npm | Node Package Manager | The default package manager and registry for the JavaScript ecosystem. It resolves dependencies from package.json, installs them into node_modules, and runs project scripts. |
| OAuth | Open Authorization | A delegated-authorization standard that lets an app access a user's resources on another service without handling their password. Users grant scoped tokens through a consent flow instead. |
| OOP | Object-Oriented Programming | A paradigm that organizes code around objects bundling state and behavior. Its pillars — encapsulation, inheritance, polymorphism, and abstraction — structure large systems around reusable types. |
| OPFS | Origin Private File System | A sandboxed, high-performance file system native to modern web browsers. It provides WebAssembly applications (like DuckDB-Wasm) with direct, highly optimized access to local storage, enabling massive client-side data pipelines. |
| ORM | Object-Relational Mapper | A programming technique for converting data between incompatible type systems. ORMs allow developers to query relational databases using the object-oriented paradigms of their host language (e.g., Python classes) instead of writing raw SQL strings. |
| OS | Operating System | The system software that manages hardware, schedules processes, and mediates access to memory, files, and devices. It exposes the syscalls and abstractions every application depends on. |
| PaaS | Platform as a Service | A cloud model that provides a managed runtime, build pipeline, and scaling so developers deploy code without provisioning servers. It abstracts more than IaaS while offering less control. |
| POSIX | Portable Operating System Interface | A family of standards specified by the IEEE to maintain compatibility between operating systems. It defines the API, shell interfaces, and utility protocols for software attempting to interface with Unix-based systems. |
| PR | Pull Request | A proposal to merge one branch into another, bundling a diff with discussion, review, and automated checks. It is the primary unit of collaboration and code review in Git-based workflows. |
| RAG | Retrieval-Augmented Generation | An AI framework that retrieves facts from an external knowledge base to ground large language models on the most accurate, up-to-date information, drastically reducing the hallucination of false data during code generation. |
| RAM | Random Access Memory | Fast, volatile working memory that holds the code and data a program is actively using. Its contents vanish on power loss, unlike persistent disk storage. |
| Regex | Regular Expression | A compact pattern language for matching, searching, and replacing text. Regex powers validation, tokenizers, and find-and-replace, though complex patterns can become hard to read. |
| REST | Representational State Transfer | A software architectural style created to guide the design of scalable web services. RESTful APIs rely on stateless communication and standard HTTP methodologies, providing predictable, uniform resource access. |
| RPC | Remote Procedure Call | A model where calling a function on a remote server looks like a local call, hiding the network underneath. Frameworks such as gRPC handle serialization, transport, and error mapping. |
| SaaS | Software as a Service | A delivery model where centrally hosted software is accessed over the web on subscription, with the vendor handling updates, scaling, and uptime. Users need only a browser and credentials. |
| SDK | Software Development Kit | A comprehensive collection of software development tools packaged together. SDKs typically include APIs, documentation, code samples, and platform-specific compilers designed to facilitate application development for a specific hardware ecosystem. |
| SEM | Search Engine Marketing | The practice of driving traffic through paid search placement — keyword bidding, ad auctions, and conversion analytics — complementing the organic focus of SEO. It shapes how landing pages and response times are optimized for campaigns. |
| SEO | Search Engine Optimization | The technical practice of structuring web applications to ensure search engine web crawlers can accurately index and rank the content. It often dictates architectural choices, strongly favoring Server-Side Rendering (SSR) over CSR. |
| SERP | Search Engine Results Page | The page a search engine returns for a query, blending organic results, ads, and rich features like snippets and knowledge panels. Ranking position on the SERP is the central target of SEO and SEM efforts. |
| SOAP | Simple Object Access Protocol | A rigid, XML-based messaging protocol for web services with strong typing, formal contracts (WSDL), and built-in error handling. Heavier than REST, it persists in enterprise and financial systems that demand strict transactions. |
| SOLID | Single-responsibility, Open-closed, Liskov, Interface-segregation, Dependency-inversion | Five object-oriented design principles that keep systems modular and change-tolerant. Together they push toward focused classes, stable abstractions, and loosely coupled dependencies. |
| SPA | Single Page Application | A web application implementation that loads a single HTML document on the initial request, subsequently updating the page content dynamically via JavaScript APIs. This eliminates full page reloads, creating seamless user experiences mimicking native software. |
| SQL | Structured Query Language | A domain-specific programming language utilized exclusively for managing and querying relational database architectures. It remains a foundational requirement for data engineering across all enterprise sectors. |
| SSG | Static Site Generation | Rendering pages to static HTML at build time so they can be served instantly from a CDN. It maximizes speed and cacheability for content that changes infrequently. |
| SSH | Secure Shell | An encrypted protocol for logging into and running commands on remote machines, and for tunneling other traffic. Key-based authentication makes it the standard for secure server access and Git over SSH. |
| SSL | Secure Sockets Layer | The original protocol for encrypting network connections, now deprecated in favor of its successor TLS. The name persists colloquially even though modern certificates secure traffic via TLS. |
| SSR | Server-Side Rendering | The architectural process of generating fully formatted HTML on a backend server before transmitting it to the client. This shifts the computational burden away from the browser, improving initial load times and SEO metrics. |
| SVG | Scalable Vector Graphics | An XML-based format that describes 2D graphics as mathematical shapes rather than pixels, so images scale to any size without quality loss. SVG supports CSS styling, animation, and scripting directly in the DOM. |
| TCP | Transmission Control Protocol | A connection-oriented transport protocol that guarantees ordered, reliable delivery via acknowledgments and retransmission. It trades some latency for correctness compared with UDP. |
| TDD | Test-Driven Development | A workflow of writing a failing test first, making it pass with minimal code, then refactoring — the red-green-refactor loop. It drives design and yields a regression suite as a byproduct. |
| TLS | Transport Layer Security | The modern cryptographic protocol that encrypts and authenticates network connections, securing HTTPS and other traffic. It succeeds SSL and underpins trust on the web. |
| UDP | User Datagram Protocol | A connectionless transport protocol that sends datagrams without ordering or delivery guarantees. Its low overhead suits latency-sensitive uses like video, gaming, and DNS. |
| UI | User Interface | The visual and interactive surface — layout, controls, and typography — through which a person operates software. Good UI communicates state and affordances clearly. |
| URI | Uniform Resource Identifier | The general syntax for naming a resource, of which a URL is the locating subset. A URI can identify a resource without necessarily saying how to fetch it. |
| URL | Uniform Resource Locator | The addressable location of a web resource, combining scheme, host, path, and optional query and fragment. It is the specific kind of URI that tells a client how and where to retrieve something. |
| UTF | Unicode Transformation Format | A family of encodings (UTF-8, UTF-16, UTF-32) that represent Unicode code points as bytes. UTF-8 dominates the web because it is compact for ASCII and backward compatible. |
| UUID | Universally Unique Identifier | A 128-bit identifier generated to be unique without a central authority, usually shown as 32 hex digits. It lets distributed systems mint keys independently with negligible collision risk. |
| UX | User Experience | The overall quality of a person's interaction with a product — including usability, flow, accessibility, and emotional response. UX spans research and design beyond the visual UI layer. |
| V8 | V8 JavaScript Engine | The open-source, high-performance JavaScript and WebAssembly engine developed by Google. Embedded within Chrome and Node.js, V8 compiles JavaScript directly to native machine code before execution, drastically increasing runtime speed. |
| VCS | Version Control System | Software that tracks changes to files over time, enabling history, branching, and collaboration. Git is the dominant distributed VCS, giving every clone the full project history. |
| VM | Virtual Machine | An emulated computer running atop physical hardware, either a full OS-level virtual machine or a language runtime like the JVM. It isolates workloads and abstracts away the underlying host. |
| WASI | WebAssembly System Interface | A highly modular system interface designed to allow WebAssembly binaries to run securely outside of web browsers. The recent WASI 0.2 update introduces the Component Model, standardizing cross-language interoperability and secure hardware access. |
| WASM | WebAssembly | A portable, binary instruction format providing near-native execution environments natively within web browsers. Wasm serves as a compilation target for robust systems languages, allowing complex software to run securely on the client side. |
| WIT | WebAssembly Interface Types | An Interface Description Language (IDL) used strictly to define complex communication interfaces between distinct Wasm modules. WIT files specify exactly how different components pass rich data types safely across memory boundaries. |
| WYSIWYG | What You See Is What You Get | An editing model where the on-screen document mirrors the final rendered output. Rich-text and page builders are WYSIWYG, trading precise control for immediate visual feedback. |
| XML | Extensible Markup Language | A verbose, self-describing markup format for structured data using nested tags. Once ubiquitous for config and APIs, it has largely ceded ground to JSON and YAML for readability. |
| XSS | Cross-Site Scripting | A web vulnerability where an attacker injects malicious scripts that run in other users' browsers. Output escaping and a strict Content Security Policy are the primary mitigations. |
| YAGNI | You Aren't Gonna Need It | An agile principle warning against building functionality on speculation. Implement features when a real requirement arrives, not because you assume it might appear later. |
| YAML | YAML Ain't Markup Language | A human-readable data-serialization language. It abandons brackets in favor of strict indentation and is globally utilized for writing configuration files for infrastructure as code, container orchestration, and continuous integration deployment pipelines. |
112 of 112 entries