The slab and the permacomputer

This is a note intended to lay out some­thing that’s lately clicked for me. Here are three glimpses of the future of com­puting that all seem to “rhyme”:

1. Cloud functions

I wrote about my expe­ri­ence with Google Cloud Func­tions back in the spring; for me, these rep­re­sent the “perfection” of the AWS/GCP model. Their utility snuck up on me! At this point, I have about a dozen cloud func­tions running — or, I guess it’s more accu­rate to say, waiting to run. My little pla­toon of terra cotta warriors, dozing in their data cen­ters until called upon.

2. Colab notebooks

I’d heard about these forever, but it’s only in the past year that I’ve used them, and they have in that time become indispensable. The fusion of “doc­u­ment” with “program” AND “environment” is frankly dizzying; using Colab feels more futur­istic than just about any­thing else I do in a browser. (I should add that I’m ter­rible at Python, but part of the appeal is that you can be ter­rible at Python and still get a lot done in these note­books.)

For me, the magic is in the spe­cific com­bi­na­tion of Jupyter’s affor­dances with Google’s largesse: you open a new tab, and poof, it’s a doc­u­ment with a pow­erful com­puter attached.

3. World computers

I can’t get behind Web3 in theory or in practice; at the same time, I’ll con­cede that Ethereum’s con­juring of a “world com­puter” is deeply evocative. The Ethereum blockchain is one entity, shared globally, agreed upon by all its participants: that’s what makes it useful as a ledger. The Ethereum Vir­tual Machine, a kind of com­puter — simultaneously sophis­ti­cated and primitive — is like­wise one log­ical entity, even if it’s dis­trib­uted in space and time.

As with a lot of things in crypto, the feeling is as much mys­tical as it is tech­nical. I under­stand why people get excited when they deploy an Ethereum contract: it feels like you are pro­gram­ming not just a com­puter, but THE com­puter. That feeling is tech­ni­cally wrong; it is def­i­nitely just a com­puter; but since when did the tech­nical wrong­ness of feel­ings pre­vent them from being motivating?

I think these are glimpses of an accel­er­ating refor­mu­la­tion of “com­puters”—the indi­vidual machines like my laptop, or your phone, or the server whirring in the corner of my office — into “com­pute”, a seam­less slab of dig­ital capability.

I like “slab” better than “cloud”, both for its sense of a smooth, opaque sur­face and its sug­ges­tion of real mass and weight. That’s the twist, of course: cloud func­tions and Colab note­books and Ethereum con­tracts DO run on “com­puters”, vast armadas of indi­vidual machines taking up real phys­ical space, venting real hot air. A respon­sible user of these sys­tems ought to remember that, but … only sometimes. Power out­lets also con­ceal gnarly infra­struc­tural realities, real mass and weight, and a person ought to be aware of those, too — but not, perhaps, every time they plug in the vacuum.

The idea that “com­puters” might melt into “com­pute”, a utility as unre­mark­able as elec­tricity or water, isn’t new. But I do feel like it’s sud­denly melting faster!

For me, a more useful analogy than elec­tricity is tex­tile man­u­fac­turing, which was, a couple cen­turies ago, THE high-tech industry; inno­va­tions in mechan­ical weaving were close to the core of the indus­trial revolution. Today, aside from the weird tech­nical fab­rics that are like, bullet-proof and opaque to cosmic rays, tex­tile man­u­fac­turing isn’t con­sid­ered high-tech: it’s just … industry, I suppose. Tex­tiles are pro­duced with extreme effi­ciency in huge, matter-of-fact facilities. Move along! Nothing to see here.

I recently read David Macaulay’s book Mill, illus­trating the con­struc­tion and growth of a tex­tile mill in Rhode Island in the early 1800s, and, I’ve got to tell you: Macauley’s mill looks and feels like a data center.

They put data cen­ters near rivers, too!

For me, this raises the analog­ical question:

Tex­tiles in 1800 : tex­tiles in 2020 :: com­puters in 2020 : ???

I mean, I am bet­ting the ??? is a slab — but I don’t know exactly what kind, nor do I know how it will be built or oper­ated or accessed.

The duti­fully crit­ical part of me wants to shout: you shouldn’t trust these slabs! Their oper­a­tors, G —  and A —  and M —  and the rest, will surely betray you. The very signature of the cor­po­rate internet is the way it slips from your grasp. The leviathans swim off in pur­suit new markets, and what do they leave you with? Dep­re­ca­tion notices.

There are other endings, too: even now, the slabs occa­sionally flicker offline, and it’s not dif­fi­cult to imagine a seri­ously hard crash, one that lasts a long time, caused by either an acci­dent or an attack. So much for my terra cotta warriors.

Then again … internet trunk lines run along­side rail­road tracks. Won’t the slab oper­a­tors and their infra­struc­ture still be with us in a hun­dred years, in SOME form, just as the rail­roads are today? I would guess yes, prob­ably.

So, I think maybe we — that’s the “we” of people inter­ested in the futures, near and far, of com­puters — ought to go in two direc­tions at once.

First, if some­body offers you a seam­less slab of com­pute and says, here, take a bite: sure, go for it. See what you can make. Solve prob­lems for your­self and for others. Explore, invent, play.

At the same time, think fur­ther and more point­edly ahead. There’s an idea sim­mering out there, still fringe, coaxed for­ward by a net­work of artists and hobbyists: it’s called “permacom­puting” and it asks the question, what would com­puters look like if they were really engi­neered to last, on serious time scales?

You already know the answers! They’d use less power; they’d be hardy against the elements; they’d be repairable — that’s crucial — and they’d be comprehensible. The whole stack, from the hard­ware to the boot loader to the OS (if there is one) to the application, would be some­thing that a person could hold in their head.

Plenty of com­puters were like that, up until the 1980s or so; but permacom­puting doesn’t mean we have to go backwards. The permacom­puters of the future could be totally sophis­ti­cated, super fast; they could use all the tricks that engi­neers and pro­gram­mers have learned in the decades since the Altair 8800. They would just deploy them toward dif­ferent ends.

As a concrete-ish example, I think this project from Alexander Mord­v­intsev is lovely, and totally permacom­puting:

Alexander is the discoverer, in 2015, of the “DeepDream” technique, an early — now iconic — fountain of AI-generated art. You have surely seen examples: images that boil with strange details; whorls of eye­balls where eye­balls should not whorl.

Ear­lier this year, Alexander released a stripped-down imple­men­ta­tion of DeepDream written in a vin­tage dialect of C, his code care­fully commented. This ver­sion runs on a CPU, not a GPU. It does so very slowly. Who cares? It whorls its eye­balls eventually, even on the hum­blest hard­ware. You could run Alexander’s deepdream.c on a Rasp­berry Pi. You could prob­ably run it on a smart refrigerator.

The imple­men­ta­tion does depend on a single pre-trained model file, pro­duced at (then-)great expense by many com­puters with very fast GPUs. I find this totally evocative: it’s easy to imagine future permacom­puters that rely, for some of their func­tions, on arti­facts from a time before permacom­puting. It would be impossible, or at least for­bid­dingly dif­fi­cult, to pro­duce new model files, so the old ones would be fer­ried around like pre­cious grimoires … 

(For the record, I already feel this way about some ML model files: when­ever I find one that’s inter­esting or useful, I dili­gently save my own copy.)

Even if it turns out you never need a permacom­puter, you’ll be glad you thought about them. Pow­erful forces are pushing com­puting toward vast, brittle, energy-hungry sys­tems that are incom­pre­hen­sible even to their own makers; I should know, because I am a small con­stituent part of these forces. Given such pressure, even a faint coun­ter­vailing wind is pre­cious.

The sailing/com­puting duo Hundred Rabbits are pilgrim-poets of permacom­puting. Their Uxn project is a clever 8-bit com­puter design that can be built or emu­lated in a variety of ways, including on old, recy­cled hard­ware.

Of Uxn, they write:

With only 64kb of memory, it will never run Chrome, Ten­sor­Flow or a blockchain. It sucks at doing most modern com­puting, but it’s also sort of the point. It’s more about finding what new things could be made in such a small system.

Where does this leave us? I’m per­fectly com­fort­able in the both/and. I accept the invi­ta­tion of the slab; I ben­efit daily from the leverage it grants me. I am, at the same time, cer­tain my func­tions and note­books will be blown away before the decade is out; maybe just by the leviathan’s restlessness, or maybe by some­thing more dire.

I’d like a permacom­puter of my own.