I have a hard time balancing my computing needs and wants. I'll list my wants here first, because I've spent more time thinking about them.
Because we don't build on formally defined and verified foundations, and because we don't formally define or verify much of what we write in turn, we end up writing all sorts of broken code. This broken code will necessarily be riddled with security holes, which means we have to take significant measures to mitigate the harm done when those holes are inevitably exploited. So I can't, for example, put all my files on a NAS and never have to worry about them being exfiltrated. I can use a firewall and Wireguard to minimize my attack surface, but these too can fail.
It's a big problem for anyone who wants to live free of authoritarian interference. Being surrounded by technology that can, in theory, be bent to an attacker's will without warning, makes all of us more vulnerable.
Building on ill-defined foundations also makes the act of programming much harder and less enjoyable. How can you know what your code's behavior will be over its domain if you don't know how the code it builds on behaves? This is probably not a problem for most people, and in practice I live with it for the most part, but I am always much happier in strictly typed programming languages whose designs preclude runtime exceptions.
It'd be great to not have to endlessly revisit and rewrite old code. To have a notion of a function or utility being "done." To be able to jump platforms without too much trouble if those platforms no longer reflect my values.
This is a value shared with uxn, but I don't think it quite meets all my computing wants.
This is a little odd, and probably the part of my "wants" that needs the most elaboration. The line between the "backend" and "frontend" layers can be difficult to keep clear, as backend and frontend tend to be shaped dialectically. Formalizing a general-purpose boundary between the two would likely be impossible, especially assuming an adversarial market. The best I can probably hope for is to come up with something that fits my own needs in particular, yet I also think this needs a political dimension to pull off broadly.
Generally speaking, I would like for software to be set up such that, e.g., a visual interface may be attached just as readily as an audio-based interface. I would like the question of whether a bit of software uses an austere TUI or an Electron-based glitter-maximalist GUI to be left up to the user. There may be an "official" interface, but it should not be essential.
Since DRM and dark patterns alike both require controlling how a user interacts with software, this bit is likely DOA in terms of broad adoption until we can forge a significant corner of the world that exists outside of capitalism. (That line might be confusing to some; I'd have lost my 20-something self at this point, certainly. Unfortunately connecting the dots there is outside the current scope of this page, but might one day make it into my politics page.)
This would, IMO, go a long way toward extending the useful lives of old computers and making accessibility a first-class citizen, assuming a general solution can be found. It would also save programmers who would rather not have to bother with the frontend from having to touch it at all.
I would like this presentation layer to be network-transparent, to allow plan-9-like interaction between devices. This implies an authentication and authorization layer between the backend and frontend.
Largely addressed by the point above, but worth its own point because I think it should be a first-class element of any new computing platform looking to achieve broad adoption. First off, we in the "libre software" movement really ought to be trying to liberate everyone here; after all, in the words of Billy Bragg, "freedom is merely privilege extended unless enjoyed by one and all." Secondly, truly first-class accessibility would improve the experience for those who don't strictly need the accomodations. E.g., continuing on with your software work via Bluetooth headset while your hands and eyes are occupied with more menial tasks.
Regardless, this is a want of mine. Done well, it should bring the essential forth and help shape the software into something more like a hammer in the hand.
User data and the platform should be cleanly seperated. It should be easy to take a snapshot of user data (and only user data; e.g., installed packages and hashes, not the packages themselves) and get an identical system on a new bit of hardware running the same platform.
It should be trivial to create snapshots and forks of system state, and to revert to them on-the-fly.
It should be possible to pause a process, alter its code, and resume its execution. There should be no distinction between the machine code and the source code.
It should be as if the whole system were passed to the main function, and then only slices of the system passed on to sub-functions. Processes should not be able to directly interfere with each other.
A bit of a want as well as a need. I need to be able to access websites, check and reply to email, ssh into servers, connect to networks over Wireguard, log in to IRC servers, etc. I also want to keep maintaining and publishing my wiki/garden here, and to keep interacting with people on Mastodon and the broader fediverse. I also like the idea of enabling Plan 9-like clusters, as hinted at in my "Bring-your-own-presentation-layer" section above.
Cryptography is foundational to this, I should mention. We are well past the days where leaving all communication, especially executable communication, unencrypted might have seemed reasonable. It shouldn't be required, as low-powered and older devices may struggle with it, and it is certainly not necessary in all cases, but it should be the default.
As a list, as I remember them:
Willing to punt on this one a bit, given how nontrivial implementing a full, modern web browser has become. I need enough browser to access online banking and would like enough browser to also access my government's websites, from municipal through federal. Rather than create a whole modern borwser, it may make more sense to port a basic HTML viewer and then create one-off shims for "BYOPL"-style interfaces to the underlying APIs. This is a fragile approach which would likely require access to a full, modern browser on another platform in order to update the shims when the APIs change, but it would require less up front work than a whole web browser would, and it would go further toward supporting old hardware.
Already strongly implied by all my "wants," but to be clear: being able to program the platform on the platform itself is a need, as is being able to at least author text. Not much of a machine for aiding thought otherwise.
Not all these needs and wants are equal, and I do not yet have the skills necessary to realize all of them. I imagine there will be a number of prototypes and intermediate forms. I also need to settle my politics enough to determine a mode of production under which to labor. I do not think the MIT or GPL licenses are enough to protect the commons from capitalist depredation; I am not sure the Peer Production License, or any license at all, is up to the task either. The surest form of protection is a combination of licensing and keeping the work a secret, keeping it internal to a trusted group, but this risks failure due to obscurity.
Some sort of proposed order:
The strictest gate here is, I guess, learning to write formally verified code.
I mean, frankly, I reckon it would be pretty cool just to have a system defined in something like Idris. Even something that doesn't hit all the bullet points here would at least be fun to play with.