Ever since I did a research project on Smalltalk and HyperCard, I’ve been trying to figure out what my interests are when it comes to computing. It seems like there are a number of threads, but I think there are parallels. Here are some of the main threads:

Computing History

Learning about the history of Smalltalk and HyperCard was a jumping-off point for me to learn about computer history in general. It’s been nostalgic to read about things I was there for (from the mid-80s onward, especially in the Mac and web worlds), as well as how we got to that point (the history of Apple, the personal computer movement, Xerox PARC).

Some of the resources I’ve enjoyed so far are:

The Open Web

I care about the web remaining open for anyone to learn, create, and share on it. I care about preventing one company from controlling web technologies (Google’s Web Integrity API worries me in this regard). I care about discourse happening over open platforms like ActivityPub/Mastodon and RSS, instead of in closed platforms that can surveil and manipulate users with impunity. The IndieWeb is an adjacent family of formats that allow open communication of systems.

Malleable Software

I want software systems that users can change to fit their needs. Open source/libre software is one way to accomplish this, but the barrier to change is still high: you have to be a developer in a given tech stack to contribute. Browser extensions are another way, although I haven’t taken advantage of them much. Another approach is a powerful plugin architecture like Obsidian’s, which allows users to build their own set of tools to create the experience they want. Emacs is probably all of the above, although I haven’t used it much.

One of the main ways I’ve scratched the malleable systems itch is by building Riverbed, a free app I’ve just released in beta. Riverbed allows users to build their own mini-apps in the paradigm of columns of cards. You define the fields of data you want to store, the rules that control which column a card appears in, and buttons that automate making changes to a card’s data. Riverbed emerged from common patterns I saw in the side project apps I was building, and I’ve found that using its building blocks I can build many of the apps I want to have—and I can make changes to them without programming at any time.

Malleable software is related to a few different overlapping concepts, with different communities and resources for each:

  • Malleable Systems: about the ability of end users to make changes, whether via programming or not.
  • Future of Coding: about innovative approaches to programming, whether or not they result in malleable software.
  • End-User Programming: allowing people who are not professional programmers to program. There is a key article from Ink and Switch.
  • Live Programming: allowing people to program from within a running system so changes appear right away.

A Common Thread

I’ve wondered if there’s a common thread in these interests. There doesn’t need to be—it’s okay to have multiple interests. And drawing a circle around it could be limiting; I’m sure my interests will have shifted in a few years. But it does seem like there’s a common theme. These are all in the area of computing, but I’m not interested in everything about computing: not static type systems, not big data, and certainly not LLMs. What draws me to these things?

A concept that is resonating with me right now is the idea of a “personal computer.” Several of the computing history resources I mentioned explored what that term means.

At the dawn of computing, computers were large, extremely expensive, fragile machines, so even the people who wrote programs could not interact with them directly: they had to provide punch cards to operators. But these limits prevented people from realizing the full potential of computers.

An early step to reduce the distance between people and machines was interactive terminals, where you could type in a command or code and see the result immediately. Timesharing allowed multiple people to connect to the same computer over terminals at the same time, but this wasn’t mainly for people’s convenience: it was to maximize the utilization of these expensive machines. The load of timesharing resulted in the machine slowing down.

This resulted in an interest in a computer dedicated to one person, sitting on their desk, fully available to them. Xerox PARC explored this with the Alto. This was more personal in that the computer was dedicated to one person, but it was still envisioned to be in an office. More personal was to have a computer in one’s own home, and the Homebrew Computer Club was a community of hobbyists who explored this, and out of which the first microcomputers available for people to own at home came.

The use of these computers was still limited to technical hobbyists due to difficult interfaces. The graphical user interface was a way to make interfacing with a computer more personable. Early research happened at Xerox PARC, and then famously both Apple and then Microsoft used those ideas in Macintosh and Windows, respectively.

This move towards making computers easy “for the rest of us” to use resulted in locking down the ability of hobbyists to create for them, though. HyperCard by Bill Atkinson was a way to allow non-programmers the ability to create interactive experiences as well. HyperCard is actually what first got me into programming. But HyperCard didn’t last because it didn’t align with Apple’s business goals: the more people who can build their own software with HyperCard, the fewer people who have to buy commercial software, so professional software developers resisted it.

The shift from desktop and laptop computers to smartphones has made computers more personal in that they are with us, on our person, all the time. But security considerations have meant that users are further limited from changing them. Apple in particular restricts maintaining and modifying devices, and releasing software that doesn’t go through their approved channels and complies with their restrictions.

More Personal Computing

So what do I want to see happen? Computing that is more personal. Allowing the people who use computers to maximally benefit from the power of computers. Not just programmers, and certainly not just the stockholders of tech giants. I want people to have computing power and the ability to control it: to have control over their data and what is done with it, to have control over their software with the ability to change it to fit their needs.

So, more personal computing. We aren’t there yet. But libre and open source software make the software available to all programmers. The open web allows anyone to create software that connects into it and removes the incentives of closed platforms. Malleable systems mean that programmers build their software to give end users the ability to change that software to meet their needs.

There are streams attempting to make computers more personal. A big part of my focus right now is figuring out how to get connected into these streams and communities in a way that makes a difference and is fulfilling.