Everything is a database: the definitive alignment chart for storage pedants

Level 1: Storing and Finding Stuff

Imagine you have a big toy box where you keep all your toys. That toy box is like a storage place: you put your toys in (storing) and later when you want a toy, you dig through and take it out (finding). Now, normally when computer people say “database,” they mean a special kind of box (inside a computer) that stores information and lets you ask questions to get that information back. For example, a database might store all your friend’s contacts, and you can ask it, “Hey, what’s John’s phone number?” and it will tell you. That’s like a super organized toy box that can answer questions about what’s inside.

This meme joke says, “What if everything is a database?” It shows silly examples: like a fridge where you keep food. When you’re hungry you “query” the fridge by opening it and looking for, say, milk. If the milk is there, the fridge “answers” your query (you found it!). Or a library with books – you can ask the librarian for a book about dinosaurs, and they’ll find it for you. That’s like the library answering your question from its book collection. Even a friend’s brain can be a database: ever ask a friend, “Do you remember that song I like?” and they reply with the info? They stored that information in their memory, and you retrieved it by asking.

All of this is funny because we don’t normally call a fridge or a person’s brain a “database.” That’s a word we save for technology. But the meme is playing pretend: it stretches the meaning of “database” to include anything that stores stuff and helps you find it. It’s as if someone said, “Ha ha, by that definition, even my sock drawer is a database of socks!” It’s a goofy way to look at things. The humor comes from realizing that at a basic level, a lot of different things — from computer programs to everyday objects — involve the same idea: storing things in an organized way so you can get them when you need them. The meme takes that idea to an extreme, which makes it absurd and thus, very funny to people who work with real databases all day. In simple terms: we’re laughing because they’re calling a refrigerator and a game and even a person a “database,” which is a silly exaggeration that shows how important storing and finding stuff is everywhere, not just in computers.

Level 2: From Postgres to Fridge

Let’s break down the joke in simpler terms. The meme is saying “everything is a database”, but in a very tongue-in-cheek way. It uses a grid to categorize nine examples based on two qualities: what it stores and how you can get stuff out of it. In normal tech talk, a database usually means a software system like PostgreSQL or MySQL that stores digital data (like numbers, text, records in tables) and lets you retrieve that data by writing queries (using a special query language, most commonly SQL – Structured Query Language). For instance, with PostgreSQL (the elephant icon in the top-left of the meme), you might write a query like:

-- A typical SQL query on a real database (PostgreSQL example)
SELECT name, balance 
FROM Customers 
WHERE customer_id = 12345;

This would return the name and balance of the customer with ID 12345, assuming those records exist in the Customers table. That’s what we expect from a “proper” database: digital information stored in an organized way, and a formal method (SQL) to ask questions and get answers.

Now, the meme imagines loosening those requirements step by step:

• What if the thing stores information, but not necessarily in digital form?
• What if you can get the information out without using a formal query language – maybe just by asking in plain English, or even by physically searching?

By considering those questions, the chart classifies some surprising things as “databases.” Here’s a simplified table of the criteria:

Criteria	Purist (Strict) the “official” way	Neutral (Middle-ground)	Radical (Very loose)
What’s being stored? (Function axis)	Only digital data counts (bits in computers, databases, spreadsheets)	Any information counts, even if analog (printed books, human memory, etc.)	Can be anything at all – not just “information” in the usual sense (could be actual objects, food, game pieces…)
How you retrieve it? (Access axis)	Must use a formal query language (like SQL, or something computer-understandable)	Use of a language is enough – could be a programming script, a formula, or even asking a person in human language	Any method of retrieval counts – even just looking with your eyes or physically rummaging around (no formal query needed)

Using this chart, each example in the meme can be explained:

• PostgreSQL – Stores digital data (strict), and you query it with SQL (strict). ✅ It’s the classic database.

• Excel – Stores digital data (it’s a file on your computer, with cells of values), so that part fits the purist view. But how do you query Excel? You might use formulas like =VLOOKUP() or filters, which is a kind of “language,” albeit Excel-specific. So Excel is considered Access Neutral (it’s queryable, but not with standard SQL). Many people do use Excel like a simple database: they’ve got tables of data in a spreadsheet and perform lookups or calculations. That’s why the meme says “Excel is a database” in a somewhat joking tone – it’s a nod to all the times people treated a spreadsheet as a database.

• Dwarf Fortress – This is a video game known for its extremely detailed simulation. It generates a lot of data internally (imagine an entire fantasy world simulated down to individual creatures and historical events!). So it’s storing digital data for sure (Function Purist ✅). However, you can’t query it with SQL; instead, you interact with the game to see what’s happening, or use fan-made tools to read its memory. The meme puts it in Access Radical territory: you can get info, but through gameplay or hacks, not through a neat query interface. Saying “Dwarf Fortress is a database” is a humorous stretch – it’s like calling the game’s internal state a giant database of lore and stats. For a newcomer: think of it as the game having an invisible spreadsheet of every detail, but you retrieve data by playing the game rather than typing a query.

• A library – Not digital (it’s physical books), but it definitely contains tons of information. So that’s Function Neutral (information is present, just not in bits and bytes). How do you find something in a library? Typically, by using a catalog or asking a librarian. A catalog search is structured (you look up a title or subject in an index either on a computer or an old card catalog), which is analogous to a query. This makes it Access Purist or Neutral depending on how you view a catalog search — it is a kind of query system, just for physical items. The meme simplifies it to the idea that “A library is a database” because it’s a big organized store of knowledge, and you query it by looking up books. If you’re new to CS, it’s helpful to see that a lot of database concepts mirror older systems like libraries: a catalog = an index, a shelf location = an address, a librarian = a query processor who helps you get the data (book)!

• A senior engineer – This one is about human data storage. Imagine an experienced developer on your team who has been around for years. They have a lot of information in their memory (like why certain decisions were made, where to find things in the codebase, historical incidents, etc.). In the meme’s terms, the senior engineer’s brain “contains information,” which fits Function Neutral. How do you get that info out? You ask them questions – essentially querying in plain English. That’s Access Neutral (using a language, just not a programming language). So the meme jokes “A senior engineer is a database.” For a junior developer, this rings true because often the easiest way to find something out in a new job is to ask a more experienced coworker. They become like your personal Stack Overflow or Google for that project’s knowledge. Of course, unlike a real database, a person might forget or go on vacation, which is why relying solely on oral knowledge is risky – but it happens a lot in real life!

• A file cabinet – Before computers, offices used file cabinets to store data (on paper). Think of a file cabinet with labeled folders: that’s basically an analog database. It holds information (client records, receipts, etc.), so Function Neutral (contains info, not digital). To find something, you open it up and search manually – maybe using labels or an alphabetical order. That’s a very hands-on retrieval method, so Access Radical. The meme calling a filing cabinet a database is half-joking, half-educational: it reminds us that a database is fundamentally just a structured storage of info. The difference is a file cabinet is slow to search and can’t be queried by an app – a computer database can do it fast with indexes. If you’re a new dev, imagine a database as an electronic filing cabinet where you type a query instead of rifling through folders. Suddenly the analogy clicks!

• Battleship – The board game with the grids and pegs. This one is a bit silly: the game’s hidden pegs (ships) represent data, albeit not particularly useful data beyond the game. It’s Function Radical because it’s not “information” in the usual sense, just positions of objects in a game. But how do players get that info? By calling out grid coordinates like “A5” – which is actually a very structured query format (letter-number). So that part can be seen as Access Purist (there’s a strict “language” to the queries in the game rules). If you think about it, each move in Battleship is essentially a query: “Is there a ship at this coordinate?” and the answer is yes or no (hit or miss). The meme is playing with this idea, labeling the game itself as a “database” of ship locations that you query via gameplay. For a junior, the takeaway is that querying just means asking for data – whether it’s a database query or asking “E4?” in a game, conceptually it’s retrieving an answer from a set of stored info. It’s a fun way to see the parallel between a very analog game and digital data queries.

• Subway checkout counter – Picture the setup at a Subway or any sandwich shop: a counter with bins of ingredients (lettuce, tomatoes, etc.), a menu (list of options), and a person who takes your order. The meme calls this a database in the Function Radical sense (the “data” here is actual food items – definitely not your typical data!) and Access Neutral (you request what you want using spoken language). Essentially, when you order a sandwich, you’re querying the “sandwich database” for certain entries (“I’d like turkey, spinach, and mayo on wheat,” is like a multi-parameter query). The person at the counter checks the “database” (looks at available ingredients, which are like the stored records) and gives you the result (your assembled sandwich, fulfilling the query). This is obviously a humorous comparison – no one actually calls a restaurant counter a database – but it underscores the meme’s theme: if you broaden definitions enough, even making lunch involves storing and retrieving data. For someone new to tech, it might also illustrate that at a high level, a lot of processes involve the same principles: you have stored stuff and ways to get it when needed. It demystifies “query” as just a request for information, whether to a computer or a person.

• A fridge – Finally, the refrigerator example is the most extreme. Your fridge holds assorted things (leftover soup, fruits, etc.). According to the meme’s far-out definition, it’s a Function Radical database because it’s just storing anything (not just info). How do you see what’s in there? You open the door and look – maybe you even talk to yourself, “Do I have milk?” as you scan the shelves. That’s as Access Radical as it gets: simply looking is your query method. The meme says “A fridge is a database” to get a laugh, because on its face that’s a ridiculous statement – but in the looser sense of “a place you store stuff and retrieve answers (like whether you have milk or not),” it fits the joke. For a young or non-technical person, this example actually helps clarify what a database does: it stores items/data so you can get them later. It’s just that normally a database stores data like numbers and text, whereas a fridge stores edible items. The funny part is imagining a programmer earnestly arguing that a fridge qualifies as a database. It highlights how sometimes technical people can over-generalize or use fancy terms for simple things, which can be pretty amusing.

So, in summary, the meme uses these examples to teach (and tease) about what a database essentially is. A database stores information and lets you retrieve information. The strict view limits this to computer systems with formal queries. The loose view says it could be anything that holds stuff and lets you find out what you need somehow. Obviously, in real work, we don’t call a notepad or a grandma’s recipe box a “database” — we reserve that word for actual software/databases. But seeing those everyday things side-by-side with Postgres and Excel in the chart is meant to make you smile and think, “Yeah, when you put it that way, a lot of things in life are about storing and finding stuff!” It’s a playful way to broaden perspective (and maybe it sneaks in a lesson about not using Excel as a serious database 😅).

Level 3: Storage Pedantry Showdown

For seasoned developers and database architects, this meme hits on a relatable humor: the endless, nitpicky arguments over what qualifies as a database. It presents a 3×3 alignment chart (a format borrowed from D&D character alignment memes) to classify statements like “PostgreSQL is a database” vs. “A fridge is a database” on two axes of pedantry. If you’ve ever been in a meeting where someone groans “Guys, Excel is not a real database,” you’ll appreciate the satire here. The chart exaggerates both the purist viewpoint (only traditional databases count) and the radical viewpoint (call anything a database if you can store and retrieve info from it) — then fills in every combination in between. It’s essentially a storage pedants cage match, and every cell is a witty contender.

Let’s decode the axes first. The Function Purist → Neutral → Radical axis is about what is being stored:

• A Function Purist insists a database must store digital data – bits, records, rows, the kind of stuff an actual DBMS handles. No analog nonsense, no metaphorical storage; we’re talking files on disk or memory.
• Function Neutral broadens that to anything that contains information, even if it’s not digital. This could be printed text, human memories, etc. The idea: if it holds knowledge or data in any form, it counts.
• Function Radical says screw it, a database can contain literally anything. Got a box of miscellaneous junk in your garage? If you can find something in it, congratulations, you have an extremely function-radical “database.”

Now the other dimension, Access Purist → Neutral → Radical, is about how you get data out:

• An Access Purist demands a formal query language. In practice that means something like SQL, or at least an API or query mechanism specifically designed to retrieve data. If you’re not writing queries (or query-like commands), it ain’t a database to the purist.
• Access Neutral is okay with any sort of language-based query, broadly defined. Maybe that’s a programming script, or maybe even a structured natural language. You don’t necessarily have to write pure SQL, but you should be using some language or protocol to ask for the data (could be a spreadsheet formula or verbally asking a smart assistant).
• Access Radical throws the rulebook out: you can retrieve the info any way you please. Feeling around with your hands, visually scanning, banging on the side of a machine to see what falls out – all fair game. If there’s a way to get the data, no matter how ad-hoc or physical, then by this view the thing was “queryable.”

With these axes in mind, each cell in the chart is an example mixing one type of “what’s stored” with one type of “how it’s accessed.” The humor lies in how the examples escalate from sensible to ridiculous:

• PostgreSQL is a database – Top-left cell (Function Purist + Access Purist). This one is straightforward and played completely straight. PostgreSQL (logo: the blue elephant) is a gold-standard relational database system. It stores strictly digital data (tables of rows, binary files on disk) and you query it with SQL, a full-fledged query language. No debate here; even the stodgiest DBA smiles and nods. This is the baseline of normalcy in the chart – essentially the Lawful Good of databases.

• Excel is a database – Top-middle cell (Function Purist + Access Neutral). Ah, the infamous Excel. It does store digital data (spreadsheets full of numbers and text), so the Function Purists can’t object on that ground. But how do you query Excel? There’s no SQL interface (unless you count ODBC hacks); instead, you use Excel’s own features: filters, lookup functions, pivot tables, maybe a bit of VBA scripting – in other words, you are using a kind of language or at least a defined syntax to get answers from data. This falls under Access Neutral: queryable with a language, just not a traditional query language. The meme jabs at a very real scenario: people treating Excel spreadsheets like databases. Seasoned devs know the pain of inheriting an “Excel-as-database” solution in an enterprise – it’s usually a mess (no ACID transactions, poor concurrency, hard to version control), and yet it’s astoundingly common because Excel is so accessible. The humor is partly eye-rolling: “Sure, Excel can function as a database… in the same way a unicycle can function as a delivery truck – technically possible, but not what it was built for.”

• Dwarf Fortress is a database – Top-right cell (Function Purist + Access Radical). Now we venture into nerdy territory. Dwarf Fortress is a famously complex simulation game (a cult favorite among programmers). It procedurally generates a rich world with thousands of entities (dwarves, creatures, items, histories). Under the hood, that’s a ton of structured digital data – in fact, dedicated players sometimes use third-party tools to peek at the game’s memory or export data about their fortress. However, to actually get information out during normal play, you don’t write queries; you interact with the game’s interface, or you might literally dig around (pun intended) to discover what’s happening. The meme labels this Access Radical: the game’s state is queryable, but “queryable in any way” might mean using the game UI, mods, or just observing emergent behavior. It’s a cheeky inclusion that resonates with devs: Dwarf Fortress is so data-dense and detailed that it verges on being a big living database of a fantasy world. It’s like the meme saying, “Look, this game basically contains a database – you just retrieve info by playing it!” It tickles the part of a senior dev’s brain that sees everything through a data lens.

• A library is a database – Middle-left cell (Function Neutral + Access Purist). Here we start extending “database” beyond the digital realm. A library (an IRL building with books) definitely contains information – tons of it – but in analog form (printed books, journals). So it’s not digital data, it’s physical information storage, making it Function Neutral. Now, is it queryable with a query language? Arguably yes, if you consider a library’s cataloging system a kind of query interface. Libraries use classification (like the Dewey Decimal System or Library of Congress system) and you can look up books by title/author/subject, historically via index cards or now via computer search. That’s a structured query (you enter keywords, you get a shelf location as a result). To a pedantic purist, this could count as an Access Purist scenario: the query interface is formal (if not code, at least a defined lookup system). So a library qualifies as a “database” under slightly loosened conditions. Seasoned folks see the logic and chuckle – we often describe libraries as analogous to databases in conversations (“the card catalog was basically the database index, and the books are the data records”). The joke is, we’re taking that analogy dead-seriously for alignment chart purposes.

• A senior engineer is a database – Middle cell (Function Neutral + Access Neutral). Every experienced team has that one go-to person who just knows things – legacy decisions, weird bugs, config secrets. That Senior Engineer effectively stores information in their brain (not digital, but definitely knowledge = Function Neutral) and is queryable through language, i.e., you can ask them questions in English (Access Neutral). The meme humorously elevates this scenario: instead of documentation or a searchable knowledge base, you have Bob, the Senior Dev, who is the knowledge base. It’s funny because it’s true – many of us have “queried” a coworker with something like, “Hey, do you remember why we set the transaction isolation level to READ UNCOMMITTED in that service?” and gotten the answers we need. At the same time, it’s slightly dark humor: relying on humans as databases is a bus factor nightmare (if Bob leaves or forgets, your info is gone). But in the alignment chart of pedantry, it fits perfectly and pokes at a real-world tech culture issue: tribal knowledge vs. documented knowledge. Calling a senior engineer a “database” is a sarcastic way to say they hold all the data you need – just pray they’re in a good mood when you query them.

• A file cabinet is a database – Middle-right cell (Function Neutral + Access Radical). This one is a classic analogy: a file cabinet filled with folders and papers is basically how we stored and retrieved data before computers. It contains information (client records, invoices, etc., on paper), so not digital but definitely organized data. To get something out, you open drawers, flip through folders – totally an Access Radical scenario (physical querying by hand and eye). We often explain databases to newcomers by comparing them to filing cabinets (tables are drawers, records are folders, indexes are like tabs that help you find stuff faster). Here the meme just states it plainly as an alignment entry: if you’re a Function Radical or Access Radical, you’d even count the trusty file cabinet as a database. Seasoned devs find this amusing because it’s true in spirit – a filing cabinet is an info store – but calling it a “database” in earnest would definitely raise eyebrows. It’s a funny reminder of how far the tooling has come: from literal cabinets to PostgreSQL, yet conceptually they serve the same purpose (store and retrieve data).

• Battleship is a database – Bottom-left cell (Function Radical + Access Purist). Now we’re in comedic overdrive. The Battleship board game (yes, the one with the plastic pegs) as a database? Here’s the rationale: in Battleship, one player’s board contains hidden ship locations – that’s the “stored data.” It’s not exactly information in a useful sense (hence Function Radical: it’s just arbitrary objects on a grid), but it is a set of positions being stored. How do you retrieve that data? You fire queries in a strict format: calling out coordinates like “B-7” or “E-5”. That’s a very structured query (two-axis coordinate system) – arguably an Access Purist method because you must use the game’s formal query rules (“row-column” is basically your query language). If you hit, you got a data point: a ship part is at those coordinates! This is such an absurd yet clever parallel that experienced devs might actually laugh out loud. It shines a light on how, once you’re deeply immersed in tech, you start seeing “data models” everywhere. (It’s also a mini-reminder of how a coordinate system query is like a very primitive database lookup by key!). It’s so over-the-top to call a board game a database that it perfectly illustrates the meme’s point: taken to extremes, the definition of database can become a game (literally).

• Subway checkout counter is a database – Bottom-middle cell (Function Radical + Access Neutral). Arguably the most bizarre entry, this one takes a real-world daily-life scenario and squeezes it into the framework. Picture the counter at a Subway sandwich shop: there’s an array of ingredients (bins of veggies, meats, sauces – basically an inventory of food items). The staff behind the counter also have information like prices or today’s specials. This is not “data” in the traditional sense (it’s sandwiches and ingredients, hence Function Radical – it can contain anything). But can you query it with a language? Sure – by speaking. When you ask, “Do you have wheat bread today?” or “Can I get extra pickles?”, you’re querying the available data (inventory) in plain English (which counts as Access Neutral: a language-based query, albeit a human language). The “result” of the query is your sandwich or the information the cashier gives you (“Yes, we do have avocado”). It’s an absurd analog: the sandwich artist is like a database engine processing your order query. For a senior engineer with a wry sense of humor, it’s funny because it’s a context collapse – treating a mundane human interaction as if it were an API call. It mocks how devs sometimes reduce everything to tech terms (“I/O” for ordering food, etc.). It’s the meme saying, “See, if you’re radical enough, even buying lunch is a database query operation!”

• A fridge is a database – Bottom-right cell (Function Radical + Access Radical). This is the punchline of the whole chart – the extreme end of both axes. A refrigerator holds anything (leftover pizza, veggies, milk… not exactly “information,” just stuff – Function Radical to the max). And you retrieve data from it by simply opening the door and looking (or smelling, if it’s old leftovers). No query language, no formal method, just pure physical inspection – as radical as access gets. Calling a fridge a “database” is patently ridiculous in normal conversation, which is exactly why it’s hilarious here. It’s the meme’s way of saying, “If your definition of a database is broad enough to include this, you’ve gone off the deep end.” For developers, it evokes all those times we’ve stretched a term’s meaning for a joke. It also wraps back around to reality in a goofy way: ever label something in your fridge or arrange items so you know where to find the milk? Congrats, you’re implementing an indexing strategy in your home “database”! 😂 (And yes, that little emoji of laughter wouldn’t be out of place in a dev Slack discussing this meme.) The fridge example brings the joke home — even non-tech people intuitively get how silly it is, which makes the meme broadly relatable beyond just hardcore database folks.

In essence, this alignment chart is a satire of definitional debates. In the tech world (especially in DatabaseHumor circles), people often argue about boundaries: Is a CSV file a database? Is an Excel sheet a database? There are blog posts titled “Excel is not a database” for a reason. The meme takes that debate to an extreme conclusion: “Fine, if you’re going to be that person, let’s argue if a fridge or a board game is a database too!” Each panel resonates with scenarios developers joke about:

• Relying on Excel instead of a proper DB (common, if precarious).
• Depending on one guru for all system knowledge (we’ve been there, sigh).
• Keeping important data in a filing cabinet or on paper (yes, some industries still do).
• Seeing data patterns in games or daily life (only the truly initiated 🥷 start doing this everywhere).
  It’s both a gentle ribbing of people who are too pedantic and a self-aware laugh at how geeky we can get about abstract concepts. By diagramming it in an alignment chart (complete with that Dungeons & Dragons style flavor of Purist/Neutral/Radical), it doubles down on nerd culture crossover. For a backend engineer or data architect, the whole thing is a buffet of inside jokes: every image is a reference, every caption is a facetious claim, and the alignment format itself screams “Only a true nerd would categorize things this obsessively!”

In the end, experienced devs appreciate the grain of truth under the silliness: a database really is just a way to store and retrieve information. The difference between Postgres, Excel, or a fridge is how well they do it and under what rules. By stretching that concept to absurd limits, the meme bonds techies over shared knowledge and says with a wink, “We all know what a real database is… but imagine if we didn’t draw the line where we do.” It’s a humor alignment that only storage pedants and their long-suffering colleagues could have dreamed up.

Level 4: The Pan-Database Hypothesis

At the most abstract level, this meme pokes fun at the ontology of storage in computer science. It implicitly asks: “What is a database, really?” In formal terms, a database is usually defined as an organized collection of data, typically digital, with a way to query that data (often via a formal language like SQL). This chart stretches that definition across two axes — what is being stored (digital data vs. any information vs. literally anything) and how it’s accessed (strict query languages vs. loose methods of retrieval). The result is a tongue-in-cheek alignment chart that treats the concept of “database” with almost philosophical breadth.

From a theoretical perspective, the meme touches on the continuum between data, information, and knowledge. In information science (and the DIKW hierarchy), raw data (bits in a computer) becomes information when given context (like books in a library or facts in a person’s head), which in turn can be considered knowledge when internalized (as with that senior engineer’s wisdom). Normally, a database system concerns itself with data and information in a structured digital form. But here, the “Function Radical” view says even concrete physical stuff can stand in for data. This is a comedic nod to the idea that, if you’re pedantic enough, everything can be encoded or interpreted as data. After all, in theoretical computer science, any system with state can be seen as storing information – even the arrangement of food in a fridge could be seen as “bits” if you define some encoding for it (absurd, but that’s the joke!). It’s like a playful extension of the Church-Turing thesis to databases: any process of retrieving information (be it SQL queries or opening a cabinet) is a form of computation or query on an underlying state.

The horizontal axis (Access Purist→Radical) alludes to what qualifies as a query language. Traditionally, a query language means something like SQL, with formal semantics grounded in relational algebra. But slide into “Access Neutral” and you include any formal or semi-formal language, even a spreadsheet formula or a spoken command. Go full “Access Radical” and the notion of a query language dissolves into any sequence of actions that retrieves data. This hints at the boundaries of what computer scientists consider a query interface. For instance, asking a librarian for a book is effectively using natural language to query the library’s catalog via a human proxy. It isn’t a “query language” in the strict database sense, but it is a language-based retrieval method. Take it one step further: randomly opening the fridge to see if there’s milk is a “query” with no language at all, just direct observation. In academic terms, the meme is cheekily examining the semantics of queries: a spectrum from formal queries (machine-interpretable commands) to informal queries (human language or manual exploration).

By framing these extremes in an alignment chart, the meme satirizes how pedantic debates in tech can get. It’s reminiscent of debates in early computing about what counts as “storage” or “memory.” (Is a punched card archive a database? What about a file system vs. a database? These lines were debated even in the 1970s.) The chart essentially proposes a “Pan-Database” hypothesis: if you relax all the strict conditions, you could call almost any collection of things a database. Of course, serious computer science draws the line well before “a fridge with leftovers,” but that’s exactly why the meme is funny to those in the know. It underlines the absurdity of taking a definition to its extreme logical conclusion – a classic reductio ad absurdum, but in the realm of DatabaseSystems. And underlying it all is a bit of truth: in a theoretical sense, any system of stored states and queries (no matter how unorthodox) shares some fundamental principles with databases.