Articles tagged with #Software Engineering
A curated list of engineering series, deep dives, and notes related to #Software Engineering.
Building a Custom In-Memory Data Store in Java: The Collections Capstone
Build a production-grade in-memory key-value database in Java from scratch using custom data structures: HashMaps, LRU caches, priority queues, and SkipLists.
Java Specialized Queues: SynchronousQueue Handoffs & DelayQueue Expiration
Master Java SynchronousQueue and DelayQueue internals. Learn zero-capacity thread handoffs and how Delayed Min-Heaps power task schedulers.
Lock-Free Sorted Range Queries: ConcurrentSkipListMap & SkipLists in Java
Learn how ConcurrentSkipListMap uses SkipLists and atomic CAS pointers to deliver lock-free sorted range queries across 64+ CPU cores in Java.
Java BlockingQueue Performance: ArrayBlockingQueue vs LinkedBlockingQueue
Compare ArrayBlockingQueue vs LinkedBlockingQueue in Java. Learn how dual-lock splitting eliminates contention in multi-threaded task queues.
Java IdentityHashMap Internals: Reference Equality & Open Addressing Probing
Learn how Java IdentityHashMap uses reference equality (==) and flat array linear probing to prevent infinite recursion in object graph serializers.
Java WeakHashMap Internals: Preventing Memory Leaks with Weak References
Explore how Java WeakHashMap uses WeakReference keys and ReferenceQueue polling to prevent memory leaks in caches and plugin frameworks.
High-Performance Java: How EnumSet and EnumMap Achieve Zero-Allocation Speed
Discover why EnumSet and EnumMap are the fastest collections in Java. Learn how 64-bit long bitmasks execute set operations in 1 CPU cycle.
Building a Real-Time Event-Driven Order System with Apache Kafka
Build an end-to-end event-driven microservices architecture in Java using Apache Kafka, Schema Registry, Avro, Dead Letter Topics, and Kafka Streams.
The Master System Design Framework: 4-Step Methodology for Senior & Staff Architect Interviews
Master the 4-step System Design interview framework. Learn requirement scoping, back-of-the-envelope estimation, and architecture deep dives.
Frontend System Design Interview Framework: Component Topology, Data Flow, and Scalability
Master the 4-step Frontend System Design Interview Framework. Learn component topology, API contract design, state data flow, and scalability.
Java ConcurrentHashMap Internals: Lock-Free CAS & Fine-Grained Bucket Sync
Deep dive into Java 8+ ConcurrentHashMap internals. Learn how lock-free CAS, volatile reads, and bucket-level synchronized locks handle high concurrency.
Operating Kafka in Production: Critical JMX Metrics, Kernel Tuning & Runbooks
SRE runbook for operating Kafka in production. Monitor critical JMX metrics (UnderReplicatedPartitions, ConsumerLag), tune Linux sysctl, and troubleshoot outages.
Java Concurrent Collections: CopyOnWriteArrayList vs Unmodifiable vs List.of()
Compare Fail-Fast vs Fail-Safe collections in Java. Learn CopyOnWriteArrayList memory mechanics and the difference between List.of() and unmodifiable wrappers.
Kafka Connect vs Kafka Streams: Zero-Code ELT Pipelines vs Real-Time Analytics
Compare Kafka Connect vs Kafka Streams. Learn when to use zero-code ELT connectors versus in-process Java stream processing with embedded RocksDB.
Java PriorityQueue Internals: Building a Min-Heap Array from Scratch
Build a custom PriorityQueue in Java using a flat Min-Heap array. Learn parent-child index formulas, siftUp, and siftDown algorithms.
Kafka Schema Registry & Avro: Guarding Against Breaking Payload Changes
Prevent production microservice crashes with Confluent Schema Registry and Apache Avro. Learn 5-byte wire format headers and compatibility modes.
Java TreeMap Internals: Building a Navigable Sorted Map from Scratch
Build a custom TreeMap in Java. Learn how NavigableMap range queries and custom Comparators maintain sorted keys in O(log N) time.
Kafka Exactly-Once Semantics (EOS): Idempotent Producers & 2PC Transactions
Learn how Kafka achieves Exactly-Once Semantics (EOS) across read-process-write stream loops using Idempotent Producers, Transactional Coordinators, and 2PC.
Red-Black Tree Rotations Explained: Self-Balancing Trees in Java
Demystify Red-Black tree rotations and recoloring. Understand how Java TreeMap and HashMap maintain O(log N) balance guarantees.
Kafka KRaft Consensus Mode: Replacing ZooKeeper for Million-Partition Scale
Understand KIP-500 and KRaft mode in Kafka. Learn how self-managed Raft metadata consensus eliminates ZooKeeper and unlocks million-partition scale.
Building a Binary Search Tree (BST) in Java: Recursive Operations & Range Queries
Implement a Binary Search Tree in Java. Learn recursive insertion, in-order traversal for sorted data, and why skewed trees degrade.
Kafka Partition Replication: High Watermark, LEO & In-Sync Replicas (ISR)
Learn how Kafka achieves high availability without data corruption using leader/follower replication, High Watermarks, ISR tracking, and Leader Epochs.
Building a Custom LRU Cache in Java Using LinkedHashMap
Build an LRU Cache in Java in 10 lines of code by extending LinkedHashMap and leveraging access-order doubly linked entry pointers.
Kafka Consumer Rebalancing: Eager Storms vs Cooperative Sticky Assignors
Eliminate stop-the-world consumer processing outages in Kafka. Compare legacy Eager Rebalancing with modern Cooperative Sticky Assignors.
How Java HashSet Works Under the Hood: Building a Set via Composition
Discover how Java HashSet uses composition to wrap HashMap key uniqueness, spending zero extra memory on static dummy value references.
Kafka Offset Management: Manual Commits, __consumer_offsets & Message Replay
Master Kafka offset management and delivery semantics. Implement manual commits to achieve At-Least-Once processing and seek historical offsets.
Java HashMap Internals (Part 2): Load Factor, Resizing & Red-Black Treeification
Learn how Java HashMap resizes its bucket table when reaching load factor threshold, and how JDK 8 treeifies long bucket chains.
Kafka Consumer Groups & Pull Model: Scale-Out Processing Without Lock Contention
Learn how Kafka Consumer Groups scale out event processing. Understand why Kafka uses a Pull Model for native backpressure protection.
Java HashMap Internals (Part 1): Hashing Functions, Buckets & Separate Chaining
Deep dive into Java HashMap internals. Learn how hash functions, bitwise masking, and separate bucket chaining store key-value pairs.
Kafka Producer Reliability: Balancing acks=all, min.insync.replicas & Data Loss
Understand Kafka producer durability trade-offs. Configure acks=all and min.insync.replicas=2 to guarantee zero data loss on critical event streams.
Building a Double-Ended Queue (Deque) in Java for Sliding Window Algorithms
Implement a custom ArrayDeque in Java for dual-ended operations. Solve sliding window maximum algorithms in O(1) time.
Kafka Partition Routing: MurmurHash2 Keys, Sticky Partitioning & Idempotence
Master Kafka message ordering. Learn how MurmurHash2 routes keyed records, how Sticky Partitioning optimizes null keys, and how idempotence fixes out-of-order retries.
Why Spring Boot Exists: Eliminating XML Configuration and Dependency Hell
Trace the architectural history of Spring Framework from XML bean wiring and WAR deployments to Spring Boot opinionated starter dependencies.
Building a Circular Queue in Java: Array Ring Buffers and Modulo Math
Build a high-performance circular array queue in Java. Eliminate O(N) array shifts using modulo arithmetic head and tail pointers.
Kafka Producer Internals: Tuning RecordAccumulator, batch.size & linger.ms
Deep dive into KafkaProducer mechanics. Learn how RecordAccumulator, batch.size, linger.ms, and ZSTD batch compression maximize streaming throughput.
The InnoDB Buffer Pool: Dirty Pages, LRU Eviction, and LSN Checkpointing
Learn how MySQL InnoDB Buffer Pool caches 16KB data pages, evicts cold pages via midpoint LRU algorithms, and flushes dirty pages asynchronously.
Building a Custom Java Stack: LIFO Mechanics & Why Legacy Stack is Broken
Build a custom LIFO Stack in Java. Learn why java.util.Stack is obsolete and how ArrayDeque provides better performance.
Kafka Storage Internals: Log Segments, Sparse Indexes & Log Compaction
Learn how Kafka locates any message in microseconds using sparse memory-mapped index files (.index) and prunes stale keys using Log Compaction.
Write-Ahead Logging (WAL) & ARIES Crash Recovery: How Databases Guarantee Durability
Learn how Write-Ahead Logging (WAL) and the ARIES algorithm guarantee zero data loss during power outages and system crashes.
Java Iterator and modCount: How Fail-Fast Iteration Prevents Data Corruption
Explore how Java iterators use modCount to throw ConcurrentModificationException and prevent silent data corruption during list traversal.
Kafka Zero-Copy Optimization: How sendfile() Streams Millions of Events/Sec
Discover how Kafka uses Java NIO transferTo() and Linux sendfile() Zero-Copy optimization to stream gigabits of data per second with minimal CPU load.
Demystifying ACID: Transactions as an Isolation & Recovery Abstraction
Deconstruct ACID transaction guarantees in database engines. Learn how atomicity, consistency, isolation, and durability function under the hood.
Java LinkedList Internals: Building a Doubly Linked List from Scratch
Learn how Java LinkedList works under the hood by building a doubly linked list. Compare ArrayList vs LinkedList performance trade-offs.
Kafka Architecture Deep Dive: Topics, Partitions, and Offset Ordering Rules
Deconstruct Kafka storage anatomy: Topics, Partitions, and Offsets. Learn how partition sharding scales write throughput and consumer parallelism.
The B+ Tree Deep Dive: Why Database Indexes Use Balanced Trees Instead of Hash Maps
Discover why database storage engines use B+ Trees for primary and secondary indexes. Learn how high fan-out page nodes enable range scans in 3 disk IOs.
How Java ArrayList Works Internally: Building a Dynamic Array from Scratch
Build a custom ArrayList in Java from scratch. Understand dynamic array resizing, System.arraycopy performance, and garbage collection.
The Append-Only Log Abstraction: Why Immutability Rules Event Streaming
Explore the append-only log data structure behind Apache Kafka. Learn how immutability enables lock-free concurrency and multi-team data replay.
Pages, Blocks, and Heap Files: How Database Storage Engines Layout Data on Disk
Explore how database engines organize table data on disk using 16KB Slotted Pages, slot offset arrays, tuple headers, and Record IDs.
Java equals() and hashCode() Contract: Avoiding Silent HashMap Bugs
Learn the unbreakable contract between equals() and hashCode() in Java to prevent silent HashMap lookup bugs and memory leaks.
Kafka Performance Secrets: Why Sequential Disk I/O Beats Random RAM Access
Learn why Kafka stores all events on disk. Understand how sequential disk writes and Linux OS Page Cache bypass JVM Garbage Collection pauses.
Why Files Fail as Databases: Concurrent Access, Update Anomalies & Crash Recovery
Discover why storing application data inside flat CSV or JSON files leads to race conditions, lost updates, corrupted data on crash, and performance failure.
Java Memory Model Explained: Stack vs Heap Allocation for Arrays
Understand how the JVM allocates memory on the stack and heap when declaring primitive and object reference arrays in Java.
Why Apache Kafka Exists: Solving Microservice N² Integration Spaghetti
Discover why Apache Kafka was created at LinkedIn. Learn how central append-only event logs solve microservice point-to-point integration spaghetti.
Why Manual Object Wiring Fails at Scale: The Inversion of Control (IoC) Problem
Discover why manual Java object instantiation fails at scale: tight coupling, rigid constructor dependencies, and Inversion of Control (IoC) solutions.
Mastering Java Collections from First Principles: Series Introduction & Learning Roadmap
Discover what you will learn in this 25-part series on Java Collections internals. Build data structures from scratch and master memory mechanics.