
Radiation-hardened quine (2014) - warent
https://github.com/mame/radiation-hardened-quine
======
greenyoda
Some interesting discussion from when this was first posted in 2014:
[https://news.ycombinator.com/item?id=7276976](https://news.ycombinator.com/item?id=7276976)

------
codezero
They describe deleting characters, but most radiation causes bit flips, rather
than character removal. Good news, this seems to work with a bitflip as well
:)

~~~
colossal
I think the result would be the same no? Assuming the characters are stored in
ASCII the result of a single bit flip can only possibly modify one character.
Of course this assumes the program is resilient against modification in
general and not just deletion (which seems to be the case).

~~~
codezero
I wouldn’t assume so. A character has a lot of bits. So it kind of depends on
how the stream is processed I think.

------
nickpsecurity
For people interested, another search phrase for this and more kinds of errors
is Immunity-Aware Programming:

[https://en.wikipedia.org/wiki/Immunity-
aware_programming](https://en.wikipedia.org/wiki/Immunity-aware_programming)

Lots of failure modes to consider.

~~~
Rexxar
This link deserve a submission. Here it is :
[https://news.ycombinator.com/item?id=18849057](https://news.ycombinator.com/item?id=18849057)

~~~
nickpsecurity
Thanks!

------
gambler
I don't get people's fascination with quines. If your language supports at
least two ways of quoting strings and some basic regex replacements, you can
cook up a quine just by starting with an empty string and using double-cursor
functionality in any modern editor.

    
    
        ".replace(/^(.*)/, String.fromCharCode(34) + '$1' + String.fromCharCode(34) + '$1')".replace(/^(.*)/, String.fromCharCode(34) + '$1' + String.fromCharCode(34) + '$1')
    
    

"Take the previous string, print it inside double quotes, then print it as
is."

Is this supposed to be profound? I don't see how this has anything to do with
biology or life. It's simply a test of how cleverly you can abuse the syntax
of your language.

~~~
FakeComments
You don’t see how a self-replicating pattern in an abstract context can serve
as a model of self-replicating patterns in practical contexts?

Or why studying how different formalisms in language lead to different
complexity in constructing such patterns may relate to things like
bootstrapping DNA?

~~~
gambler
I don't see discussions of any of the things you mentioned. I see people
falling in love with "clever" code.

Quines can be made straightforward. You have two copies of your code. Copy 2
then prints copy 1 twice, creating the replica of the original 2 copies.
That's it. Everything else is trickery dealing with language boilerplate and
string escapes.

Similarly, I'm pretty sure the quine above is not generalizable to any
language. It's all about Ruby syntax, not some fundamental property of the
program.

------
xamuel
For people interested in philosophy of soft errors, I'll take this opportunity
to plug a paper of mine where I use soft errors to argue that empirical
evidence suggests we do not live in a computer simulation (at least not in one
ultra-specific type of computer simulation):

[https://philpapers.org/archive/ALEATO-6.pdf](https://philpapers.org/archive/ALEATO-6.pdf)

~~~
matthewwiese
Didn't expect to see a PhilPapers link on HN! I liked your paper, definitely
gave me something to chew on. I've never given much thought to attempting to
falsify the simulation hypothesis in any meaningful way (on account of a
general apathy to its oft "contrived" nature that you elude to). However, your
thought experiment regarding this supposed _x-x '_ property is quite clever.
Now my mind is buzzing...

P.S. I appreciated your reference to Popper in the abstract. It prompted me to
take my copy of _The Open Society & Its Enemies_ off the shelf and peruse it
for nostalgia's sake. :)

~~~
xamuel
Glad to set minds buzzing, it made me smile real wide to read that. I'll have
to check out that book you mentioned sometime :)

------
SilasX
Interesting! Feels like a metaphor for biological self-replication, which
keeps working after minor mutations.

------
webkike
You can harden this Quine even further (statistically) by adding lots of white
space where ever it’s allowed

~~~
jjnoakes
As long as you add white space in a way such that the output of the program
also has that white space.

------
ghubbard
This quine is covered briefly in Yusuke Endoh's talk from RubyConf 2017
[https://youtu.be/6K7EmeptEHo?t=1500](https://youtu.be/6K7EmeptEHo?t=1500)

The whole talk is awesome if you're interested in this kind of thing in Ruby.

------
KeyboardFire
See also:
[https://codegolf.stackexchange.com/q/57257/3808](https://codegolf.stackexchange.com/q/57257/3808)

~~~
darkmighty
See also:
[https://codegolf.meta.stackexchange.com/questions/2140/sandb...](https://codegolf.meta.stackexchange.com/questions/2140/sandbox-
for-proposed-challenges/14977#14977)

(disclaimer: self-promotion)

