Solving problems with code, sharing practical tech insights, and leveling up together!
This article dissects the classic Go interview problem of printing numbers and letters alternately (1a2b…26z), explains why sleep‑based solutions fail, details deadlock and token‑count pitfalls, and presents a robust dual‑channel token relay implementation with step‑by‑step code and three key takeaways.
The article explains how to reliably predict the output of Go channel interview questions by drawing execution timelines, distinguishing synchronization points from print order, handling buffered vs unbuffered channels, and spotting deadlocks, providing four concrete heuristics backed by code examples and runtime observations.
This article reviews ten frequent misuses of Domain‑Driven Design—ranging from over‑engineering simple CRUD apps to misusing layers, aggregates, services, repositories, and events—provides concrete counter‑examples, explains why they happen, and offers practical corrective guidelines plus a self‑check checklist.
The article explains why traditional two‑phase commit (2PC) is unsuitable for micro‑service workflows, introduces the Saga pattern as a series of local transactions with compensations, compares orchestration‑based and choreography‑based implementations, and provides concrete design guidelines, code samples, and state‑machine persistence strategies.
The article walks through a real‑world payroll system, showing how to evolve from simple interface separation to full event‑driven read‑model synchronization using CQRS, explaining when to adopt each stage, the trade‑offs, code examples, and common anti‑patterns.
The article explains how a Repository differs from a DAO by focusing on aggregates instead of tables, shows proper interface design, PO‑to‑aggregate mapping, read/write separation, CQRS basics, and JPA pitfalls, providing concrete Java code examples for Spring Boot projects.
Using a real‑world salary‑calculation module, the article shows how to separate Domain Services, Application Services, and Infrastructure in DDD, explains the responsibilities of each layer, provides concrete code refactorings, and offers practical questions to decide where new logic belongs.
The article examines a payroll bug caused by exposing internal collections, then explains three immutable‑focused rules for aggregate roots—expose only through the root, keep each transaction to a single aggregate, and reference other aggregates by ID only—showing how proper design prevents consistency errors, performance loss, and concurrency conflicts in Spring Boot applications.
The article explains that an Entity is distinguished by a unique identifier while a Value Object is defined solely by its attributes and must be immutable, illustrating the concepts with Java Entity, record, and JPA mapping examples, and providing three practical questions to decide which to use.
The article analyzes the pitfalls of synchronous calls in a payroll microservice, defines domain events and their naming conventions, compares them with message‑queue messages, and presents two concrete implementations—Spring ApplicationEvent for intra‑process decoupling and RocketMQ with a transactional outbox for cross‑process communication—while also clarifying when event sourcing is appropriate.
