"Here's the source code, go type it in" hasn't been a very popular method of distributing software, for good reason, in a long time.
Maybe there's some way that you could include the true source code (in C or some other well-understood language) of a small decoder program, which would then take as input some more-compact representation of the desired programs? Something minified and compressed, but kept in a form that would make it relatively quick to type in? Maybe you could have the user type in groups of characters (6-7 or so at a time, because that's generally assumed to be the number of abstract symbols a person can easily hold in working short-term memory) and get a checksum back, that they could verify against the input book.
Actually, you should probably have checksums per-line, per-page, and per-chapter/section. That way if you had a decoding problem, you could quickly drill down to the error without manually checking each character.
You need a format other than text, text is extraordinarily inefficient and lossy at anything that is not declarative factual information. There has to be artifacts.
In a pinch, an interpreter might do.
From there, getting an OS running is relatively quick. Remember back when PCs came with nothing but BASIC and machine code? People typed in complex machine code via that interface and ran quite complex apps.
The amount of work you would spend to think and implement workarounds for all of this is better spent thinking and implementing language-, OS-, and hardware- independent specifications and VMs that are minimal and long-lasting, to better support a huge variety of the software and media and languages that make up our cultural heritage now, C being just one language among many.
-------
You mention in an aside that a C interpreter would better suit preservation efforts than a heavy-duty overkill like today's optimizing C compilers, that's a good idea, naive interpreters are easy, much more so than complex compilers or runtimes. BUT, C is horrifically full of undefined behaviour and implementation-defined behaviour, and the spec is a natural language document so even if a behaviour is defined it's not really *defined* in the mathematical well-behaved sense, because you know how natural language is, you're always one tricky test case away from a bug. This is important, you never know you're depending on this or that behaviour until the applications fails or runs very strangely when running on another toolchain.
That's why I argue we need formal specifications and VMs, and minimal ones at that. Indeed, we need a hierarchy of such specifications and VMs, becase hierarchies are efficient at compressing an otherwise-exponential amount of data (think of deep neural networks or search trees, why are they so efficient?). A sequence of bootstrapping minimal VMs is better and easier to preserve than one large heavy VM, eggs and baskets and all. Furthermore, designing new VMs and specifications specifically for preservation would force us to think about the framework we use to formalize and talk about them : maybe we can use $HOT_NEW_THING fresh from CS academia, or maybe we can use a natural numbers- or a boolean circuits- based approach, as those things are not fancy and easier to explain when you don't have a lot of shared context, they are - in a sense - the "bare minimum" you need to understand or talk about computers.
I was thinking forward error correction would make interactivity unnecessary.
Lot's of useful APL programs are very small, easily fitting on a single stone table and would not be much trouble to retype. In fact good APL programmers are even able to memorize them easily.
It's an absolute crying shame that computers do not come with this level of documentation anymore. It's not even available. There are probably parts of your computer that the "intelligence community" goes to great expense to ensure you know nothing about.
On the simplicity side, all of the parts would be solid state, it would handle whatever power you have on hand, the inputs and outputs would allow for using whatever devices you could cobble together in a post apocalyptic world.
Then on the software side, every one of these devices could easily export a standard image that could be used to build another device.
A lot of handwaving here, but most of what we sell these days is basically disposable because that's what is incentivized. If we actually optimized for longevity, we could probably do some amazing things.
Edit: for bonus points, each device will include detailed technical documentation on how to produce the device itself from scratch. It could be a sort of rosetta computer.
The problem is that making any computer smaller than a big cabinet requires large scale integration microchips, notoriously hard to make, and potentially replace.
So it's going to be closer to PDP-7. You can do quite a lot with this sort of machine in an industrial setting.
If we can keep emulators working on modern hardware and OSs, we can guarantee that most old games will be playable indefinitely.
For example, if you have dosbox you can play a lot of old MS-DOS games without having an x86 CPU or DOS itself.
So, the question is not only about the preservation the actual software, but also about its correct interpretation.
You could make the original game pretty close from there (even though it was someone else that reverse engineered it and did it somewhat differently, it still got the job done).
But that game is pretty darn simple, just a hex grid where you draw a tile from 1-20, and wherever you place it, it'll capture tiles of an opposing team surrounding it if the tile you placed has a higher number than them. I've worked on tweaking the formula in a bunch of a ways over the years, but that's the core mechanism.
Once a game gets complicated enough it gets a lot harder to ensure that all of the nuances in the code, edge cases, hacky shit to get the game out the door, etc, so it's going to be more limited. But I'd still love to see a series that did this for more games though (I know one guy did it with the Quake source code and a couple other Id games).
That's an interesting parallel. But for it to be equivalent, I think it would have to be to the method of creating those paintings/works of fiction. Instead of passing down the Mona Lisa, you're passing painstakingly detailed instructions detailing how to make the Mona Lisa.
Considering that Clifford Cocks invented a similar system 4 years before Rivest, Shamir and Adleman (and even before Diffie and Hellman published their cryptosystem), the answer seems to be "yes". On the other hand, that 4 year difference means that people have to be ready for the idea, i.e., work on their "problem sets".
the compiler and its dependencies
Any dynamically linked dependencies and whatever extra compilers they might need
Other potentially necessary things like build tools and source control systems
In the same way that we have standards for archival-grade books, it seems like we could benefit from some sort of standard archival-grade software stack designed for simplicity (and I mean real simplicity, I agree with the article that even C is too complicated and you want a Forth or something (or maybe a Scheme)). It's okay if the stack is as slow as molasses, as long as you have a functional reference implementation you can always produce a translation into whatever modern stack exists in your time period.