Not OP, but for what it’s worth, I consider it unreasonable to request that other people think of you in a certain way (be it gender, or having personal traits or skills or anything), or at least for there to be any sense of expectation or obligation that they will fulfill such a request. That would be actual thought-policing, and abhorrent to me. It’s reasonable to want people to think of you a certain way, to hope that they will, to take actions that will hopefully increase the likelihood of it, and possibly to only be close friends with people who do think of you that way (although I think it’s usually wise to try not to care too much about what others think about you). But I feel strongly that people have a right to think whatever thoughts they want, and that anything that seems to be punishing people for thoughts (as opposed to actions or speech) should raise major alarm bells.
Therefore, to the extent that people are told “You should accommodate the desires of trans people, and will be told you’re a bad person and possibly face social consequences if you don’t”, expected accommodations of the form “Think of them as female even if your brain naturally classifies them as male” are unreasonable. “Avoid speech or other visible actions that rub in their face the fact that you think of them as male” is polite, and may be reasonable to expect; “Use these pronouns when referring to this person in front of them” is an obvious example of that.
So that is the strong-request/demand that it’s reasonable for people to get from “society”. (If people in power were unambiguously saying “In order to be polite and not be called bad, you must think of these people in a certain way”, then I think there would be revolts.) If someone hasn’t become emotionally close friends with any trans people, I’d say it’s not too surprising if they haven’t picked up on something subtler than “socially enforced rules”.
I happen to work for a company whose software uses checksums at many layers, and RAID encoding and low-density parity codes at the lowest layers, to detect and recover from hardware failures. It works pretty well, and the company has sold billions of dollars of products of which that is a key component. Also, many (most?) enterprise servers use RAM with error-correcting codes; I think the common configuration allows it to correct single-bit errors and detect double-bit errors, and my company’s machines will reset themselves when they detect double-bit errors and other problems that impugn the integrity of their runtime state.
One could quibble about whether “retrieving and querying the data that was written” counts as a “computation”, and the extent to which the recovery is achieved through software as opposed to hardware[1], but the source material is a James Mickens comedic rant in any case.
I’d say the important point here is: There is a science to error correction, to building a (more) perfect machine out of imperfect parts, where the solution to unreliable hardware is more of the unreliable hardware, linked up in a clever scheme. They’re good enough at it that each successive generation of data storage technology uses hardware with higher error rates. You can make statements like “If failures are uncorrelated, and failures happen every X time units on average per component, and it takes Y time units to detect and recover a failure, and we can recover from up to M failures out of every group of N components, then on average we will have an unrecoverable failure every Z time units”; then you can (a) think about how to arrange it so that Z >> X and (b) think about the dangers of correlated failures.
(The valid complaint that Mickens’s character makes is that it would suck if every application needed to weave error correction into every codepath, implement its own RAID, etc. It works much better if the error correction is done by some underlying layer that the application treats as an abstraction—using the abstraction tends to be more complex than pretending errors don’t exist (and for noncritical applications the latter is a valid strategy), but not terrible.[2])
With regard to AI. It seems likely that we’ll end up making use of potentially-dangerous AIs to do things. If we do, then we’d want powerful safeguards. It seems unlikely that we’d have 100% confidence in any particular safeguard (i.e. unlikely we’d have formal proofs of the safety properties we’d want). Then we’d want to keep adding more safeguards as long as their failure modes weren’t totally covered by those of preexisting safeguards (and as long as they’re affordable); ideally we’d try to estimate (ideally measure) the chance of failure of each safeguard and how independent they are.
Now, would some of these safeguards be built with the aid of earlier versions of AI? I’d guess yes. This could take a few forms, ranging from “formally-verified direct programs that the earlier AI generated along with their proofs of safety and effectiveness” to “smaller neural nets (cut-down versions of earlier AIs?) that monitor the training of the new AI’s net” to “weaker full-blown AIs watching the decisions output by the new full-blown AI”. I suspect any of these might be useful.
The Godzilla complaint seems to be about that last thing, having weaker AIs monitor the new AI. Well, um, it seems to me that, if the weaker AIs’ output is restricted to the one-bit signal “do we hit the killswitch on the new AI” (and that signal is executed by a machine), then there’s no danger of Godzilla destroying Tokyo after it has taken down Mega-Godzilla. (It’s like cutting off Godzilla’s limbs and tying him to Mega-Godzilla with his jaws open around Mega-Godzilla’s neck, so his only available action is biting down.) There is a danger, if this happens a lot, of the subsequent training of the new AI merely teaching it to evade detection by the weaker predecessors; this danger should be taken seriously; but it is also less bad than having Mega-Godzilla kill us the first time it started going rogue; the safeguard is net positive.
Addressing specific claims:
If, among our many precautions, we have AI 1 oversee AI 2 (in this scheme I describe where AI 1′s only available action is to output a bit that shuts off AI 2)[3], and AI 2 starts to go rogue, and AI 1 fails in its task, then we’re no worse off than if we lacked that particular precaution—either the other precautions save us or they don’t. If AI 1 succeeds, then we have at least some chance of being able to debug what went wrong with AI 2, and save ourselves in the future. Using AI 1 as overseer is strictly beneficial, minus implementation costs. (There’s a second-order risk of someone overestimating how much it protects us and then choosing to be more reckless, but that’s a different kind of thing.)
If “goes wrong” means “it kills us all”, then yeah. If “goes wrong” means “it starts acting dangerous but we manage to shut it off”, that is potentially recoverable.
The parent could be aligned but incompetent (heh, I think many people know parents like that), while the child is unaligned and more competent. (Why would the programmers create the child if it weren’t expected to be more competent than the parent?) It seems easy to imagine alignment checks that the parent would pass while the child would fail.
The checksums are done by the CPU but hardware-accelerated; I think the RAID stuff is clearly software; the LDPC stuff is done by more specialized hardware; the ECC RAM is hardware, but the choice of how to respond to double bit errors is software.
ECC RAM is one example: the application can just assume that memory accesses are correct, and that double-bit errors will cause the operating system to kill the application—so the application itself needs zero lines of code about RAM errors, though now there does need to be monitoring to restart the process and/or fail over to another machine.
Another example is using a durable database, and going from “just increment and decrement the variables in memory” to “create a database transaction, to be attempted / rolled back as a unit”. That does require code changes in the application itself.
In practice we’d probably want it to output something more like a number between 0 and 1 representing its worry level, and likely the killswitch goes off if either a single overseer exceeds some danger threshold or multiple overseers exceed some lower threshold.