# Dixl Developer Lexicon

> Definitive Computer Science &amp; Engineering Glossary

## Publications & Knowledge Base

- [Configuring UFW Firewall on Ubuntu &amp; Debian: A Field Guide](https://dixl.eu/configuring-ufw-firewall-on-ubuntu-debian-a-field-guide/): I stared at the sysadmin ticket at 4:42 PM on a Friday. The client had just deployed a fresh Debian instance into production, left iptables unconfigured, and woke up to a crypto-miner script eating 98% of their CPU cycles within four hours. They tried to fix it by running random iptables commands they found on [&hellip;]
- [How to Set Up SSH Keys Securely on Linux Servers](https://dixl.eu/how-to-set-up-ssh-keys-securely-on-linux-servers/): A junior sysadmin dumped their private SSH key into a public GitHub repository at 4:45 PM on a Friday. By 5:12 PM, automated scrapers had harvested it, bypassed the single-factor authentication on three production nodes, and dropped malicious mining binaries across the cluster. We were called in to audit the wreckage. The root cause wasn&#8217;t [&hellip;]
- [How to Install Nginx on Linux Like a Pro | Field Guide](https://dixl.eu/how-to-install-nginx-on-linux-like-a-pro-field-guide/): I am looking at a deployment audit right now where a junior dev pulled down a default package manager bundle at 4:45 PM on a Friday, pushed it straight to production without checking the repo source, and watched the TLS handshake crash within twenty minutes. Not quite the smooth zero-downtime transition the vendor documentation promised. [&hellip;]
- [Tabu Search](https://dixl.eu/tabu-search/): Tabu Search is a higher-level metaheuristic used to solve global optimization problems by guiding a local search procedure to explore the solution space beyond local optimality. Developed by Fred Glover, it utilizes adaptive memory structures (tabu lists) to classify moves as forbidden (tabu) based on recency and frequency attributes, thereby preventing cycling and encouraging deep [&hellip;]
- [Sudoku Solving Algorithms](https://dixl.eu/sudoku-solving-algorithms/): Sudoku solving algorithms model the popular logic puzzle as a Constraint Satisfaction Problem (CSP) or an Exact Cover problem. Mathematically, a standard 9&#215;9 Sudoku grid is represented as a matrix of variables V of size 81, domains D_v = {1, 2, &#8230;, 9} for all v in V, and a set of constraints C enforcing [&hellip;]
- [State-Space Search](https://dixl.eu/state-space-search/): State-space search is a foundational algorithmic paradigm in computer science and artificial intelligence that models problem-solving as the traversal of a directed graph. Each node represents a distinct system state, and each directed edge represents a valid state transition governed by deterministic or stochastic operators. The primary objective is to discover a finite sequence of [&hellip;]
- [Stack Search](https://dixl.eu/stack-search/): Stack search is the algorithmic procedure of locating an element within a Last-In-First-Out (LIFO) data structure without permanently violating its structural invariants. Because standard abstract data type (ADT) definitions for stacks restrict observation and mutation strictly to the top element via push and pop operations, arbitrary searching necessitates either temporary structural dismantling with state restoration, [&hellip;]
- [SSS* Algorithm Specification](https://dixl.eu/sss-algorithm-specification/): SSS* is a state-space search algorithm designed by George Stockman in 1979 for minimax game trees. Unlike Alpha-Beta pruning, which performs a depth-first traversal, SSS* operates in a best-first manner over a set of solution trees, maintaining a priority queue of solved or partially solved nodes. It is mathematically proven to visit no more leaf [&hellip;]
- [Spreading Activation](https://dixl.eu/spreading-activation/): Spreading activation is a network-based algorithmic paradigm used to search, retrieve, and infer information across associative networks and semantic graphs. Originating in cognitive science and knowledge representation, the algorithm operates by initializing activation energy at one or more source nodes, which then propagates across weighted, directed edges to neighboring nodes based on edge weights, decay [&hellip;]
- [Spiral Hashing](https://dixl.eu/spiral-hashing/): Spiral Hashing is an advanced dynamic hashing scheme engineered to manage variable-sized datasets with minimal memory overhead and smooth, predictable rehashing costs. Unlike traditional linear or extendible hashing that suffers from massive latency spikes during table expansion, Spiral Hashing dynamically allocates storage buckets in a spiral trajectory across logical memory pages, distributing the re-allocation workload [&hellip;]
- [Simplified Memory-Bounded A* (SMA*)](https://dixl.eu/simplified-memory-bounded-a-sma/): Simplified Memory-Bounded A* (SMA*) is an extension of the A* search algorithm designed to operate within a strictly constrained memory budget. While standard A* retains all generated nodes in memory leading to exponential space complexity O(b^d), SMA* proceeds like A* until memory is exhausted, at which point it prunes the worst leaf node (highest f-cost) [&hellip;]
- [Slop (search algorithms)](https://dixl.eu/slop-search-algorithms/): Slop is an advanced approximate search algorithm designed for high-dimensional metric spaces, operating on the principle of dynamic radius relaxation and bounded bucket pruning. Unlike traditional graph-based navigations (e.g., HNSW) or tree-based partitions (e.g., k-d trees), Slop introduces a localized tolerance parameter—the &#039;slop factor&#039;—which controls the tradeoff between recall precision and query traversal latency. By [&hellip;]
- [Similarity Search](https://dixl.eu/similarity-search/): Similarity search is the computational paradigm of retrieving objects from a dataset that maximally correlate with a given query vector under a designated metric space, such as Euclidean distance, cosine similarity, or inner product. As high-dimensional vector representations proliferate across modern computing—driven by deep learning embeddings for text, images, and audio—exact linear scanning becomes computationally [&hellip;]
- [Siamese Method](https://dixl.eu/siamese-method/): The Siamese Method (also known as the De la Loubère method) is a classical, deterministic algorithmic procedure utilized to construct odd-order magic squares. Given any positive, odd integer n &gt;= 3, the algorithm systematically populates an n x n matrix such that the sums of the integers in every row, column, and both main diagonals [&hellip;]
- [Search-based software engineering](https://dixl.eu/search-based-software-engineering/): Search-Based Software Engineering (SBSE) is an engineering paradigm that reformulates software engineering problems as optimization problems, leveraging metaheuristic search techniques to navigate vast, non-linear, and non-differentiable design spaces. By abstracting software artifacts—such as test suites, refactoring plans, resource allocation, and hyperparameter configurations—into mathematical representations (genomes or candidate solutions), SBSE automates complex trade-off analysis using scalar [&hellip;]
- [Search Tree](https://dixl.eu/search-tree/): A search tree is a hierarchical data structure optimized for storing and querying dynamic sets of ordered key-value pairs. By maintaining structural invariants such as balanced depth or path-length constraints, self-balancing search trees guarantee logarithmic worst-case time complexities for lookup, insertion, and deletion operations, serving as the foundational underpinning for indexed storage engines, associative memory [&hellip;]
- [Search Game (Adversarial Search)](https://dixl.eu/search-game-adversarial-search/): A Search Game (formalized in game theory and adversarial search) is a mathematical framework for analyzing decision-making processes between two or more rational, opposing agents. In computer science, it is primarily instantiated via the Minimax algorithm and its optimizations (such as Alpha-Beta pruning, Principal Variation Search, and Monte Carlo Tree Search). The algorithm evaluates a [&hellip;]
- [Rocchio Algorithm](https://dixl.eu/rocchio-algorithm/): The Rocchio algorithm is a classic relevance feedback technique rooted in the Vector Space Model (VSM). It computes an optimized query vector by mathematically adjusting the original query vector based on known relevant and non-relevant document vectors. By maximizing the separation between relevant and non-relevant clusters in a multi-dimensional term space, the Rocchio algorithm significantly [&hellip;]
- [Reverse-Search Algorithm](https://dixl.eu/reverse-search-algorithm/): The reverse-search algorithm, pioneered by David Avis and Komei Fukuda, is a state-space enumeration technique designed to list all elements of a finite set defined by a local search or optimization property without requiring exponential space complexity. Unlike traditional backtracking or breadth-first search which must store previously visited states in memory to prevent cycles, reverse-search [&hellip;]
- [Rapidly-Exploring Random Tree (RRT)](https://dixl.eu/rapidly-exploring-random-tree-rrt/): The Rapidly-Exploring Random Tree (RRT) is an incremental sampling-based algorithm designed to efficiently search nonconvex, high-dimensional state spaces. By dynamically biasing the search toward unexplored regions via random sampling, RRT bypasses the combinatorial explosion inherent in exact cell-decomposition methods, making it foundational for kinematic and dynamic motion planning. 1. Overview and Architecture { &quot;title&quot;: &quot;Rapidly-Exploring [&hellip;]
- [Rapidly Exploring Dense Trees](https://dixl.eu/rapidly-exploring-dense-trees/): Rapidly exploring dense trees represents an advanced optimization of sampling-based motion planning and hierarchical graph traversal. By tightly coupling metric space discretization with bounded-distortion nearest-neighbor queries via optimized spatial indices (such as k-d trees and vantage-point trees), this algorithm overcomes the exponential complexity degradation common in dense, high-obstruction state spaces. 🛠️ HOW-TO IMPLEMENT &amp; CONFIGURE [&hellip;]
- [Range Minimum Query](https://dixl.eu/range-minimum-query/): Range Minimum Query (RMQ) is a fundamental algorithmic problem that asks for the index or value of the minimum element within a specified contiguous subsegment of a linear array. Formally, given an array A of n elements, a query Q(i, j) returns the index k such that A[k] = min(A[i&#8230;j]) for 0 &lt;= i &lt;= [&hellip;]
- [Rainbow Table](https://dixl.eu/rainbow-table/): A rainbow table is a specialized precomputed data structure engineered to solve the cryptographic challenge of reversing cryptographic hash functions for password recovery, exploiting a continuous time-memory trade-off. Unlike classical exhaustive lookup tables, rainbow tables utilize reduction functions to chain hash values back to plaintexts across multiple reduction steps, vastly minimizing the storage footprint required [&hellip;]
- [Query Expansion](https://dixl.eu/query-expansion/): Query expansion is an algorithmic technique in information retrieval designed to improve retrieval performance by augmenting an initial user query with additional, semantically related terms, synonyms, or contextual vectors. By transforming sparse or ambiguous user inputs into richer, expanded query representations via pseudo-relevance feedback, knowledge graphs, or dense embedding projections, systems bridge the vocabulary mismatch [&hellip;]
- [Quadratic Probing](https://dixl.eu/quadratic-probing/): Quadratic probing is an open-addressing collision resolution scheme in hash tables where the interval between probes is a quadratic function of the probe attempt counter. Formally, given a key mapped to an initial hash index h(k), the i-th probe index is defined as h(k, i) = (h(k) + c1 * i + c2 * i^2) [&hellip;]
- [Proof-Number Search (PNS)](https://dixl.eu/proof-number-search-pns/): Proof-Number Search (PNS) is a best-first AND-OR game tree search algorithm designed to determine the exact outcome of a game state—win, loss, or draw—under minimax rules. Unlike traditional alpha-beta pruning algorithms that traverse trees in a depth-first manner evaluating scalar heuristics, PNS treats tree expansion as a boolean logic satisfiability problem. It assigns two integer [&hellip;]
- [Phrase Search](https://dixl.eu/phrase-search/): Phrase search is a fundamental information retrieval mechanism that extends standard keyword lookups by enforcing strict adjacency and ordering constraints over terms. While boolean retrieval models match documents containing isolated tokens, phrase search demands that a sequence of query terms appear contiguously within the target document, preserving exact word order. From an algorithmic perspective, this [&hellip;]
- [Perfect Hash Function](https://dixl.eu/perfect-hash-function/): A Perfect Hash Function (PHF) is an injective mapping from a static set of n keys into a set of m integers, where m &gt;= n, guaranteeing zero collisions. When m equals n, the mapping is classified as a Minimal Perfect Hash Function (MPHF), achieving optimal space utilization. By eliminating collision resolution overhead, PHFs provide [&hellip;]
- [Parallel Metaheuristic](https://dixl.eu/parallel-metaheuristic/): A parallel metaheuristic is a high-level algorithmic framework designed to find near-optimal solutions to computationally intractable NP-hard optimization problems by concurrently exploring and exploiting search spaces across multiple processing elements. By leveraging multi-core CPUs, GPUs, or distributed clusters, parallel metaheuristics overcome the stagnation and curse of dimensionality inherent in sequential stochastic search techniques (such as [&hellip;]
- [Odor Source Localization](https://dixl.eu/odor-source-localization/): Odor source localization (OSL) is the computational and algorithmic process of determining the physical origin of a chemical substance in a fluid medium (air or water) via autonomous agents. Due to turbulent advection and molecular diffusion, chemical plumes do not form continuous concentration gradients but rather sparse, intermittent, and fragmented patches of odor interspersed with [&hellip;]
- [Null-Move Heuristic](https://dixl.eu/null-move-heuristic/): The Null-Move Heuristic (or Null-Move Pruning) is an aggressive game-tree search optimization used primarily in minimax search algorithms with alpha-beta pruning. Based on the psychological and mathematical observation that passing a turn (making a &#039;null move&#039;) in a non-zugzwang position still leaves the player with a minimax evaluation greater than or equal to their fail-high [&hellip;]
- [NewsRx: Real-Time Algorithmic News Stream Processing and Deduplication](https://dixl.eu/newsrx-real-time-algorithmic-news-stream-processing-and-deduplication/): NewsRx is an advanced algorithmic pattern and data structure pipeline engineered for high-throughput, low-latency ingestion, semantic deduplication, and topological ranking of unstructured live news feeds. Operating at the intersection of streaming data processing and metric-space indexing, NewsRx mitigates bursty message amplification and flash-crowd denial states through deterministic sliding-window reservoir sampling and MinHash-based vector quantization. 🛠️ [&hellip;]
- [Nearest Neighbor Search](https://dixl.eu/nearest-neighbor-search/): Nearest Neighbor Search (NNS) is a fundamental algorithmic optimization problem that retrieves the point in a metric space closest to a given query point. As high-dimensional vector spaces grow ubiquitous in machine learning, information retrieval, and computational geometry, exact linear scans become computationally intractable. Modern engineering demands approximate nearest neighbor (ANN) paradigms utilizing graph-based routing, [&hellip;]
- [Natural Sort Order](https://dixl.eu/natural-sort-order/): Natural sort order is an algorithmic approach to ordering strings containing embedded numeric sequences based on their arithmetic value rather than strict ASCII or Unicode scalar collation. Traditional lexicographical sorting evaluates &#039;file10.txt&#039; as preceding &#039;file2.txt&#039; because ASCII character &#039;1&#039; precedes &#039;2&#039;. Natural sorting parses contiguous digit sequences into native integer values, ensuring numeric sequences (&#039;file2.txt&#039; [&hellip;]
- [Multiplicative Binary Search](https://dixl.eu/multiplicative-binary-search/): Multiplicative binary search is an advanced algorithmic pattern tailored for unbounded, exponentially scaled, or logarithmically distributed domains. Unlike standard binary search which bisects the linear index space, multiplicative binary search scales the search bounds geometrically using multiplicative factors (such as powers of two or adaptive exponential steps), rendering it optimal for locating unknown upper bounds [&hellip;]
- [MTD(f)](https://dixl.eu/mtdf/): MTD(f) (Move-To-Depth f) is a memory-enhanced, iterative zero-window minimax search algorithm designed to compute the exact minimax value of a game tree. By framing the minimax problem as a series of repeated Alpha-Beta zero-window searches (also known as PVS or scout searches with alpha = beta &#8211; 1), MTD(f) drastically reduces the search space compared [&hellip;]
- [Move Generation](https://dixl.eu/move-generation/): Move generation is the foundational algorithmic process within discrete state-space search where an engine evaluates the current node configuration and systematically enumerates all valid legal transitions (moves) to successor states. In high-performance computational domains such as combinatorial game theory and robotic motion planning, move generation bottlenecks overall system throughput. Achieving optimal efficiency requires eliminating dynamic [&hellip;]
- [Mobilegeddon: Responsive Layout Indexing and Dynamic DOM Pruning Algorithms](https://dixl.eu/mobilegeddon-responsive-layout-indexing-and-dynamic-dom-pruning-algorithms/): Mobilegeddon refers to the foundational shift in algorithmic ranking and document evaluation introduced by search engines in April 2015, which prioritized mobile-friendly web pages. From a computer science perspective, it forced a re-engineering of automated web rendering engines, transforming static HTML document parsing into dynamic, viewport-aware layout calculation pipelines. Core algorithms must now evaluate the [&hellip;]
- [Minimax](https://dixl.eu/minimax/): Minimax is a recursive backtracking decision-making algorithm used in two-player, zero-sum, perfect-information games. It models the interaction between two adversarial agents—Maximizer and Minimizer—under the assumption that both agents act rationally to maximize their respective utilities while minimizing the opponent&#039;s. By exhaustively evaluating or heuristically bounding the game tree to a specified depth limit, Minimax computes [&hellip;]
- [Maximum Inner-Product Search](https://dixl.eu/maximum-inner-product-search/): Maximum Inner-Product Search (MIPS) is the foundational algorithmic challenge of retrieving the top-k vectors from a dataset that maximize the inner product with a given query vector. Unlike Euclidean distance ($L_2$) or Cosine similarity, the inner product does not satisfy the triangle inequality, rendering standard metric-space spatial indexes (such as standard k-d trees or ball [&hellip;]
- [MaMF: Matrix-assisted Multi-Feature Filtering](https://dixl.eu/mamf-matrix-assisted-multi-feature-filtering/): MaMF (Matrix-assisted Multi-Feature Filtering) is an advanced algorithmic pattern engineered to process high-dimensional multi-feature streams against dynamic matrix-stored threshold criteria. By transforming sequential conditional checks into optimized linear algebraic matrix operations, MaMF bypasses traditional branching penalties, maximizing CPU cache locality and leveraging SIMD (Single Instruction, Multiple Data) vectorization for near-linear performance scaling. 🛠️ HOW-TO IMPLEMENT [&hellip;]
- [Look-ahead (backtracking)](https://dixl.eu/look-ahead-backtracking/): Look-ahead with backtracking is a systematic algorithmic paradigm for traversing discrete state-space trees to solve combinatorial optimization and constraint satisfaction problems (CSPs). By combining speculative projection (look-ahead) with failure-driven state restoration (backtracking), the algorithm evaluates partial assignments, prunes unviable branches early via forward checking or arc consistency heuristics, and guarantees completeness without exhaustive enumeration of [&hellip;]
- [Locality-Sensitive Hashing](https://dixl.eu/locality-sensitive-hashing/): Locality-Sensitive Hashing (LSH) is an algorithmic paradigm designed to solve the approximate nearest neighbor (ANN) search problem in high-dimensional vector spaces. Unlike traditional cryptographic or hash-map hash functions that intentionally maximize collision rates for disparate inputs (avalanche effect), LSH families are specifically constructed to maximize the collision probability of data points that are close under [&hellip;]
- [Linear-Quadratic Regulator Rapidly-Exploring Random Tree](https://dixl.eu/linear-quadratic-regulator-rapidly-exploring-random-tree/): The Linear-Quadratic Regulator Rapidly-Exploring Random Tree (LQR-RRT) is a sampling-based kinodynamic motion planning algorithm that integrates asymptotic optimality with linear-quadratic regulator feedback controllers as local steering functions. By accounting for differential equations of motion, actuator limits, and state constraints directly within the tree expansion phase, LQR-RRT effectively navigates complex high-dimensional non-linear dynamical systems while minimizing [&hellip;]
- [Linear Search](https://dixl.eu/linear-search/): Linear search is a foundational algorithmic technique used to find a target value within a sequential data structure. It operates by sequentially inspecting each element of the collection from the beginning until the target is matched or the collection is exhausted. While theoretically inefficient for large datasets compared to logarithmic alternatives like binary search, linear [&hellip;]
- [Linear Probing](https://dixl.eu/linear-probing/): Linear probing is a cache-conscious collision resolution algorithm used in open-addressing hash tables. When a hash collision occurs at index h, the algorithm sequentially probes subsequent indices (h + 1, h + 2, &#8230;, mod capacity) until an empty slot or the matching key is found. While highly efficient due to contiguous memory allocation and [&hellip;]
- [Linear Hashing](https://dixl.eu/linear-hashing/): Linear Hashing is a dynamic hashing scheme invented by Witold Litwin in 1980 that allows hash tables to grow and shrink incrementally without the catastrophic latency spikes associated with traditional full-table rehashing. By maintaining a split pointer and utilizing a multi-phase hash function family, Linear Hashing guarantees amortized constant time O(1) performance for insertions, deletions, [&hellip;]
- [Lifelong Planning A* (LPA*)](https://dixl.eu/lifelong-planning-a-lpa/): Lifelong Planning A* (LPA*) is an incremental heuristic search algorithm that efficiently computes shortest paths between a static start vertex and a goal vertex in a graph whose edge costs change dynamically over time. Rather than recomputing a fresh path from scratch using standard algorithms like A* or Dijkstra&#039;s upon every graph modification, LPA* reuses [&hellip;]
- [Lexicographic Breadth-First Search (LexBFS)](https://dixl.eu/lexicographic-breadth-first-search-lexbfs/): Lexicographic Breadth-First Search (LexBFS) is an advanced graph traversal algorithm that refines standard breadth-first search by visiting vertices in a lexicographic order based on their previously visited neighborhoods. Originally formulated to recognize chordal graphs efficiently, LexBFS maintains an ordered partition of vertices, refining sets through history-based comparisons. Its primary strength lies in discovering structural properties [&hellip;]
- [Late Move Reductions](https://dixl.eu/late-move-reductions/): Late Move Reductions (LMR) is an advanced heuristic pruning technique utilized in minimax-based adversarial search engines. By recognizing that moves evaluated later in the move-ordering sequence are statistically less likely to cause a beta cutoff than moves evaluated early, LMR reduces the search depth for these trailing moves. This optimization significantly prunes the state space, [&hellip;]