Systems

• Formal Verification of Cryptographic Protocols: ProVerif, Tamarin, and the TLS 1.3 Verification Story · 2023-04-06

  An exploration of the Dolev-Yao model, ProVerif and Tamarin provers, computational soundness results, and how formal methods proved TLS 1.3 secure before deployment.

• Microarchitectural Attacks: Spectre, Meltdown, and the Transient Execution Apocalypse · 2023-04-06

  A deep analysis of Spectre v1-v4, Meltdown, and the root cause in speculative execution, covering the endless cycle of mitigations and new attack variants that exploit the microarchitectural state.

• Side-Channel Attacks: Timing, Power Analysis, Cache-Timing, and the Constant-Time Discipline · 2023-04-04

  A rigorous exploration of side-channel cryptanalysis from Kocher's 1996 timing attack through differential power analysis to cache-timing attacks like Prime+Probe and Flush+Reload, with the countermeasure of constant-time programming.

• Searchable Encryption: Querying Encrypted Databases, Forward Privacy, and the Leakage-Abuse Frontier · 2023-03-31

  An in-depth analysis of symmetric searchable encryption from Curtmola et al. through forward privacy, leakage-abuse attacks, and the modern systems that balance security with performance.

• Format-Preserving Encryption: The FFX Mode, Rank-Encipher-Unrank, and Legacy Database Protection · 2023-02-25

  A technical deep dive into FPE: the Feistel-based FFX mode with AES, the rank-encipher-unrank construction, and practical applications in encrypting legacy databases and tokenization systems without breaking schemas.

• TCP Congestion Control: From Slow Start to BBR · 2023-02-11

  A comprehensive exploration of TCP congestion control algorithms, from classic approaches like Tahoe and Reno to modern innovations like BBR. Learn how these algorithms balance throughput, fairness, and latency across diverse network conditions.

• Floating Point: How Computers Represent Real Numbers · 2023-02-08

  A deep exploration of IEEE 754 floating point representation, the mathematics behind binary fractions, precision limits, and the subtle bugs that can arise when working with real numbers in code.

• Threshold Cryptography: Distributed Key Generation, Threshold ECDSA, and the Validator Use Case · 2023-02-03

  A rigorous look at threshold cryptography from Shamir secret sharing through GJKR distributed key generation to modern threshold ECDSA and BLS signatures for blockchain validators.

• Verifiable Delay Functions: Wesolowski, Pietrzak, and the Sequentiality Assumption · 2023-01-21

  An exploration of VDFs from their cryptographic foundations through practical constructions, with emphasis on randomness beacons, blockchain consensus, and the sequential computation lower bounds.

• Oblivious RAM and Private Information Retrieval: Hiding Access Patterns from the Storage Server · 2023-01-10

  A comprehensive tour of ORAM and PIR: the square-root construction, tree-based Path ORAM, computational and information-theoretic PIR schemes, and the fundamental lower bounds that constrain the overhead.

• Multi-Party Computation: From Yao's Garbled Circuits to the SPDZ Line · 2022-12-26

  A deep exploration of secure multi-party computation, tracing the intellectual arc from Yao's millionaires' problem through the SPDZ practical framework, with full protocol detail and modern applications.

• Garbage Collection Algorithms: From Mark-and-Sweep to ZGC · 2022-11-22

  A comprehensive exploration of garbage collection algorithms, from classic mark-and-sweep to modern concurrent collectors like G1, Shenandoah, and ZGC. Learn how automatic memory management works and the trade-offs that shape collector design.

• CPU Caches and Cache Coherence: The Memory Hierarchy That Makes Modern Computing Fast · 2022-07-12

  A comprehensive exploration of how CPU caches bridge the processor-memory speed gap. Learn about cache architecture, replacement policies, coherence protocols, and how to write cache-friendly code for maximum performance.

• Virtual Memory and Page Tables: How Modern Systems Manage Memory · 2022-05-19

  A comprehensive exploration of virtual memory, page tables, and address translation. Learn how operating systems provide memory isolation, enable overcommitment, and optimize performance with TLBs and huge pages.

• Process Scheduling and Context Switching: How Operating Systems Share the CPU · 2022-05-18

  A deep dive into how operating systems decide which process runs next and how they switch between processes. Understand scheduling algorithms, context switches, and the trade-offs that shape system responsiveness.

• Branch Prediction and Speculative Execution: How Modern CPUs Gamble on the Future · 2021-08-15

  Explore how modern processors predict branch outcomes and execute instructions speculatively, the algorithms behind branch predictors, the performance implications for your code, and the security vulnerabilities like Spectre that emerged from these optimizations.

• Virtual Memory and Page Tables: How Operating Systems Manage Memory · 2021-08-12

  A comprehensive exploration of virtual memory systems, page tables, address translation, and the hardware-software collaboration that enables modern multitasking. Understand TLBs, page faults, and memory protection.

• State Machine Replication: Viewstamped Replication Protocol, Zab (ZooKeeper Atomic Broadcast), and the Consensus-Scalability Continuum · 2021-07-27

  A deep exploration of state machine replication — how Viewstamped Replication and Zab enable fault-tolerant services through ordered command execution, and how the consensus-scalability continuum shapes modern distributed systems design.

• Streaming Systems: Apache Flink Checkpointing, Kafka Log Compaction, Watermarks and Event-Time Processing, and Exactly-Once Semantics · 2021-07-22

  A deep exploration of streaming systems — how Flink's distributed checkpointing provides exactly-once state consistency, how Kafka's log compaction enables durable event storage, and how watermarks solve the event-time vs processing-time dilemma.

• B-Trees and LSM-Trees: The Foundations of Modern Storage Engines · 2021-07-14

  An in-depth exploration of B-Trees and LSM-Trees, the two dominant data structures powering databases from PostgreSQL to RocksDB. Learn their trade-offs, internal mechanics, and when to choose each for your workload.

• Columnar Storage: Parquet Encoding, ORC Stripe Format, Apache Arrow In-Memory Columnar Format, Predicate Pushdown, and SIMD Scans · 2021-07-03

  A deep exploration of columnar data formats — how Parquet and ORC organize data column-by-column for efficient analytics, Apache Arrow's in-memory representation for zero-copy data interchange, and the vectorized execution that makes modern query engines fast.

• CPU Caches and Memory Hierarchy: The Hidden Architecture Behind Performance · 2021-06-22

  A deep exploration of CPU cache architecture, from L1 to L3 caches, cache lines, associativity, replacement policies, and cache coherence. Learn how memory hierarchy shapes modern software performance.

• Object Storage: RADOS/Ceph Architecture, the CRUSH Placement Algorithm, S3 API Semantics, and Erasure Coding at Scale · 2021-06-21

  A deep exploration of object storage — how Ceph's RADOS and CRUSH algorithm enable scalable, self-managing storage clusters, the S3 API's influence on cloud storage, and how erasure coding reduces storage overhead.

• Distributed File Systems: GFS Design, HDFS Architecture, the Colossus Evolution, and Single-Master Metadata Bottlenecks · 2021-06-18

  A deep exploration of distributed file systems — how Google's GFS pioneered the single-master model, how HDFS adapted it for the Hadoop ecosystem, and how modern systems have evolved beyond the single-master bottleneck.