September 2026

Reservoir Sampling:One Pass When You Do Not Know n Up Front

Keep the first k items, then for each later index i (1-based), replace a slot with probability k/i — a uniform sample of k from a stream of unknown length.

Algorithms

Binary Exponentiation:pow(base, exp) in Logarithmic Multiplies

Square the base and consume the exponent bit by bit — O(log exp) multiplies instead of a loop of exp products, for integers or modular pow.

Algorithms

Fisher-Yates:Shuffle in Place Without Bias

For i from n-1 down to 1, swap a[i] with a uniform index in 0..i — every permutation equally likely, which is what Collections.shuffle already runs.

Algorithms

Euclid GCD:Subtract, Then Mod, Then Extended Coefficients

Replace repeated subtraction with remainder, then back-substitute for Bézout coefficients — gcd, lcm, and a modular inverse when gcd is 1.

Algorithms

Count-Min Sketch:Approximate Frequencies When Exact Maps Do Not Fit

d × w counters and the min over hashes: over-estimate frequencies on purpose when a HashMap of every key will not fit.

Java

Pick the Collection:Nulls, Order, Threads, and the Hot Operation

A decision guide for the Java Collections series: given the hot operation, null policy, encounter order, and whether another thread looks — which JDK type to new.

Algorithms

Aho-Corasick:Many Patterns, One Pass Over the Text

Build a trie of all needles, add failure links like KMP on a forest, then scan the haystack once — every pattern that ends at the current character reports.

Algorithms

HyperLogLog:Approximate Distinct Count in Tiny Memory

Estimate cardinality with a handful of registers and a harmonic mean — plus-or-minus is the point, not a HashSet of every key.

Java

Sequenced Collections:First, Last, and Reversed Without the Ceremony

Learn how Java 21 sequenced collections provide uniform first, last, and reversed operations across lists, deques, ordered sets, and ordered maps.

Algorithms

Boyer-Moore:Skip Ahead When the Mismatch Is Near the End

Align the pattern at the window end, use a bad-character skip (and the good-suffix idea) so a late mismatch jumps the haystack instead of sliding by one.

Design Patterns

Interpreter:Represent a Grammar and Evaluate It

Model a tiny promo DSL as AND/OR of percent-off and sku-in-category expressions that evaluate(Order), and skip it when a few ifs or a real parser would be honest.

Algorithms

Raft:Elect a Leader and Replicate a Log (Awareness, Not a From-Scratch Cluster)

Raft terms, leader election, and log replication at awareness depth — enough to know what etcd and Kafka-adjacent consensus are doing, not enough to ship your own cluster.

Design Patterns

Visitor:Add Operations Without Changing the Elements

Add CSV export and tax walks to a stable Sku / Category tree with accept(Visitor) so each new report is a class, not another method on every catalog type.

Algorithms

Rabin-Karp:Rolling Hash When You Need Many Pattern Checks

Slide a window hash in O(1), compare hashes first, then verify characters — the procedure for one needle or many needles against the same haystack.

Design Patterns

Prototype:Copy an Object Instead of Reconstructing It

Clone a configured DiscountPolicy, ChargeRequest, or gateway test double in Java instead of rebuilding constructor arguments — and skip clone() when new is cheaper or the copy shares mutable guts.

Algorithms

Two-Phase Commit:All Prepare, Then All Commit — and Why It Blocks

A coordinator asks every participant to prepare, then commit or abort together — and why a crashed coordinator leaves the cluster stuck.

Design Patterns

Memento:Snapshot State Without Breaking Encapsulation

Undo a checkout draft in Java by letting Order take an opaque snapshot — no public fields, no JSON dump, and no serializing OrderProcessor.

Design Patterns

Mediator:Keep Colleagues from Talking to Each Other

Stop DiscountPolicy, PaymentGateway, fraud, inventory, and the notifier from importing each other by letting CheckoutMediator own the checkout conversation.

Algorithms

Exponential Backoff:Retry With Jitter Instead of a Thundering Herd

Wait base × 2^attempt after a failure, cap the wait, and add jitter so retries do not stampede the same instant.

Design Patterns

Flyweight:Share What Does Not Change

Share immutable catalog SKU metadata across cart LineItems so a Black Friday order does not clone name, tax class, and image URL on every row.

Algorithms

Leaky Bucket:Smooth Bursts Into a Steady Drain

Queue work into a bucket that leaks at a constant rate — overflow is dropped or the caller waits. Smooth output, not a stored burst of tokens.

Design Patterns

Bridge:Split Abstraction from Implementation

Stop the Email×SendGrid / SMS×Twilio subclass grid by letting OrderNotifier hold a MessageSender so channels and vendors vary independently.

Algorithms

KMP:Find a Pattern Without Sliding Back on the Text

Build the LPS prefix table, then scan the text once — on a mismatch the pattern jumps using already-matched prefix, so the text index never retreats.

Design Patterns

Iterator:Walk a Collection Without Exposing Its Guts

Stop walking Order line items with get(i) on a leaked ArrayList so a switch from list to a SKU tree does not rewrite OrderProcessor.

Algorithms

Token Bucket:Allow Bursts, Then Enforce an Average Rate

Refill tokens at a steady rate, spend one per request, and allow a burst up to bucket capacity — then reject or wait.

Design Patterns

Abstract Factory:Families of Objects Without Naming the Concrete Types

Build Stripe-region and Razorpay-region checkout families in Java so gateway, webhook parser, and money type vary together without OrderProcessor naming the concretes.

Algorithms

Prim:Grow an MST From a Seed Vertex

Grow a min-heap of crossing edges from a seed until every vertex is in the tree — a Dijkstra-shaped frontier for an MST, not distances from a source.

Design Patterns

Chain of Responsibility:Pass a Request Until Someone Handles It

Replace a hard-coded fraud-inventory-payment-notify sequence with a Handler chain in Java so a new checkout step is a class you splice in, not a next-type you edit.

Algorithms

Consistent Hashing:Move Few Keys When a Node Joins or Dies

Place keys on a ring so adding or removing a node remaps only its neighbors — not every key — with virtual nodes to even the load.

Design Patterns

State:Change Behavior When Internal State Changes

Replace a growing DRAFT / PAID / REFUNDED / VOID switch in process, refund, and void with OrderStatus objects that own legal transitions, so OrderProcessor stops being the state machine.

Algorithms

Backtracking:Search With Undo When the Next Choice Depends on the Last

Choose, recurse, undo: search a decision tree with pruning when the next pick depends on the path — not a second knapsack table.

Design Patterns

Composite:Treat Trees of Objects as One

Replace nested loops over Outdoor / Hiking / SKUs with a CatalogNode tree so a category and a single product both answer subtotal(), and OrderProcessor still charges one payable.

Design Patterns

Proxy:Stand In for an Object You Cannot Touch Directly

Put a PaymentGateway proxy in front of a slow SDK so OrderProcessor still calls charge, while lazy init, an auth check, and a last-result cache decide whether the real gateway runs.

Linux

Linux strace:See What a Stuck Process Is Waiting On

Hands-on strace recipes — attach to a PID, follow children, filter syscalls, and read the wait that logs never mentioned.

Algorithms

Interval Scheduling:Always Take the Finish That Frees the Room Soonest

Pick a maximum subset of non-overlapping intervals by earliest finish time — greedy that throws ranges away, not merge-intervals.

Design Patterns

Command:Turn a Request into an Object

Turn charge, refund, and capture into Java objects you can queue, retry, undo, or audit — without wrapping a one-shot process() in ceremony.

Linux

Linux tar and gzip:Archive, Compress, and Restore Without Corrupt Surprises

Hands-on tar and gzip recipes — create an archive, inspect it before extract, compress with gzip, and restore without clobbering the wrong tree.

Design Patterns

Facade:One Simple Front for a Messy Subsystem

Hide checkout’s discount, payment, fraud, and tax conversation behind one CheckoutFacade.place(Order) so controllers stop assembling the subsystem.

Java

Primitive Types in Patterns:instanceof and switch Without the Wrapper Dance

Try JEP 532 in JDK 27: use primitive patterns with instanceof, switch directly on long, float, double, and boolean, and reject lossy conversions without hand-written casts.

Linux

Linux cut, sort, uniq, and tr:Shape Text Before You Pipe to awk

Hands-on text-prep recipes — slice columns, sort keys, count uniques, and translate characters before you reach for awk or sed.

Algorithms

LZ77 and DEFLATE:Sliding-Window Compression Behind zip and gzip

Find repeated phrases in a sliding window as length-distance pairs, then Huffman-code the tokens — that pairing is DEFLATE, not Huffman alone.

Design Patterns

Template Method:Freeze the Skeleton, Vary the Steps

Freeze a shared Java payment sequence so capture, refund, and void keep one skeleton and only the provider step (and hooks) vary.

Linux

Linux ssh, scp, and Port Forwarding:Reach a Remote Box Without Guesswork

Hands-on SSH recipes — keys and config, copy files with scp, and tunnel a port without memorizing every flag.

Algorithms

Huffman Coding:Build a Prefix Code From Frequencies

Build a prefix-free code from symbol frequencies with a heap: greedy merges, why it is optimal here, and why this is not DEFLATE.

Design Patterns

Singleton:One Instance, Used Carefully

Keep a process-wide resource as an enum singleton only when you can name why there must be one, and inject Clock, config, and gateways into OrderProcessor instead of AppContext.getInstance().

Java

Lazy Constants:Initialize Once Without the Double-Checked Lock

Try JEP 531 in JDK 27: LazyConstant.of, List/Map/Set.ofLazy, and one-time thread-safe init the JIT can constant-fold — without double-checked locking.

Linux

Linux cron and systemd Timers:Run Jobs on a Schedule You Can Trust

Hands-on crontab and systemd timer recipes — schedule a job, choose calendar vs boot delays, and find the run that never fired.

Algorithms

Edit Distance:Insert, Delete, Substitute as a Costed Grid

Levenshtein distance on a DP grid: insert, delete, substitute, and recover one alignment — related to LCS, a different job.

Design Patterns

Builder:Assemble Complex Objects Step by Step

Replace a telescoping ChargeRequest constructor with a Java builder so required checkout fields stay required, optional ones stay optional, and the product can still be a record.

Linux

Linux systemctl:Start, Stop, and Debug systemd Units

Hands-on systemctl recipes for everyday work — inspect units, start and stop services, enable at boot, and debug failed units without guessing.

Design Patterns

Adapter:Make Incompatible Types Talk

Wrap a vendor client whose methods do not match PaymentGateway so OrderProcessor keeps calling charge(Order, BigDecimal) and never learns PayPal’s shape.

Git

Find the Break:git bisect When Something Stopped Working

Hands-on git bisect — binary-search commits to find the first one that broke a working check, then reset HEAD and optionally automate the walk.

Git

Cherry-Pick:Move One Commit Without Merging the Branch

Copy one commit onto another branch — bring a hotfix from main onto your feature without merging the rest of main.

Git

Review Before Merge:Pull Requests on the Host Without the Guesswork

Open a pull request, read the host diff, merge on GitHub or GitLab, then pull main locally so review happens before the default branch moves.

Git

Git Rebase:Replay Your Branch Without a Merge Commit

Hands-on Git rebase — fetch an updated main, replay your feature commits on top of it, and skip the extra merge commit.

Git

Reset Too Far:Recover Commits With git reflog

Hands-on Git — recover a commit after a reset that went too far, using git reflog to restore HEAD or create a recovery branch.

Git

Git Stash:Park Uncommitted Work Without a Fake Commit

Hands-on Git stash — park a dirty working tree, switch branches, and restore the work without a fake WIP commit.

Java

Your Key Vanished From the Map:`equals` and `hashCode` Without the Interview Checklist

Implement equals and hashCode so HashMap and HashSet can find the key you put — Object contract, records, and why a mutable id loses the entry.

Java

Exceptions:Checked, Unchecked, and When `throw` Beats `return`

Choose throw over a sentinel return, close resources with try-with-resources, and wrap checked exceptions at lambda boundaries instead of swallowing them.

Java

Generics:Write `List<Order>` Once and Mean It

Use Java generics so List of Order stays a list of orders — type parameters, PECS, erasure, and why raw types still compile.

Java

JUnit 5:Assert Behavior Before You Slice Spring

Prove an Order pricing rule with plain JUnit 5 — assertions, parameterized tests, and lifecycle — before you reach for a Spring test slice.

Java

`java.nio.file`:Paths, Copies, and Walks Without the Old IO Soup

Use Path and Files to read, copy, and walk directories in the JVM — without new File soup and without turning this into a Linux CLI tutorial.

Spring Boot

Spring Cache:Stop Querying for the Same Order Twice

Cache order reads with Spring @Cacheable and in-process Caffeine, evict on update, and keep JPA entities out of the cache.

Spring Boot

Flyway Without the `ddl-auto` Roulette

Version the orders schema with Flyway SQL migrations, turn off Hibernate ddl-auto outside local experiments, and prove the script with Testcontainers.

Spring Boot

When `@Valid` Fails, the Body Should Help:Problem Details and `@ControllerAdvice`

Turn Bean Validation failures and domain exceptions into RFC 7807 ProblemDetail responses with @ControllerAdvice so API clients get a body they can actually use.

Spring Boot

Profiles and Secrets:Stop Baking Production Into the Jar

Split Spring Boot config by profile, bind settings to a @ConfigurationProperties record, and inject secrets from the environment instead of committing them in the jar.

Spring Boot

RestClient After RestTemplate:One Client, Bounded Waits, Errors You Handle

Replace ad-hoc HTTP calls with Spring Boot 3 RestClient: inject the managed Builder, set timeouts, map JSON to records, and handle status codes without RestTemplate ceremony.

Algorithms

LIS:Longest Increasing Subsequence in n log n

Longest increasing subsequence: the O(n²) best-ending-here table, then patience / tails plus binary search for n log n.

Design Patterns

Decorator:Add Behavior Without Subclassing the Core

Replace AuditedRetryingCachedGateway subclasses with PaymentGateway wrappers you compose at the edge — logging, retry, cache — without a new type per combination.

Algorithms

LCS:Longest Shared Subsequence Without Requiring Contiguous

Find the longest common subsequence of two strings with a DP grid: match or skip, then reconstruct one shared sequence.

Design Patterns

Observer:Notify Dependents When Something Changes

Stop editing OrderProcessor for every new notification channel by publishing a payment event and letting EmailNotifier and AuditLog subscribe.

Design Patterns

Factory Method:Let Subclasses Decide Which Object to Build

Move construction of DiscountPolicy and PaymentGateway behind a polymorphic creator so six controllers stop naming PercentOff and StripeGateway.

Java

PEM Encodings:Keys and Certs Without the Internal Parser

What the Java 27 PEM API is (JEP 538): encode and decode keys, certificates, and CRLs with PEMEncoder and PEMDecoder — no BouncyCastle, no sun.security.util.

Algorithms

Coin Change:Unbounded Combinations When the Item Can Repeat

Make change when each denomination may be used again: min-coins and count combinations, and why this is not 0/1 knapsack.

Design Patterns

Strategy Pattern:Swap Algorithms Without Editing Callers

Replace a growing discount if/else with a Strategy in Java so each new promotion is a class you add, not a branch you edit into OrderProcessor.

Java

AOT Caches:Faster Startup Without a Native Image

What Leyden AOT caches are (JEP 483, 514, 515, 516): train a HotSpot cache, then start faster and warm up sooner — still a JVM, not a GraalVM native image.

Algorithms

0/1 Knapsack:Pick or Skip When Each Item Exists Once

Fill a capacity with pick-or-skip DP: each item once, a 2D table or a 1D roll, and how to reconstruct which items went in.

Design Patterns

Design Patterns Roadmap:Pick the Right Pattern for the Pain You Have

A map of creational, structural, and behavioral patterns — what pain each one solves, when to skip it, and links to every post in this series.

Java

Post-Quantum TLS:Hybrid Key Exchange Before the Quantum Deadline

What Java 27 JEP 527 is: hybrid ML-KEM + ECDHE named groups in TLS 1.3 so JSSE sessions survive store-now-decrypt-later — without writing crypto.