The web is already multiplayer

I've been working on editors again: tweaking CodeMirror to make it work better in Val Town. It's really hard work, unfortunately the kind of hard work that seems like it should be easy. It has me thinking a bit about why front-end engineering is difficult.

In fancy terms, it's multivariate and extended over time. Frontends, backends, browsers, and users are all variable, unpredictable actors.

There are no single-player web applications: the simplest model of frontend software is a user interacting with a webpage, but the user and the webpage have similar capabilities. Your frontend application can respond to and produce events. It can modify the webpage.

So can the user: they can modify webpages at any point. Maybe they load every page in a new session, breaking your assumptions about how a website will persist state. Or maybe they never create a new session - they have 80+ tabs open that never get closed, so they will continue using versions of your frontend application that you released months ago, which now break when talking to an updated backend server.

But those aren't the only players. Browsers are active participants in the game: a browser might translate a webpage and modify the DOM in a way that makes React crash. It might disable an API that the application expects, like localStorage, in a way that makes its behavior unpredictable. Ad-blockers might prevent some of the application from loading.

Distribution is probably the single most compelling attribute of the web over native applications. There's no app store, no mandated release process, no installation step. But just as you as the application developer have more power, so do browsers and users.

The interplay between these actors is what makes things difficult, and difficult in a way that's underemphasized in both Computer Science dogma and hacker culture. It isn't some algorithmic challenge or hard performance problem, or anything that can be solved by switching programming languages. It's an understanding of uncertainty in a deployment target that is constantly shifting and has a lot of unknowns.

After working in this realm, it's a treat to work on 'hard' problems that at least give you more certainty about the environment. Optimizing SQL queries, for example – it can be challenging, but at least I know that I'm writing SQL for Postgres 16. Frontend engineering can feel like optimizing a query and not knowing whether it'll run in DuckDB, Postgres, or MySQL, and even whether you can trust that the database schema will still be the same when it runs.

It's hard work. It's not cool. And I am nowhere near mastering it. I totally get it when people have an aversion to it, or think that the methods used today are wild. But mostly the methods are wild because the problem is, too. A straight-line solution to the problems of the front-end would be lovely, but those problems don't really permit one.