Web Developer Dictionary

Late Static Binding is a PHP mechanism that lets static methods refer to the class they were called on, not the class where they were defined. Use static:: instead of self::. self vs static class Base { public static function create(): static { return new static(); // the class it was called on } public static function name(): string { return static::class; // Late Static Binding } } class Child extends Base {} Child::create(); // returns Child, not Base Child::name(); // "Child", not "Base" Where it is used Fluent interfaces and Builder patterns that return static ActiveRecord style: User::find(1) returns User, not the base class Static factory methods in class hierarchies

Lazy Loading is a deferred-loading pattern: a resource or data is loaded only when it is actually needed, not in advance. The opposite is Eager Loading (loading everything upfront).In different contextsImages — the browser loads <img loading="lazy"> only when it enters the visible area, speeding up the initial page renderORM — related data is loaded with a separate SQL query on first access. Convenient for prototyping, but can trigger N+1JS modules — dynamic import() loads code only when needed, reducing the initial bundle sizeInfinite scroll — content is loaded in portions as the user scrollsWhen to be carefulIn ORMs, lazy loading is convenient during development but dangerous in production: it is easy to miss how one property access turns into dozens of queries. Recommendation: in production code, always explicitly declare which relations are needed — through eager loading.

A linked list is a linear data structure where each element (node) holds a value and a pointer to the next node. Unlike an array, elements are not stored contiguously in memory. Types Singly Linked — each node → next node. Forward traversal only Doubly Linked — each node → next and previous. Traversal in both directions Circular — the last node → the first Comparison with arrays Insert/delete at head: list O(1) vs array O(n) (shift) Insert/delete in middle: list O(n) (search) vs array O(n) (shift) Index access: list O(n) vs array O(1) Memory: list uses more (pointers) In PHP PHP arrays are hash tables — not linked lists. For a true linked list: SplDoublyLinkedList or a custom implementation. Rarely needed in practice.

A linter is a static analysis tool that automatically finds potential errors, style violations, and suspicious code before execution. The name comes from the lint utility for C (1978).What it checksSyntax errors and dangerous codeUnused variables and unreachable codeStyle violations: indentation, quotes, semicolonsDangerous patterns (e.g. == instead of === in JS)Popular lintersPHP: PHP_CodeSniffer, PHPStan, Psalm — static analysis with type checkingJavaScript: ESLint — most flexible, with thousands of pluginsPython: Ruff, Flake8, PylintCSS: StylelintLinter vs FormatterA linter finds problems; a formatter fixes formatting automatically (Prettier, php-cs-fixer). They are often run together in pre-commit hooks.

LLM (Large Language Model) is a neural network trained on trillions of tokens of text that generates human-like text in response to a prompt. ChatGPT, Claude, Gemini, Llama — all are LLMs. The foundation of the current AI boom.How it worksAn LLM predicts the next token (a word or part of a word) based on context. Despite the simple task, the scale and Transformer architecture allow it to "understand" complex instructions, write code, translate, and analyse.Key conceptsToken — the smallest unit of text. GPT-4 processes ~4 characters = 1 tokenContext window — the maximum amount of text the model "sees" at onceTemperature — a randomness parameter. 0 = deterministic, 1 = creativeInference — generating a response (as opposed to training)LimitationsHallucinations (confident but false facts), knowledge capped at training date, limited context window, expensive to scale.

A load balancer is a proxy that distributes incoming requests across multiple servers. It enables horizontal scaling and eliminates single points of failure.Distribution algorithmsRound Robin — sends requests to each server in turnLeast Connections — routes to the server with the fewest active connectionsIP Hash — a given client always goes to the same server (sticky sessions)Weighted — more powerful servers receive more requestsL4 vs L7L4 — TCP/UDP-level balancing; does not inspect the request body. FasterL7 — HTTP-aware; can route by URL, header, or cookie. Nginx, HAProxy, AWS ALBHealth CheckThe load balancer periodically checks server health. If a server stops responding, it is removed from rotation until it recovers.

Load testing verifies how a system behaves under expected and peak load. It answers: how many concurrent users can the server handle? Where does performance degrade?TypesLoad test — expected load. Does p99 latency stay below 500 ms at 1000 RPS?Stress test — load above expected. Where does the system break?Spike test — a sudden burst. Can the system handle 10× load for 1 minute?Soak test — sustained load over a long period. Are there memory leaks?Toolsk6 — JavaScript, open-source, excellent developer experienceApache JMeter — Java, GUI, battle-testedGatling — Scala, DSL, good reportingMetricsRPS (requests per second), latency percentiles (p50, p95, p99), error rate, throughput. Test in an environment as close to production as possible.

Long polling is a technique for simulating push notifications over HTTP. The client sends a request; the server holds it open until new data appears (or a timeout occurs), then responds. The client immediately sends the next request. An older "real-time" approach before WebSocket. Flow Client Server |-- GET /poll --------->| | | (waiting for new data) | | (30 seconds...) || (new request immediately) | | Benefits Works everywhere — plain HTTP, no special protocols Simpler to implement than WebSocket Drawbacks Many open connections burden the server Latency = time between response and new request HTTP overhead on every cycle When still relevant Environments where WebSocket and SSE are unavailable (corporate proxies, old browsers). In modern web apps, usually replaced by SSE or WebSocket.