Design considerations for Mars colony computer systems
A very interesting article discussing SpaceX’s dramatically lower launch costs has convinced me that, in a decade or two, it will become economically viable to send people to Mars. Whether lots of people will be willing to go is another matter, but let’s assume that a non-trivial number of people decide to spend many years living in a colony on Mars; what computing hardware and software should they take with them?
Reliability and repairability are crucial. Same-day delivery of replacement parts is not an option; the opportunity for Earth/Mars travel occurs every 2-years (when both planets are on the same side of the Sun), and the journey takes 4-10 months.
Given the much higher radiation levels on Mars (200 mS/year; on Earth background radiation is around 3 mS/year), modern microelectronics will experience frequent bit-flips and have a low survival rate. Miniaturization is great for packing billions of transistors into a device, but increases the likelihood that a high energy particle traveling through the device will create a permanent short-circuit; Moore’s law has a much shorter useful life on Mars, compared to Earth. The lesser high energy particles can flip the current value of one or more bits.
Reliability and repairability of electronics, compared to other compute and control options, dictates minimizing the use of electronics (pneumatics is a viable replacement for many tasks; think World War II submarines), and simple calculation can be made using a slide rule or mechanical calculator (both are reliable, and possible to repair with simple tools). Some of the issues that need to be addressed when electronic devices are a proposed solution include:
- integrated circuits need to be fabricated with feature widths that are large enough such that devices are not unduly affected by background radiation,
- devices need to be built from exchangeable components, so if one breaks the others can be used as spares. Building a device from discrete components is great for exchangeability, but is not practical for building complicated cpus; one solution is to use simple cpus, and integrated circuits come in various sizes.
- use of devices that can be repaired or new ones manufactured on Mars. For instance, core memory might be locally repairable, and eventually locally produced.
There are lots of benefits from using the same cpu for everything, with ARM being the obvious choice. Some might suggest RISC-V, and perhaps this will be a better choice many years from now, when a Mars colony is being seriously planned.
Commercially available electronic storage devices have lifetimes measured in years, with a few passive media having lifetimes measured in decades (e.g., optical media); some early electronic storage devices had lifetimes likely to be measured in decades. Perhaps it is possible to produce hard discs with expected lifetimes measured in decades, research is needed (or computing on Mars will have to function without hard discs).
The media on which the source is held will degrade over time. Engraving important source code on the walls of colony housing is one long term storage technique; rather like the hieroglyphs on ancient Egyptian buildings.
What about displays? Have lots of small, same size, flat-screens, and fit them together for greater surface area. I don’t know much about displays, so won’t say more.
Computers built from discrete components consume lots of power (much lower power consumption is a benefit of fabricating smaller devices). No problem, they can double as heating systems. Switching power supplies can be very reliable.
Radio communications require electronics. The radios on the Voyager spacecraft have been operating for 42 years, which suggests to me that reliable communication equipment can be built (I know very little about radio electronics).
What about the software?
Repairability requires that software be open source, or some kind of Mars-use only source license.
The computer language of choice is obviously C, whose advantages include:
- lots of existing, heavily used, operating systems are written in C (i.e., no need to write, and extensively test, a new one),
- C compilers are much easier to implement than, say, C++ or Java compilers. If the C compiler gets lost, somebody could bootstrap another one (lots of individuals used to write and successfully sell C compilers),
- computer storage will be a premium on Mars based computers, and C supports getting close to the hardware to maximise efficient use of resources.
The operating system of choice may not be Linux. With memory at a premium, operating systems requiring many megabytes are bad news. Computers with 64k of storage (yes, kilobytes) used to be used to do lots of useful work; see the source code of various 1980’s operating systems.
Applications can be written before departure. Maintainability and readability are marketing terms, i.e., we don’t really know how to do this stuff. Extensive testing is a good technique for gaining confidence that software behaves as expected, and the test suite can be shipped with the software.
Interesting thought experient, Derek. I think there are many barriers in addition to launch cost that may keep us from colonizing Mars but if we assume they will all fall away for the sake of argument, computer systems and software for Mars are still a challenging problem.
The first thing you’d need to do is separate the safety-critical applications from the non-safety-critical applications. The former need specialized hardware, software, and redundancy. While the latter, might be ok with more or less off the shelf hardware and software (perhaps with minor modifications to deal with radiation and atmospheric differences).
This article highlights some of the challenges and solutions for using computers in space and is definitely worth a read: https://arstechnica.com/science/2019/11/space-grade-cpus-how-do-you-send-more-computing-power-into-space/
It basically says that computing in space is expensive and slow from the hardware side. Plus, for critical systems, we need redundancy, backups, and spares.
Writing software that is aware it is part of a redundant, safety-critical system becomes extremely complicated and expensive and will remain that way for the foreseeable future. Think the flight computers in Airbus passenger jets.
Programming in C twenty years from now? I hope not. We need to move away from non-memory-safe languages, especially for safety-critical applications. The amount of specialized software that we’d need is huge. And I hope we choose something safer than C, whether that’s Ada or Rust (if it matures), or something entirely new.
I think any Mars colony will need a steady stream of supplies from Earth. I don’t see why new computer parts wouldn’t be factored into the cost of doing business on Mars. Repairing electronics on Mars beyond part swapping seems like a poor use of resources given the cost of getting people there and keeping them alive.
Software development on Mars seems like a really expensive idea. Given that the cost of pushing a software update from Earth to Mars is essentially zero (no rocket fuel required), why wouldn’t we keep the developers on earth?
I like your idea of not using computers at all when we can get away with it.
I’m just curious if you have any thoughts about what kind of computer systems you envision on Mars if we colonize it? Modern, networked, mobile, sci-fi kind of stuff? Or stripped down, bare minimum embedded systems that accomplish the minimum very well but not much else (something like the space shuttles had)?
@Blaine
Programming in C can be memory safe, in that the compiler could choose to insert the necessary checks; tools are available to do this, but the culture of C is not memory checking oriented. People like inventing new languages that ‘solve’ C’s problems, it’s more fun than trying to change the C culture.
I’m not suggesting that any major software development happen on Mars, but there will be a need to make changes to the code being used on Mars. Those doing the coding on Earth may not always be as responsive as desired, and there are a few weeks, when the planets are on opposite sides of the Sun, when communication is not possible.
A steady stream of replacement hardware will be needed. But there is talk of a permanent colony, and anybody thinking along those lines has to deal with the issue of supply lines being cut (among other things).
The kind of computer systems used will depend on the problem being solved. Humans have existed on Earth for many thousands of years without computers, are computers needed to survive on Mars? I don’t know, but would today’s youngsters be willing to live for any length of time without their music collection i.e., they are going to need a device containing a DSP)?
As for sci-fi stuff like AI, why send such (electrical) power hungry, radiation prone, difficult to maintain hardware to Mars, when humans are already there?
Array bounds checking would help but that’s only a small subset of the memory safety issues. I’m not a C programmer so I don’t know all the options available to mitigate memory safety issues in C/C++ but it looks like Microsoft thinks the solution may be to change languages: https://www.zdnet.com/article/microsoft-70-percent-of-all-security-bugs-are-memory-safety-issues/. Am I misinformed?
Yeah, the supply lines are really problematic. In the best case when you request a part the day before a scheduled launch and somehow get it on board, you still need to be prepared to wait for a rocket to travel from Earth to Mars (about half a year?). And in the worst case where the window has just closed, you have to add two years to the best case. Actually, the worst case is much worse than that. If your requested replacement equipment is lost in during landing on Mars, you have to start over. So your part arrives in something like in 4 years. It’s part of the reason that I just can’t see people colonizing Mars any time soon. The distances involved make rescues really problematic. Even with unlimited funds, you still have punishing travel times.
I think human existing on Earth without computers for most of our history is the wrong measuring stick. Living on Mars will be much more like living on the space station than anywhere on Earth. So it seems to me that computers with be absolutely vital to creating and maintaining breathable atmospheres in our structures, monitoring for conditions that could endanger the people and equipment there, communications, navigation, making water, making electricity, charging batteries, doing science, running “space” suits, controlling vehicles, making rocket fuel, etc.
Do you see any way around the extensive use of computers in Mars?
@Blaine
Array bounds and pointer checking are virtually synonymous in C, although fancier pointer checks are being considered.
The supply issue is what sets the very high priority for reliability and repairability. People who want to go to Mars either have a death wish, or no clue about the reality of living on Mars.
Electronic computers were not used in World War II submarines, there are alternative forms of computers.
The use of computers is tied up with what humans are going to be doing on Mars. If it’s about scientific study, then automatic probes are much cheaper.
Some similar constraints to these are discussed and worked through at collapseos.org. Interestingly, C is rejected there as too large. It seems Forth is sometimes used where small computers need to do important tasks. I’ve been reading more about how it is implemented, and there is this tantalizing feeling that I can nearly fit the whole thing in my head.
@Jared Jennings
C compilers are larger that Forth compilers, because there is more in the language. The collapseos.org website lists the Z80 as their processor of choice. The Z80 is plenty big enough to support a C compiler, in fact many 1980s microcomputers were Z80 based and there was lots of C (and Forth) software written for them.
Forth is very minimalist, and perhaps it is a better fit for people with a minimalist outlook; but then why pick the Z80, surely the 6502 is more minimal.
One could do better than falling back to core memory. For instance bringing Yokogawa’s minimal fab with them.
https://www.minimalfab.com/en/about/greeting.php
And FORTH is not the only thing which runs on simple hardware. May try (Active)Oberon like in
https://en.wikipedia.org/wiki/Oberon_(operating_system) and
https://en.wikipedia.org/wiki/Bluebottle_OS
Has tcp/ip, a zoomable graphical UI, some small apps, and may be simpler for people to understand. Can do realtime and is written in memory safe language down to the core.
@Flynn Tronsson
The minimal fab project looks interesting. I hope it succeeds.
The language chosen needs to be widely used, because at least here on Earth developers need to be found who can support it.
I used Pascal for many years, and am a fan of type safety. For whatever reason C took Pascal’s market share, and Oberon and Modula-2 (Wirth’s next language) failed to take off.