Tag
checksums
- Sep 22, 2026 Multipart Upload: Choosing a Part Size That Survives a Retry Parts are immutable commit units. The 5 MiB floor, 10,000-part ceiling, and per-part checksums turn part size into a decision about retry cost and memory. cloud infrastructure
- Aug 14, 2026 Verifying a Backfill with Range Checksums Instead of Full Comparison How partitioning a dataset into key ranges and comparing per-range digests localises a skipped or double-written record, and why the digest must be order-independent. distributed systems
- Aug 5, 2026 Content Addressing and What Artifact Hashes Actually Prove The difference between a hash that identifies bytes and a signature that identifies a publisher, how digest verification fails, and why a matching hash is a narrower guarantee than it appears. language runtimes
- Jul 7, 2026 Checksum Strength: What CRC32C and SHA-256 Each Guarantee The detection guarantees a cyclic redundancy check actually provides, the different guarantee a cryptographic hash provides, and the cost of moving from one to the other. filesystems
- Jun 19, 2026 Intel HEX, Motorola SREC, and What a Programmer Actually Consumes The record structure of the two textual image formats, how each encodes load addresses and detects corruption, and why a raw binary loses the information a programmer needs. embedded systems
- May 25, 2026 Checksum Blind Spots: Misdirected Writes and Lost Updates The fault classes that survive a correct checksum, from acknowledged writes that never landed to corruption introduced above the filesystem, and the ordering machinery each one needs. filesystems
- Apr 11, 2026 Self-Healing Reads: Reconstructing a Copy From Redundancy How a filesystem repairs a damaged block during a read, what the repair costs on mirrored and parity layouts, and why the repair itself can fail. filesystems
- Apr 9, 2026 Scrub Passes: Finding Latent Damage Before It Is Needed What a scrub actually reads and in what order, why it must walk metadata rather than sweep the device, and how a pass is throttled so it does not starve foreground I/O. filesystems
- Feb 17, 2026 Checksum Verification and Restore Drills Distinguishing repository integrity from data verification and from a real restore, how much sampling is statistically worth doing, and what no checksum can detect. devops
- Jan 28, 2026 End-to-End Protection Information and Where the Checksum Stops How T10 protection information moves a checksum onto the wire with the data, what the guard, application tag, and reference tag each defend, and why the host still needs its own check. filesystems
- Jan 5, 2026 Checksum Placement: Block Pointers, Metadata Trees, and Payloads Where a filesystem can store a block checksum, why the pointer is usually the right home for it, and how each placement choice changes what a torn write can do. filesystems
- Jul 22, 2025 Torn Writes, Journal Checksums, and Detecting a Bad Commit Why a commit record that exists is not proof that its transaction is intact, how checksumming the log closes that hole, and what remains undetectable. filesystems
- Jul 4, 2025 Reconciling a Load: Counting Rows Is the Weakest Possible Check A row-count comparison agrees on many wrong tables, so reconciliation has to compare keys, then values, and needs a position to compare at. data engineering
- Apr 4, 2025 Torn Writes, Sector Atomicity, and the RAID Write Hole Why a 512-byte sector write is atomic but a 4 KiB write may not be, how torn writes corrupt filesystems that assume otherwise, and what parity updates do to crash consistency. memory systems
- Feb 25, 2025 What a SHA-512 Integrity Hash in Package Metadata Actually Proves Subresource Integrity, package lockfile digests, and Go checksums look alike but answer different questions about who computed the hash and what it covers. security
- Feb 4, 2025 Silent Data Corruption and What Device Error Reporting Misses Why a read can succeed and still return the wrong bytes, how drives separate correctable from uncorrectable errors, and which corruption classes no device is able to report. filesystems
- Jan 26, 2025 Read-Path Verification and What Happens When a Block Fails The ordering constraints a verifying read must satisfy, the error classes a mismatch can be sorted into, and why retrying a failed checksum is usually pointless. filesystems
- Sep 9, 2024 Checksum Granularity and the Read-Modify-Write Penalty How the size of the region one checksum covers sets both the precision of damage reporting and the cost of small overwrites, and why 4 KiB sectors made granularity a hard constraint. filesystems
- Feb 16, 2024 Doublewrite Buffers and the Torn Page Problem Why a page write is not atomic on real hardware, how a shadow copy restores the page after a partial write, and what the extra sequential write costs. databases
- Feb 9, 2022 Content-Addressed Artifact Identity and the Cost of Mutable Tags Why a digest derived from bytes is the only stable name for a build output, how Merkle chunking makes large artifacts hashable, and what a mutable tag hides between resolution and pull. devops
- Feb 7, 2022 Post-Cutover Reconciliation and Drift Detection How to prove that a destination holds the same state as its source after the switch, why checksums over large tables lie, and how to detect divergence that appears later. cloud infrastructure