The Curious Engineer

All blogs / C++

Lu’s blog

uvdn7.github.io

Learnings on system and programming.

C++Distributed systems / cloudRustDatabases

Posts
89 from 2 Jan 2018 to 29 Apr 2026
Posting
now and then (1 in the last year)
Kind
personal blog
Feed
https://uvdn7.github.io/feed.xml

2026 1

  1. Atomic Queue

2025 2

  1. Integer Division in Bucketed Time Series
  2. A Mental Model for C++ Coroutine

2024 3

  1. Access a function’s return value in C++ scope guard
  2. When `__cxa_pure_virtual` is just a different flavor of SEGFAULT
  3. Rust’s early vs. late lifetime binding

2023 12

  1. zsh interprets a standalone redirect as a `cat` command
  2. C++ coroutine and lambda’s lifetime
  3. `folly::IOBuf` and zero-copy networking
  4. What I learned about `inline` recently
  5. `ssh` to my workstation over Internet
  6. Caching Partially Materialized Views Consistently
  7. What Good Are Impossibility Results
  8. Project Management is a Concurrency Control Problem
  9. PTP/TrueTime vs. HLC when it comes to snapshots
  10. Describing State Machines using Math – TLA+ series (2)
  11. Notes on the Spanner: becoming a SQL system paper
  12. Linearizability is more than Capturing Causality Everywhere

2022 14

  1. IP as distributed data in the cloud
  2. Bet using a token bucket
  3. Generic Fault Tolerant Distributed Critical Section is Impossible
  4. Notes on Amazon's DynamoDB USENIX ATC'22 Paper
  5. Leave something to be somebody else's problem
  6. Why TIMEOUTs are hard to get rid of
  7. Notes on Photon - Databricks' query engine over data lakes
  8. Fast SQL from Schemaless ingestion
  9. When and How to Invalidate Cache
  10. Cache Invalidation
  11. Feedback Loops
  12. Little's Law and Service Latency
  13. Don't point out something wrong immediately
  14. How and why the Relational Model works for databases

2021 25

  1. `defaulted` constructor in C++
  2. How electrical energy powers the light bulb in your house
  3. C++ exception (2) — throwing an exception
  4. C++ exception (3) – catching an exception
  5. C++ exception (1) — zero-cost exception handling
  6. Application Binary Interface from the Ground Up
  7. Fix Flickering Relay Switch caused by Nest Thermostat
  8. `struct Foo f;` and `struct Foo f{};` are very different
  9. Learning C++ Memory Model from a Distributed System's Perspective
  10. DNS – the first distributed database
  11. Fiber-compatible Future
  12. There's Nothing 100% in Computer Science
  13. When would someone use std::enable_shared_from_this
  14. How FoundationDB works and why it works
  15. Paxos vs. Quorum-based Consistency
  16. Build `folly::coro` with GCC
  17. Why you don't need virtual base destructor with smart pointers
  18. How `AUTO_INCREMENT` works on MySQL
  19. SeqLock
  20. `folly::Indestructible`
  21. C++ Map Lookup Memoization
  22. atomic_thread_fence
  23. C++ Type Erasure and `std::function`
  24. Paxos Commit with Constraints
  25. How C++ `typeid` operator works

2020 15

  1. BW-Tree
  2. GNU Visibility Attribute
  3. Fix visual artifact on Linux running AMD 3400G
  4. Compile `folly` from source on Arch Linux
  5. std::atomic from bottom up
  6. Synchronized Multi-Append
  7. Read-Write Transaction API
  8. Linear scalable read-write lock
  9. Global Data Locality – Why and How
  10. My Ben Eater 8-bit breadboard build
  11. Every Computer System is a State Machine – TLA+ series (1)
  12. 2 + 2 can be 22
  13. API for Assigning Timestamp
  14. Notes on the Google Spanner Paper
  15. Unary Plus

2019 10

  1. Understanding Paxos as a Read-modify-write Transaction
  2. Stack overflow
  3. Re-entrant vs. Thread-safe
  4. Discover Paxos via 2pc
  5. Compare Small Versions that Wrap Around
  6. Notes on the Amazon Aurora Paper
  7. Non-blocking 2pc
  8. Proper Boost Installation on OSX
  9. Debugging Random Program Behavior
  10. Consistent Badge Count at Scale

2018 7

  1. Paxos at its heart is very simple
  2. Paxos Replication vs. Leader-Follower Replication
  3. Different ways of caching and maintaining cache consistency
  4. 请不要再称数据库是CP或者AP (Please stop calling databases CP or AP)
  5. State Machine and Synchronization
  6. A Look into Return Value Optimization of C++
  7. Time and Order