Bluue Whale

How LightMem cuts token waste in LLM memory systems with a three-tier structure modeled on the Atkinson-Shiffrin memory model: sensory memory, topic-aware short-term memory, and long-term memory.

How CSR (Compressed Sparse Row) represents a sparse matrix with just three arrays, values, column_indices, and row_pointers, and why it speeds up sparse matrix-vector multiplication and graph neighbor lookups.

How the Ego-Splitting Framework solves overlapping clustering with an ordinary non-overlapping clustering algorithm, by splitting each node into one persona per community it belongs to.

Where modularity comes from as a way to measure how well-formed a community is, and how the Louvain and Leiden algorithms differ in optimizing it.

How GraphRAG combines knowledge graphs with community detection to answer questions that need a view of an entire corpus, walked through its indexing/query pipeline and evaluation results.

A review of the SimpleMem paper, covering semantic compression, recursive memory consolidation, adaptive retrieval, and benchmark results.

A tour of common concurrent hash map designs—global locks, sharding/lock striping, Java's ConcurrentHashMap, and Cliff Click's NonBlockingHashMap (NBHM)—through the lens of contention and performance.

A second round of Java SwissTable tuning: why Objects.equals polluted the profile, and why a SWAR probing loop beat the Vector API on ARM and x86.

Implementing SwissTable-style hash map in Java

How Netflix tripled a service's CPU capacity, got only a 25% throughput gain, and traced the gap back to false sharing using hardware performance counters.

Why a userspace spinlock spinning on CAS and a kernel-backed mutex going through futex end up suited to different workloads, explained through cache coherence.

Swiss Table hash table design with open addressing, Robin Hood probing, SIMD control bytes, and a Java port experiment.

Why iterating one open-addressing hash table and reinserting its elements into another can blow up from O(n) to O(n^2), once the two tables share a hash ordering.

How DeepMind's SIMA plays multiple 3D games through nothing but screen pixels and keyboard/mouse output, trained with behavior cloning and classifier-free guidance.

How Kubernetes Topology Aware Routing gets kube-proxy to prefer same-zone pods using EndpointSlice hints, and the conditions that determine whether it actually activates.

How Share Groups break the 1:1 coupling between Kafka partitions and consumers, letting multiple consumers split the work on a single partition.

How KIP-848 moves rebalancing responsibility from the client to the broker and uses epoch-based incremental convergence to eliminate rebalance downtime.

Overview of the SIMD JSON algorithm that uses SIMD instructions to speed up JSON parsing 2–5x, covering structure indexing and parsing stages

How Kotlin coroutines build suspension points with state machines and CPS.

How high-watermark-based replication protocols in Kafka can lose data or diverge, and how KIP-101 fixes it by introducing the leader epoch.

How InstanceWrapper and Injector create prototypes, walk resolveConstructorParams(), and produce and inject instances of every dependency object.

How the @Module decorator attaches metadata via Reflect, and how DependenciesScanner and NestContainer register both StaticModule and DynamicModule.

A walk through NestFactory.create(), tracing how the HttpAdapter, ApplicationConfig, and NestContainer come together to build a NestApplication.