A heap is the reflex answer to K-th largest problems, but when the whole array is already in memory, Quick Select is faster on average. The size-K heap and Quick Select mechanics, and how the shape of the data decides between them.
A managed entity from findById gets UPDATEd through dirty checking, with no save() call. The three entity states, how snapshot comparison works, what save() actually does, and the persistence context lifetime that all of it depends on.
@Transactional doesn’t work just because it’s declared. Spring wraps the bean in a proxy and intercepts only the calls that go through it. Why the annotation is silently ignored on private methods and self-invocation, and how @DataJpaTest’s test transaction hides the defect.
Union-Find gives each group a root representative and decides whether two elements share a group. The unoptimized version stretches find to O(N) on chain trees; path compression and union by rank make it practically constant.
Kahn’s BFS for topological sort repeatedly takes nodes with zero in-degree, and cycle detection comes along without extra logic. The mechanism, the Course Schedule problems, and the selection criteria against DFS post-order.
Subarray-sum problems collapse from O(N²) to O(N) along two paths — sliding window or prefix sum with a hash. Negative inputs or strict-equality conditions break monotonicity and shift the work from sliding window to prefix sum.
Round Robin and Least Connection were the standard load balancer choices for years. Yet the core algorithm that modern LBs like Envoy and AWS ALB ship as their headline option is Least Outstanding Requests, and its practical implementation is Power of Two Choices. This post traces the evolution path along which the unit of routing decisions moved from connection to request.
When the answer isn’t sitting in any array, you can still binary-search the answer itself. The parametric-search recipe — define the decision function, fix the direction of monotonicity, justify lo and hi.
MSA is a decision about which criterion to use to decompose the system. Domain boundary, data ownership, scale pattern, failure isolation — the chosen criterion creates the service boundaries, and those boundaries decide communication and data in turn.
ES and CQRS address how a system’s source of truth is shaped and how its views are separated from it. Adoption cost spreads across the system, so I lean toward adopting only when the value can be stated explicitly.
Distributed transactions are about how a single ACID transaction decomposes across services and how its pieces are reassembled. The roles and trade-offs of 2PC, Saga (Choreography vs Orchestration), and Outbox.
settings.json, CLAUDE.md, slash commands, subagents, hooks. Claude Code’s customization surface settles into four layers once you pick one criterion: when does each one step in?
alacritty + tmux + nvim + zsh + Claude Code in a single screen. The choices and structure behind a terminal-centric development environment.
Looking at JIRA’s issues and workflows as a graph of work units — covering the Sprint lifecycle, issue hierarchy, Git/GitHub integration patterns, and automation flows.
GitHub Actions seen as an event-driven automation engine — the three-layer abstraction of workflow / job / step, plus the operational details of triggers, runners, and secrets.
Looking at GitHub PRs as a collaboration layer added to Git’s change graph, and walking through the Code Review cycle, PR-level design, and merge strategies.
Looking at Git as a graph of changes — and seeing how commit hygiene, branching strategy, and the merge-vs-rebase choice are all decisions about the shape of that graph.
An SLA isn’t kept by monitoring after the fact — it’s built by design and held by operation. Once the SLI for a low-latency service becomes p99 latency rather than availability, timeout budgets, caching, degradation, isolation, and load shedding build the SLA, while p99 SLOs, burn-rate alerting, headroom, deploy gates, and the review cycle hold it.
A three-step pattern combining dual write and fallback read to transition data formats in live services without downtime.
How the CMK/DEK two-tier key structure in envelope encryption limits key leak impact and simplifies key rotation.
Which slot of the ML lifecycle each MLflow component fills, and which pieces a lightweight team can pick.
A Circuit Breaker’s trip trigger and recovery strategy must be designed together. Trip without recovery cuts the dependency permanently; recovery without a trip basis becomes meaningless cycling.
Before choosing a rate limit algorithm, the protection layer decides which algorithms are even available. This post lays out how L4/L7/Application layers and Token/Leaky/Sliding/Fixed algorithms intersect.
sklearn and ONNX aren’t competing at the same layer. Once you separate their roles, the real question becomes ‘do I need an ONNX layer at all?’
The structure and characteristics of Logistic Regression, and why an old model still serves as the baseline in CTR prediction.
Manual reload, static upstreams, weak L7 observability — four limits a static reverse proxy hits in a cloud-native environment, and the four mechanisms Envoy uses to address them.
Isolation, routing, connectivity, security — VPC’s four axes pulled into one place, framed around the decisions backend engineers actually face.
Java pairs static strong typing with JVM bytecode and adaptive JIT optimization. Python combines dynamic typing with an interpreter and declarative type hints. Go ships static structural typing and a single compiler. The type-system decision drives the runtime mechanism.
CPython’s GIL serializes multithreaded execution and pushes work onto multiprocessing or asyncio. Java pinned threads 1:1 to the OS until virtual threads (Java 21) reopened the thread-per-request model. Go shipped with an M:N scheduler from day one. The model you start from decides whether your service goes thread-per-request, reactive, or multiprocess.
These three tools often sit in the same place but solve different problems. A look at how static content, dynamic content, and traffic mediation get split among them.
All three languages use a garbage collector, but the priorities differ. Java leans on generational + region GCs (G1, ZGC), Python combines reference counting with a cyclic detector, and Go runs a single concurrent tri-color mark-and-sweep. What each GC gave up is what shapes its operational profile.
Calling a function with an object is often described as pass by reference, but in memory all three languages copy values. Java copies a reference value, Python binds a new name to the same object (call by sharing), and Go copies a struct header — escape analysis decides where the values live.
Three practical topics for operating TLS on top of the basic handshake. Session resumption and 0-RTT cut the repeated cost, mTLS authenticates the client too, and ACME automates certificate issuance and renewal.
Container orchestration basics and what backend developers need to know: core objects, networking, scaling with HPA, and operational essentials.
Go’s concurrency model builds on CSP, providing Goroutines and Channels as core tools. An overview of how each works and when to choose what.
TLS builds a secure channel over an untrusted network by providing confidentiality, integrity, and authentication. A walkthrough of symmetric/asymmetric hybrid encryption, the TLS 1.2 handshake, the certificate and PKI trust model, and what TLS 1.3 improved.
Why MongoDB and Redis end up in different roles even under the same NoSQL umbrella. A comparison across data model, storage, schema, scaling, and use cases.
Spring MVC assigns one thread per request. When I/O waits pile up, threads sit idle. WebFlux replaces this with an event loop-based non-blocking model. A summary of the structural differences from MVC, the Reactor pattern, and when to choose which.
HTTP/1.1 processes requests and responses sequentially. HTTP/2 changed this with multiplexing, binary framing, and header compression. A summary of the differences between the two protocols and gRPC, which runs on HTTP/2.
Observer cuts coupling through a one-to-many relationship that notifies subscribers of state changes. The Subject just notifies, unaware of who listens. EventEmitter, RxJS, and event-driven architecture all extend from here. It differs from broker-mediated pub/sub.
Covers container concepts, the differences from VMs, Docker’s architecture, and the basics of Dockerfile and Docker Compose.
The difference between splitting code by technical layers (horizontal) and by features or domains (vertical). Trade-offs and selection criteria for each approach.
Strategy encapsulates a family of algorithms behind a single interface and swaps them at runtime. It extends by adding a strategy instead of editing an if/switch. In languages with first-class functions, a separate Strategy class collapses into a single function.
Nest.js provides a DI container and Module system at the framework level in the Node.js ecosystem. A summary of its core design principles: IoC, DI, Module, and Provider.
Facade provides a simple entry point to a complex subsystem, cutting the coupling between the client and the internals. A service layer or a library SDK is effectively a Facade. It differs from Adapter (interface conversion) and Mediator (two-way coordination).
Layered architecture separates code into horizontal layers by technical responsibility. A summary of the four-layer structure, dependency direction rules, and how DIP decouples layers.
Core Kafka concepts (topics, partitions, consumer groups, replication) and the background behind KRaft mode, which removes the ZooKeeper dependency.
Core concepts of Hexagonal Architecture and its idiomatic implementation in Go using implicit interfaces and package structure for dependency direction control.
Decorator replaces the subclass explosion of inheritance with composition. It stacks wrappers that keep the same interface to add behavior at runtime. java.io, Python function decorators, and web middleware chains are all variations on the same intent.
Builder is the answer when three limits of constructors meet at once — many parameters, some optional, and step-wise validation. With fewer than all three, simpler tools suffice. When the language provides rich named/default parameters, the need for Builder shrinks as well.
Factory’s shared intent is separating creation from use. The three variants — Factory Method, Abstract Factory, and Static Factory Method — split creation differently and suit different conditions. Static Factory Method is the variant most often encountered in practice, and DI containers absorb part of Factory’s explicit role.
Singleton is one of the simplest patterns but the canonical anti-pattern debate. The decision to bundle single-instance guarantee with global access into one pattern causes tight coupling and test difficulty. DI is the general alternative that separates the two intents.
DIP (principle), IoC (pattern), and DI (technique) sit at different levels of abstraction. The hierarchy must be clear before framework features and design principles can be told apart.
Cache patterns split along two axes — who fills the cache on a miss, and where writes go. The five canonical patterns (cache-aside, read-through, write-through, write-back, refresh-ahead) are combinations of choices along those two axes.
A transaction gives atomicity, a lock gives serialization — they aren’t substitutes. How pessimistic and optimistic locking cover the Lost Update that an isolation level’s plain reads don’t, and how to choose between them.
A transaction isolation level is a policy choice about which anomalies to allow. The anomalies each ANSI level prevents, and how InnoDB’s MVCC and Repeatable Read behave differently from the standard.
What each of the four ACID properties actually guarantees in an RDB transaction. A/C/D are relatively clear guarantees, but only I has ’levels’ — the gateway to the correctness vs. concurrency trade-off.
Two transport protocols that backend developers encounter constantly. A summary of TCP and UDP — connection establishment, reliability guarantees, flow/congestion control mechanisms, and selection criteria.
L2 switch, L3 routing, L4/L7 load balancer — where the layer numbers attached to everyday networking terms come from. How the OSI model maps to TCP/IP, and what each number refers to.
HTTP is stateless. Maintaining user authentication requires storing state somewhere. This post covers the structure, trade-offs, and storage strategies of server-side sessions and client-side JWT tokens.
There was a time I called JWT an authentication method and said I logged in with OAuth, and the terms kept blurring together. This post lines up Basic, Digest, API Key, Session, Token, OAuth, OIDC, and SSO by two questions: authentication vs authorization, and where the proof of identity lives.