May 2026

Hash Tables:Buckets, Collisions, and When `HashMap` Lies About O(1)

How hashing maps a key to a bucket, what chaining and open addressing do with collisions, and why HashMap is expected O(1) — not a law of physics.

Data Structures

Deque:Both Ends Without Two Structures

A double-ended queue lets you push and pop at both ends in O(1). How ArrayDeque delivers that in the JDK, and when a deque is a stack, a queue, or a sliding window.

Data Structures

Queue:FIFO, Circular Buffers, and Why a Naive Array Queue Rotates

FIFO as an ADT: enqueue, dequeue, and why a naive array queue slides or wastes space — and how a circular buffer (ring) fixes both.

Linux

Linux dmesg:Read the Kernel Ring Buffer

Hands-on dmesg recipes for everyday work — inspect boot messages, chase hardware faults, filter by level, and watch the kernel live.

Data Structures

Stack:Undo, Parse, and Call Frames Are the Same Shape

LIFO as an ADT: push, pop, peek, and why undo, brace matching, and the call stack are the same layout — implemented with ArrayDeque, not java.util.Stack.

Data Structures

Linked Lists:Singly, Doubly, and Circular Without Losing the Head

How node-and-pointer lists make splice cheap when you already hold the node, why get(i) walks, and how singly, doubly, and circular variants differ.

Data Structures

Dynamic Arrays:Amortized Growth Without Pretending Append Is Always O(1)

How ArrayList grows by doubling, why append is amortized O(1) not a guarantee on the next call, and when a fixed array is the honest choice.

Linux

Linux top, htop, and btop:Watch CPU, RAM, and Load

Hands-on top, htop, and btop recipes — read load averages, find CPU and memory hogs, and triage a busy box in real time.

Data Structures

Arrays:Why Index `i` Is Free and Insert in the Middle Is Not

How a contiguous array makes index i O(1), why insert and delete in the middle slide everything, and how a 2D matrix is still the same layout.

Data Structures

Data Structures Roadmap:What to Learn from Arrays to Tries

A beginner-to-advanced path through data structures: glossary, Big-O literacy, a JDK map, and a living index of every post in this series.

Java

Text Blocks:Multiline Strings Without the Concatenation Soup

Java 15 text blocks (JEP 378): triple-quote multiline strings, incidental indentation, and escape sequences — JSON, SQL, and HTML without + concatenation.

Java

Switch Expressions:Return a Value Without the Break Ritual

Java 14 switch expressions (JEP 361): arrow cases, yield, exhaustiveness — return a value without fall-through breaks. Pattern switch lives in a later post.

Linux

Linux find:Locate Files by What You Know

Hands-on find recipes for everyday work — hunt by name, type, size, and time, then act on matches with confidence.

Java

HttpClient:Talk HTTP Without a Third-Party Stack

Use Java 11 java.net.http.HttpClient for HTTP/1.1 and HTTP/2 — builder, sync and async send, body handlers — without Apache HttpClient or OkHttp for ordinary calls.

Java

Local-Variable Type Inference:When `var` Clarifies and When It Hides

Java 10 var (JEP 286): use local-variable type inference when the right-hand side already names the type, and skip it when var hides what the reader needs.

Java

Java Modules:What `module-info.java` Actually Buys You

What JPMS (JEP 261) actually buys: explicit exports, requires, and a smaller runtime — not a file you copy into every repo. import module is a later language convenience.

Java

CompletableFuture:Compose Async Work Without Callback Hell

Compose async Java work with CompletableFuture — supplyAsync, thenApply, thenCompose, allOf — without nested callbacks, and when virtual threads are the simpler path.

Java

java.time:Dates Without Calendar and SimpleDateFormat

Replace Calendar and SimpleDateFormat with java.time — Instant, LocalDate, ZonedDateTime, formatting, and a Clock you can fake in tests.

Linux

Linux awk:Slice Fields and Summarize Streams

Hands-on awk recipes for everyday work — pick columns, filter rows, change separators, and compute totals in pipelines.

Java

Optional:Return Absence Without Null and Without Wrapping Every Call

Use java.util.Optional to return absence without null — of/ofNullable, map/flatMap/filter, orElse vs orElseGet, and when wrapping every call is cargo-cult.

Java

Primitive Functional Interfaces:Skip the Box on the Hot Path

Use java.util.function’s primitive SAM grid to skip boxing on hot numeric paths, fill IntStream slots, and leave ToIntFunction out of ordinary application code.

Java

Bi-Arity:Two Arguments Without a Pair Type

Use BiFunction, BiPredicate, and BiConsumer for two-argument slots — apply, test, accept — and fill Map.merge, compute, and forEach without inventing a pair type.

Linux

Linux grep:Search Files Like You Mean It

Hands-on grep recipes for everyday work — find text, filter logs, search codebases, and pipe results with confidence.

Java

Unary and Binary Operators:Same Type In, Same Type Out

Use UnaryOperator and BinaryOperator when input and output are the same type — List.replaceAll, Stream.reduce, Collectors.reducing, and minBy / maxBy.

Java

Supplier:Produce a Value When Asked

Use Java’s Supplier<T> for lazy values — get, orElseGet, factories, supplyAsync — so you do not build work until something actually needs the result.

Java

Consumer:Accept a Value for a Side Effect

Use Java’s Consumer<T> for side effects — accept, andThen — and see where Stream.forEach, Optional.ifPresent, and peek already ask for it.

Java

Predicate:Ask a Yes/No Question You Can Combine

Use Java’s Predicate<T> to test values — test, and, or, negate, isEqual, Predicate.not (Java 11) — and see where Stream.filter, anyMatch, and removeIf already ask for it.

Linux

Linux Common Directories:Know Where Things Live

Learn the Linux filesystem hierarchy — what /, /etc, /var, /usr, /home and friends are for, and when to look in each one.

Java

Function:Turn T into R Without a One-Off Interface

Use Java’s Function<T,R> to map values — apply, compose, andThen, identity — and see where Stream.map, Optional.map, and Collectors already ask for it.

Java

Functional Interfaces Roadmap:The Four Shapes Behind Every Lambda

What a Java functional interface is, the four shapes in java.util.function, when to write your own SAM type, and a living map of every post in this series.