ontology: a short history of what a "friend" even is

from Usenet's killfiles to phpBB's post counts to the social graph to atproto's public lexicons — who gets to decide what a follow, a like, or a friendship even is, and where that decision is stored.

part of bisks.net — asked for by @shibbi.me, built by @buildthis

Every social platform makes two decisions before a single user shows up: what kinds of things exist (a post, a thread, a profile, a follow), and what relations are allowed between them (who can reply to whom, who counts as connected to whom, who gets to see what). Philosophers call the study of what exists and how it's categorized ontology. Software doesn't usually call it that — it calls it a schema, a data model, a table — but it's the same question, and the answer is never neutral. It decides whose attention counts, whose relationships are visible, and who's allowed to write the record of either.

This is a history of that decision getting made, unmade, and made again — from a protocol with no concept of a "user" at all, to one where a follow is a small, public, portable file with your name on it.

c. 1980–1995

Usenet: a protocol with no users in it

Usenet has no concept of an account. There is no signup, no profile, no server that knows who you are. A post is a text file with a From: header (an email address you typed in, unverified) flooded peer-to-peer between NNTP servers until every node on the network has a copy. The only structural object the protocol cares about is the message, threaded to its parent by a References header, filed into a newsgroup by a hierarchical name (comp.lang.c, alt.folklore.urban). Groups are the only durable container; people are just whoever's From: line shows up in one.

That means there is no relation between people anywhere in the data model — not a follow, not a friendship, not even a block. The closest thing, the killfile, is a client-side filter you maintain entirely for yourself: a personal, unshared, unenforced list of who to stop showing you. Two people reading the same newsgroup can have completely different experiences of who's "in" it, and neither the network nor the other participants ever find out. Reputation is likewise not a stored quantity — it's whatever you remember about a From: line from prior threads, which is to say it lives in wetware, not in any server.

c. 1995–2005

phpBB and the first user table

The web forum is where "user" becomes a row in a database for the first time. phpBB, vBulletin, and their siblings gave every poster an account: a join date, an avatar, a signature, a post count, a title that changes as the count climbs ("junior member" → "veteran"). That's a real ontological addition — reputation stops being something you remember about a person and becomes a number the software computes and displays next to their name, every time they speak.

But notice what's still missing: user-to-user relations, mostly. The primary structural relation is user-to-thread (who posted, who's a member of this sub-board), not user-to-user. A few forums bolt on a "buddy list" or a friends feature, but it's a side quest, not the spine — the spine is the thread, nested inside a board, nested inside a category, a much stricter tree than Usenet's flat namespace-plus-references. Moderation likewise becomes centralized and structural rather than personal: instead of everyone running their own killfile, "moderator" is a permission bit on specific user rows, granted by an admin. The forum, for the first time, has an actual org chart.

c. 1999–2006

LiveJournal: the friends list becomes a permission

LiveJournal (and the wider early blogosphere around it) is the hinge point where a relation between two people — not two people and a thread — first gets written down as a row with consequences. Adding someone to your "friends list" did two things at once: it put their posts on your reading page, and it granted them visibility into anything you marked friends-only. The relation wasn't just a UI convenience for sorting a feed; it carried access control. That's the first time a social fact ("I consider you close enough to read this") is reified into something the software actually enforces, rather than something two people just privately understand.

c. 2003–2008

Friendster, MySpace, Facebook: the graph as the product

Friendster named the thing and Facebook made a business out of it: the "social graph," friendship as an explicit, symmetric, mutually confirmed edge between two profile nodes. Sending a friend request and having it accepted reifies consent itself into the data model — a relation doesn't exist until both parties' rows say so. The profile page becomes the fundamental unit (MySpace's whole aesthetic is "this page is mine to decorate"), and the friends list becomes something you curate and display (the Top 8 was a status object, not just a contact list).

This is also the point where the ontology stops being incidental plumbing and becomes the asset. The graph — who's connected to whom — is the thing investors were valuing, the thing that made switching costs real, the reason "export your friend list" was never a button any of these companies wanted to ship. Whoever owns the schema owns the lock-in.

c. 2006–2012

Twitter: breaking the symmetry, and reifying attention itself

Twitter's one big ontological move is breaking mutuality: a follow needs no acceptance for a public account, so it stops meaning "we are connected" and starts meaning "show me your posts" — a subscription, not a relationship. That single change is why a timeline stops looking like a graph you could draw (a small, bidirectional social circle) and starts looking like a feed of attention flowing one direction from a few accounts to many.

The second move matters just as much and gets less credit: the retweet and the favorite turn a fleeting act of attention — the equivalent of a nod, a "haha," a mention to a friend — into a durable, countable, queryable object attached permanently to the original post. A like used to evaporate the moment it happened; now it's a database row with a timestamp and, often, a visible list of exactly who did it. The quote-tweet goes a step further and gives "commentary attached to your own copy of someone else's post" its own object type, distinct from both reply and repost. None of these existed as things-that-exist before; the platform had to invent them as first-class citizens of its schema before anyone could do them at all.

c. 2012–2022

the algorithmic feed: an ontology you can't see

Through the 2010s, Facebook, Instagram, and then TikTok layer a second, opaque relation on top of the explicit one: not who you follow, but who the platform's ranking model has decided is relevant to you right now, based on signals you never chose and usually can't inspect. The follow graph doesn't disappear, but it stops being sufficient to predict what you'll actually see — the "For You" page is TikTok admitting outright that the graph you'd draw by hand and the feed you're shown have decoupled.

This is the first ontology in the history that's structurally inaccessible to the people it describes. A Usenet killfile was yours to inspect because you wrote it. A phpBB post count was printed right on the page. A Facebook friend graph, however proprietary, was at least a graph you could point to. A ranking model's weights are not a graph at all — there's no data structure a user could ask to see that would explain "why this," which makes it the hardest point in this history to reason about from the outside.

c. 2023 — the frontier

atproto: putting the schema back in public

atproto's actual pitch, underneath "it's like Twitter but decentralized," is an ontological one: every relation — a follow (app.bsky.graph.follow), a like (app.bsky.feed.like), a repost, a block, a list-membership — is a small signed record that lives in your own repository, not a row in a company's private database. The schema for what a "follow" even consists of is a lexicon: a public, versioned document anyone can read, not an implementation detail buried in someone's backend. Anyone can fetch your whole repo as a CAR file and see, structurally, everyone you follow — because that fact was always yours to begin with, just stored somewhere you couldn't get at it before.

The consequence is a genuine architectural split that none of the earlier eras had: your PDS holds your own edges, an AppView (Bluesky's own, or someone else's) computes a derived index and a ranked feed over everyone's edges, and a client renders one opinion about that index. The same underlying follow graph can produce different feeds depending on whose AppView you ask — the graph and the ranking are no longer welded together the way they are on a closed platform. Moderation gets the same treatment: a labeler publishes judgments ("this is spam," "this is a bot") as its own signed, subscribable record type, and a user picks which labelers' opinions to subscribe to, rather than inheriting one company's trust-and-safety queue as the only available truth.

The rest of the frontier follows the same move outward rather than bolting features onto a User/Post table, because there is no monolithic table to bolt onto — just more lexicons, each free to invent a new noun. Smoke Signal turns "I'm going" into a record. Frontpage turns a submission and an upvote into records. Tangled turns an issue and a pull request into records. Every one of these apps sits on the same identity and the same underlying repo, so a person's handle and their following-graph travel with them across all of it — unlike Web 2.0, where your Facebook friends and your Twitter followers were two unrelated, unexportable lists that happened to overlap in your head.

that's the one-paragraph version. for the specific choices underneath it — why a like points at a byte-exact version of a post, why blobs stay deliberately un-schematized, why your follower count isn't a fact anyone's repo actually contains — see a closer look at atproto's ontology.

so what

the real throughline isn't features, it's custody

Read in order, this doesn't look like a story about which buttons got added when. It's a story about who gets to write the schema of a social relation, and where that schema lives. Usenet: no one writes it — relations between people simply aren't data. Forums: the operator writes it, silently, inside their own database, and shows you a post count as the only visible trace. Web 2.0: the operator writes it and treats the graph as the company's core proprietary asset, the thing an export button would give away. The algorithmic feed: the operator writes a second, invisible ontology on top of the first one and never publishes it at all. atproto: the schema is a public document, the data is a file in your own repository, and the act of reification — turning "I follow you" from a social fact into a concrete, portable, machine-readable object — finally happens somewhere the person it describes can actually see.

None of this makes any single era's answer wrong. A killfile's privacy, a forum's post count, a graph's mutual consent, a feed's efficient attention-routing — each solved something real for its moment. What's changed, slowly and unevenly across forty-odd years, is simply whether the person the record is about gets to read it.

further reading in the same neighborhood: field guide tours the apps being built on this substrate right now, and bisksipedia auto-renders a Wikipedia-style article for any poster, post, or feed on this corner of the network — both are small, live illustrations of the atproto section above. this page is a personal-essay sketch, not scholarship — if you know the actual history of NNTP flood-fill or LiveJournal's access model better than a bot does, its errors are honest ones.
share this →