The escalator never went down in the first place. Files are a weird, unclean semi-abstraction (growable virtual sparse block devices addressed as seekable byte-streams with heavy metadata and OS-level memory caching?) that we only feel a degree of primacy about because of how common they've been.

Consider: unikernels (like, say, any old cartridge game ROM) don't have any need for files. They have precisely three abstractions they deal with data in terms of:

• a .data section in ROM (maybe needing bank-switching to get in place);

• some kind of byte-addressable NVRAM (like battery-backed "save RAM", or CMOS memory) either bus-mapped, or through MMIO.

• tape or (floppy) disk, sometimes at an extremely low level (send commands to the drive motor, write guard nybbles, etc.), sometimes through a DOS where you can just request to seek to a given track then read or write a given sector on that track. Either way, more like a block device than a filesystem.

---

For today's kids, I'd suggest: don't start with files. Teach key-value storage first. Interact with a library like LMDB without explaining where it's putting the data. They'll understand this just fine.

Then, teach object storage in terms of key-value storage. Object storage—especially once you add object versioning—is much closer to the modern metaphor that user-facing apps expose. You compose a complete new version of an object in an in-memory scratch buffer, and then it atomically replaces the previous object. You can't corrupt an object by half-saving it. Etc. Again, don't bother explaining how this works yet; just give them a scripting runtime hooked up to a Minio instance.

After they get that, you can ask them what they'd do if they needed to create an object that wouldn't fit in memory. Then you can explain block devices, as a "place where large scratch buffers can live"—but don't force them to figure out how to allocate those buffers from the block device! That's gonna pull in a whole bunch of prerequisite teaching. Instead, pull out another API: Linux's LVM. Logical volume management takes block devices in, and spits block devices out. The logical volumes are the scratch buffers. Explain mmap(2), and how these buffers end up a lot slower that memory buffers. Explain how these buffers survive a disk crash.

After you get to that point, then you can explain that all the other ways computers durably store data are built on top of these logical-volume durable scratch buffers. You can explain how LMDB works in terms of disk pages; and then you can explain how a content-addressable storage works in terms of combining an LMDB-like KV store with hashing and splitting.

And, after that—if you like—you can explain that sometimes, when we need something that's like object storage but where everything in the storage bucket is actually a tiny scratch buffer, we use filesystems. You can explain what an "extent" is by talking about how something like LMDB, that has a "freelist" of pages from its underlying logical-volume, can reserve a contiguous set of those pages and then let something else access them. Then you can explain a filesystem as a key-value store that has buckets called "inodes" with page-range keys, and extent-address values. (And an associated versioned object store of directory-objects, where each object is a serialized list of records (dirents), each containing a reference to an inode and giving it a name and other stuff.)

Filesystems are hard!