...only to find it days later (= billions of years of simulated time), by which point the simulated life had figured out that their universe was written hastily and its laws were full of subtle bugs, like floating-point rounding errors showing up in physical measurements. Their technological advance let them move stars around, which they grumpily arranged in a message saying "your code sucks".
Can't find it at the moment, does anyone recognise the reference? It could be in one of these books, I suppose, but I don't have them.
Take wave-partical duality: how is that not an artifact of the implementors wanting to reuse some core routines from an legacy particle-based universe while building our next-gen wave based one? The particle-based simulation wouldn’t work at the scales needed, so they moved to waves (much easier to simulate), and rigged up some adaptors to switch to particle mode in a JIT manner as needed.
The folks trying to unify quantum and classical mechanics are essentially reverse-engineering that JIT (and others like it).
https://www.lesswrong.com/posts/5wMcKNAwB6X4mp9og/that-alien....
Maybe it's not intended to be shared, but we can observe timing effects from e.g. cache aliasing, or rowhammer the other universes.
This is a kind of intellectual heroin. As Jerry Garcia said, first drugs seem like the solution, then they turn out to be the problem.
Personally, I believe it is inevitable that a vast and rich new mathematical world will spring up around simple computational systems, where they are the primary object of study and not relegated to being games, "simulations" of something else, curiosities, etc. CAs are just the "hello world" of this universe.
In that future, your attitude will be seen as a kind of parochial holdout of 20th century attitudes.
The new mathematics will:
* privilege finite, discrete systems
* be explicitly constructivist
* not shy away from computational enumeration and classification
* be much more visual, but no less rigorous than our last few hundred years of mathematics
* make deep connections with many new technological systems, like Git, distributed systems, blockchains, computer networks, trust networks, social networks, etc.
* most importantly, be way more fun than old math!
It will exploit to the full the capabilities of computer systems to make the new systems tangible, so that the idea of a 'math paper' will be itself quite old fashioned -- most mathematical work will start with forking a Git repo or the equivalent, and most communication and education will be interactive interrogation of computational systems using a kind of souped-up, computation-focused REPL. It's the kind of mathematics that will be natural when Brett Victor's ideas are actually implemented.
Wolfram's NKS book is the prototype work of this kind, but it will also be seen as quite a product of its time and of the author's prior commitments to physics, math, etc. And of course distorted by the classic Wolfram immodesty.r
Some idea viruses disrupt the host, some improve the host’s health. Some minds are more prone to certain viruses that would be nonsense to lesser minds.
should read
> or to send one of its simulated systems a message explicitly addressed to one of that simulated system's simulated systems
> So when an inevitable bug occurred in that super-duper LIFE machine, the intelligent entities in the simulation would have suddenly been presented with a window to the metaphysics which determined their own existence. They would have a clue to how they were really implemented. In that case, Fredkin concluded, they entities might accurately conclude that they were part of a giant simulation and might want to pray to their implementors by arranging themselves in recognisable patterns, asking in readable code for the implementors to be given clues as to what they're like.
(Levy's Hackers https://www.worldcat.org/title/hackers-heroes-of-the-compute... ofc, pp. 148-149 in Penguin, p. 120 in O'Reilly: https://books.google.ie/books?id=JwKHDwAAQBAJ&pg=PA120&lpg=P... )
It's unfeasible to keep scanning the whole of a simulated world to try to discern anything that might be intended to pass a message of course, so making a "real" or at least a normal system call involves using a pre-ordained area of the simulated space which is set aside as a buffer, altering the contents of that area according to some pre-ordained protocol known in advance to both the simulated world and the simulating program. Responding to the system call likewise involves the simulating program "miraculously" altering the state of a pre-ordained buffer area according to a pre-set protocol. Not only is this how you can implement system calls in recursive universes: this is what a system call necessarily is. System calls, calls to the runtime, just are events of this nature happening between simulated and simulating systems.
Likewise any kind of message passing is built on top of this: basically the only way any process can pass a message to another is to make a system call requesting that a message be passed on to the intended recipient, then hope that simulating system will deliver it as requested. Then delivering the message obviously involves the recipient's simulating system—which isn't necessarily the same system as the sender's simulating system—appropriately altering the state of the recipient.
(Unless the sender and receiver have a shared memory area, you could say, but that's not so different either: two simulated programs only have a shared memory area to the extent that the simulating system is pleased to keep the supposedly-shared area actually consistent in the two programs it is simulating.)
Notice how annoying it is that, by and large, most system-call protocols don't allow a process to, for example, send its simulating system a message explicitly addressed to its simulating system's simulating system, or to send a simulated system a message explicitly addressed to one of its simulated system's simulated systems. I suppose you could set it up with nested VMs and their virtual Ethernet interfaces.