A few thoughts about death in the world of Tron: 1982.
Programs talk about “derezzing” and “deresolution” as if it means dying…
But they also use “dying,” “kill” and “dead” in almost the same way:
And various other synonyms and euphemisms for death:
and a few that might be euphemisms or slang, but actually use death-related words:
As well as a few mentions of “living” and “surviving.”
But I think part of the reason for this variation is that “deresolution” (“derezzed,” “derezzing,” etc) means something a little different from “death.”
I think the difference is between two meanings: the end of life, and the disintegration of the body.
Theoretically, a program could “derezz” without “dying”– that is, someone could be seen disintegrating, but still show up alive later, having been restored from a backup.
Maybe this is what Sark thought happened to Flynn here:
And one can also “die” without “derezzing”– as Sark did at the end, after which his dead body was used as an MCP-zombie for a while before it “derezzed” for real:
And it’s also possible to “rezz” and “derezz” without ever being alive at all, like Sark’s Carrier:
But even assuming that they do live in a world where derezzing isn’t necessarily death– a world where the dead can be data-recovered or restored from backups– there would still be a LOT of uncertainty about what happens after you die.
Maybe part of why they often say “derezzed” is to be more specific– because that’s the only thing they can know for certain, if they saw the body disintegrate in front of their eyes.
I’d imagine they are rarely completely sure whether or not a program is “dead” for real– and might come back later.
Or in what form.
I addressed this a little bit in my first Tron fic “Many-Handed Gods,” and @CoupleOfDays also wrote “Tron: Recovery” about the really fascinating concept of a data-recovery program bringing the derezzed-but-not-deleted back to life. There have been other stories too, and it’s always interesting to see different layers of it explored.
Death would be a really complex idea, inside the computer.
Because programs would only know whatever information their Users have seen fit to give them… and I imagine that wouldn’t often include any knowledge about what awaits them after deresolution. And it would be different for different programs, of course– even the User might not know what they’re gonna do until it happens!
Just offhand, I can think of three different variations on life-after-death for programs, each with its own sub-variations:
Recovery.
When you tell a computer to delete a file, it just makes the file ready to be overwritten if needed. Like in CoupleofDays’ story, derezzed programs could still be there as sort of data-ghosts, waiting for new data to overwrite them. If a data-recovery program gets to them before that, they could be restored to life.
Maybe just like they were before.
Or maybe different– if they’d already been partially overwritten. Lots of potential for horror there.
Restored from backup.
If the User still has a copy, they can replace the derezzed program with that.
Since the copy would have been made a while ago, I’d imagine that the rerezzed program would lack any new memories and changes since the last backup– essentially reverted to an earlier self.
If the User wants to make any new upgrades before sending the program back out there, then it’ll be different in those ways too.
So there are lots of ways your dead loved one might come back so different it’d be hard to think of them as the same program. And hey, in our world we already have enough disagreement about whether you’d count as the same person if you were replaced with a copy whose mind was exactly the same as yours at death. Imagine if there were also countless possible layers of just how different that copy could be.
Also, who’s to say the User will even decide to restore the backup to the same computer, or the same partition or “sector” or whatever? You might never see your friend again, and you might never know if he came back somewhere else.
Refactored/rewritten.
Instead of having a backed-up copy, the User might replace the destroyed program with a new one, written from scratch to have functions as similar as possible to the original.
How similar that program would be to your lost love… would depend on how faithful the rewriting was, I guess.
(And how would little rephrasings of code syntax end up manifesting, in the appearance and personality of programs in the system? Could memories of the program’s experiences be replicated that way too? And what if the User was a sort of memory savant and managed to recode the program exactly as written before? Would that carry over in the same way as if it was duplicated via copy-paste?)
So anyway… I can certainly understand how even in a world where re-rezzing is possible, the programs still have a healthy fear of death, and grief over the deaths of their fellow programs.
I sure would.
