This fun post prompted by John Regehr’s question: “Do Small-RAM Devices Have a Future?” where he proposes several possible scenarios. One in particular is fun to think about:
Small-RAM devices continue to exist into the indefinite future; they just keep getting smaller, cheaper, and lower-power until genuine physical limits are reached. Eventually the small-RAM processor is implemented using nanotechnology and it supports applications such as machines that roam around our bloodstreams, or even inside our cells, fixing things that go wrong there.
In short, if we’re asking whether small-RAM devices will continue to exist, one potential application that might keep them around is nanobots. Otherwise, we’d probably expect size and cost of large-RAM devices to go down so much there wouldn’t be any point in not just using those instead, for nearly every other application.
But I’m a little skeptical that we’d ever do things this way, which I’ve already given away with the title of this post. There are many advantages for the organism route:
- Most of what we know about building mechanical devices is out the window at small scales. There are, of course, people who work on some of this stuff, but they’re still at the level of figuring out how to even build gears.
- There’s already a wealth of knowledge in biology to tap into. For many of the basic problems to solve, there’s an organism from which we can steal a solution.
- We can already synthesize small genomes, put them into cells and have them live, but we cannot yet build any nano-machines. So there’s already a pretty huge head-start.
And many of the apparent disadvantages, I think, are illusory:
- I’m not sure there’s a wider array of applications for nanobots. Anything you can get a nanobot to do, you can probably engineer an organism to do, as well. Though, you might need to develop some completely new organelles (for example, to get a cell to run on electricity, if that’s how you simply had to power it.)
- Nanobots would probably require some sort of “immune system,” too, so that’s unlikely to be a disadvantage specific to organisms. We’ve never actually built one, so we haven’t had a chance to run into problems like a battery or gear getting gummed up with bacteria.
- Further, organisms can be engineered to be immune to many potential diseases pretty easily. If we’re willing to give up evolution (which, for engineered organisms, will probably be an advantage at first) then even a simple error correcting code on protein descriptions would be a barrier so high that we’d probably never have to worry about viruses at all.
And finally, I think a lot of the main challenges would equally apply to both techniques:
- Whatever solution we come up with for getting emergent structures to form from millions of tiny objects working together will probably not care whether those objects are communicating via proteins or electrical signals (or both, for that matter.)
- The particular application will probably be the most difficult part of building any nanobot or organism. For example, how to go about seeking out, identifying, and destroying a cancer cell is a difficult task by itself, and whether that’s being done via organism or nanobot probably won’t affect the difficulty at all.
To tie this discussion back to the original question, even if we do end up with nanobots being the preferred technology, then it’s likely we’d pilfer techniques from biology. That would likely mean carrying around the whole program in every device, even if it only needed subsets of it (just like DNA.) And that’d mean these devices still have a lot of memory, since genomes are regularly in the ballpark of millions or billions of base pairs.
Or, even if there is a good reason to have very small memories on these nanobots, actually producing code for those small memories would probably be the job of the compiler, not the programmer. I hope to someday work on developing languages and compilers for building organisms, but I don’t think I’d be too upset if it were for programming nanobots instead. ;)
Either way, I think it would be the end of low-level programming languages: successfully writing complex programs for either of these technologies at all, even if ridiculously inefficient, would enable incredible applications that we couldn’t do otherwise. That wasn’t true of the first computers. A cancer-curing bacteria that took a week to divide and had a 200GB genome would still be a cancer-curing bacteria. A computer that took a week to calculate a square root would be useless junk.