Well, it really depends on the nature of the radiation hardening.
Modern computing is all complementary mosfet based. You have a transistor to pull the signal up quickly, and a transistor to pull the signal down quickly.
The thing with CMOS is that, if both transistors turn on at the same time, it creates a short circuit. Depending on details of how the silicon was actually made, a short like that could either permanently cause damage, or it could just cause the circuit to transiently crap out until it reboots.
Exotic radioactive particles have a tendency to turn mosfets on when they smash into them. This can cause those sorts of short circuits. Some computers blow up, while others just stop working until power cycled.
In space, you obviously don't want to use the computers that blow up when that happens. If you use the computers that just transiently fail, then you generally need to have redundant computers able to keep the rest of the system running while they reboot the computer that failed. That does add a lot of software complexity, but at least the computers are relatively normal.
Transistors are less likely to be toggled by radiation the larger and more capacitive (slow to toggle) they are, so if you make a computer with big slow transistors, it will be unlikely to crap out even if a bunch of radiation is hitting it. That's handy because the software can actually be really simple. You just run your program and trust that it will be reliable enough to get it's job done.
Not all errant transistor flips cause a short circuit, they may just cause a miscalculation. Most of the calculations a computer does don't actually matter, and no one ever notices. It does mean the computer is slightly irrational, though, and that's bad for a computer. There's chips that have hardware support for detecting miscalculations and memory corruption. There's nothing particularly special about writing software for them. Typically you just need to implement an interrupt handler for when the hardware detects corruption, and you need to write a task that periodically reads every physical memory address so that the memory controller can proactively fix any bit flips in the memory.