The idea of archiving machine learning models really struck a chord. It reminds me of Asimov’s Foundation, where the empire has collapsed and people don’t know how to use the crumbling technology and treat it as magic.
Similarly, Jonathan Blow on "Preventing the Collapse of Civilization"[1] which is about software getting more complicated and worse at the same time. I just noticed he also brought up Foundation in that talk.
(Between this, The Thirty Million Line Problem video by Casey Muratori[2] and running across Forth, specifically jonesforth, I've also been thinking of building my own tech stack from scratch, or at least playing around with it while collecting more and more references about doing so.)
Most people already treat current technology as magic.
You could even make the point that for most techies, we treat tech as magic, but we call it "abstraction layers". We don't care about what's underneath as long as it always works.
...as long as it works for about 18 months.
I'm losing count of the number of projects I've seen recently which have build instructions which start with "you need this specific version of this particular build tool or compiler"....
The main thing I would point out is that it is just as important to record what ought not be repeated as it is to preserve that which is good.
Simple, understandable software is a good thing. Software which is performant is a good thing. Software which solves the user's problem is the most important. We have examples of software which are all three of those things. We also have software which is none of the three.
The biggest thing, if we are thinking long term, is that we should likely remember to emphasize that which can be maintained overtime by a small number of people, or indeed just one person. We should also emphasize machines that can be understood by a small team, or indeed just a single individual. Until recently, I would have said that all of this is alarmist.
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 hardware to the boot loader to the OS (if there is one) to the application, would be something that a person could hold in their head.
I think the slab will start with the smartphone. Someone will find a universal starting point within the complex mess that exists. This starting point will be successful and universally adopted (think: TCP/IP). Maybe it starts in the browser, as a page, then a plugin, then an app, then an OS, and finally hardware. The software written from this common starting point will, ideally, be able to run equivalently in each mode.
Broadly this isn't a new idea. Historically people think this starting point is something like Lisp, and want Lisp machines. There are other paths, though. It is good though that so many people are pushing toward this goal from so many directions; getting a computer whose mutable state from startup to application can fit in your head would be a godsend for human programmers. The path we're on now, only AI will be able to understand our systems. And that's bad, not just from a livelihood perspective.
The idea of Uxn, or some other minimalistic computing platform really scratches my itch, but I'm afraid anything that can't handle modern TLS is pretty much DOA - getting online is 95% of the reason why you'd want to own a computer, and while there are certainly a lot of fun things to do with an air-gapped device, computing shouldn't end at "just fun".
In my mind, this is more of a problem with TLS than it is a problem with older, slower, or simpler computers. Encypted, complex, and/or fast-churning protocols are sold as delivering security and efficiency, but in practice, for many applications, they primarily function as a ratchet to artificially induce obsolescence.
This. I tried spinning up a Win2k VM a few months back and was surprised to find that the web's now basically off limits to Win2K because of TLS. What's even more surprising is that the same barrier doesn't keep an Amiga[1] off the web. (Javascript is another matter, of course!)
The main practical solution seems to be to use a http-to-https proxy. Inspired by nostalgia and stuff retrocomputing people were doing on the fediverse, I recently spun up a MacOS 8.1 VM. Getting online basically took installing such a proxy on the host, since there's no browser with modern TLS that will run on a 68040 Mac.
Well the alternatives are: to stay offline, proxy through a more powerful relay (e.g. with WireGuard, seems to be able to run on an ESP32, but that's just moving the problem around), or... convince the world that the most widely deployed encryption protocol needs radical change?
Getting online is not the true purpose of owning computer.
You don't need TLS. you kind of already have all sorts of computers that can handle TLS, so why build another one?
UXN was developed out of necessity , because some software stopped working in certain environments. AFAIK author is living on a boat. and doesn't have unlimited electricity and internet access. Their electricity supply depends on weather.
When you look at it like that, information security is largely first world country problem. whilst 3rd world country is happy if it has internet and electricity at all.
I think there's a niche market to be had for offline/air-gapped computers, not only for security but for independent operability. If you're in BFE and have solar-powered computers running your AC you want something efficient and reliable, and everything in the hardware and software purpose-built.
A two-magnitude slowdown by being too simple to make compilation/any form of not-naive interpretation possible, by preventing code from self-clobbering, isn't a great start either. The approach there is to write a faster "device" in the host language, which doesn't help portability.
Have you heard of wolfssl? But if your idea of reliabilty is network connected computers that must never fail fate has bad news coming for you. Better to engineer systems with the certain expectation everything fails at some point. So air gapped is the way to go!
It's not about the simplicity, it's about the CPU power required to keep the encrypted traffic flowing. I have a G4 TiBook for example (an insanely powerful machine, 20 years ago), and I can sense it struggle.
I don't think you can run Dillo in 64kb of RAM (see Uxn specs: https://wiki.xxiivv.com/site/uxn.html). It would be interesting to see if e.g. a GBA running Uxn could handle TLS at reasonable throughput.
Oh that's correct, there's a bit too many contexts in this thread and I confused myself. Sorry, my bad.
You're right, OpenBSD with something like Dillo or NetSurf might go a very long way. I'm not sure though if I want to run OpenBSD on the TiBook, I have plenty of more powerful hardware for that, and running a modern, portable OS removes from the flavor of such retro hardware - e.g. it's the most modern/powerful laptop that can still run OS9. There still are people who maintain and write new software for the classic Macs (one of them, jcs, being an OpenBSD developer). I'll have to explore my options more thoroughly here, but either way, that machine struggles even with modern SSH, something you're used to being instant.
sounds interesting (an asynchronous relational data model with orthogonal persistence and transaction logging and rewind?) but also it looks like you're not throwing out amd64, linux, tls, html, tcp/ip, js, or even the dom, just maybe postgres
i like the idea 'With Adama, the transactional boundary is a single message. A single message from a person enters and a single data differential is emitted [to the log]'
i do think this new kind of data store needs its own language; though it could conceivably be a dialect of an existing language, very few languages are fundamentally relational, and those that are (prolog, say) are poorly suited to reactive systems (in pnueli and harel's term — as opposed to transformational)
I'm starting in the middle for productivity reasons, and a thorn in my side is k8s and microservice shenanigans.
The data store has its own language which is how it got started, and my vision is to build complex digital products with simple infrastructure.
For HTML/JS/DOM, I am accepting it into my heart as I can ship product on those technologies. But, I do believe in fixing them. For example, I believe we can fix HTML with some reactive extensions which I have started.
"If, in some cataclysm, all of scientific knowledge were to be destroyed, and only one sentence passed on to the next generation of creatures, what statement would contain the most information in the fewest words? I believe it is the atomic hypothesis that all things are made of atoms — little particles that move around in perpetual motion, attracting each other when they are a little distance apart, but repelling upon being squeezed into one another. In that one sentence, you will see, there is an enormous amount of information about the world, if just a little imagination and thinking are applied."
Just last night I read 'Fast Times at Fairmont High' and I was just in love with the computing clothing idea. Maybe it isn't so bad if my fashionable clothing and it's embedded ML model become obsolete. Maybe we can make our permacomputers more temporary, but also more disposable.
