This project has always fascinated me, so I tried making a tiny uroboros quine with Python -> Javascript -> Python -> etc. I started with a quine for each language, and tried inserting them into each other, but the output always grew exponentially.

    py_quine_template = "s = {}; print(s.format(repr(s)))"
    py_quine = py_quine_template.format(repr(py_quine_template))
    
    js_quine_template = "s = {}; console.log(s.replace('{}', JSON.stringify(s)))"
    js_quine = js_quine_template.format(repr(js_quine_template))

    py_js_quine = py_quine_template.format(repr(js_quine_template))
    ???

So I checked how it's done in the Github repo[1], but the language snippets only seemed to be quoting and printing without any self-references like you'd expect in a quine...

Then it hit me. You only need the quine machinery in one language. If I can make a Python script that has a string with its own source code, then the Javascript code will simply be `console.log(py_source)`, no manipulation necessary.

So here's my Python/Javascript uroboros quine:

    s = "s = {}\npy_source = s.format(repr(s))\nprint('console.log('+repr(py_source)+')')"
    py_source = s.format(repr(s))
    print('console.log('+repr(py_source)+')')

If there were more languages, then it'd be `console.log("System.out.println({python_source})")`, etc. The problem then becomes escaping inner quotes, and escaping the escape characters themselves. I managed to sidestep the issue by using two types of quotes, and relying on Python's `repr` also giving valid JS strings, but if I had to add just one more language I'd need a lot more scaffolding.

I still think the Quine Relay is a tour de force, but now for different reasons. It's not 128 quines in different languages, but an incredibly robust system for escaping strings in 128 wildly different languages.

[1] https://github.com/mame/quine-relay/blob/master/src/code-gen...

i just want to know what possesses a man to do such a wonderful thing, and to even know if such a thing is possible before pursuing it

i would also watch a 128 hour livestream of him coding it because how do you even start

Discussion for 'quine-relay': https://news.ycombinator.com/item?id=33105706 (350 points | 7 months ago | 56 comments)

mame (yusuke endoh) also has a pretty awesome youtube channel which is basically just showing their hacks

https://www.youtube.com/@YusukeEndoh

mame is also very well known for their IOCCC submissions. My favorite is https://www.ioccc.org/2012/endoh1/hint.html.

It would seem that the author of this code is actually the World No. 1 IOCCC champ!

Number 2 really did make chuckle!

    cc -w chia.c -o chia

At the most basic, you just have N+1 copies of the program, and run whichever one is longest, since that must be the one with no missing characters.

The program itself then prints N+1 copies of itself...

You just need a little care about the start of the first program, since that is the 'entry point' - it needs to fall through to the 2nd program if the first is damaged.

There's a great video recently by Kurzgesagt video recently[0] on just how hard the immune system works to identify and kill any cell that is not cooperating anymore.

In a nutshell, the DNA fails at protecting from changes all the time, and the immune system is constantly checking for that and killing off those cells.

[0]https://youtu.be/zFhYJRqz_xk

It pretty much is, but it's not rad hard in the sense that you can change or delete any one letter. Well, maybe in animals and plants, since we have at least two copies of most genes.

DNA doesn't make a copy of itself, the cell makes a copy of the DNA. DNA doesn't really do anything, it requires RNA and proteins to actually do anything.

In some cases, this is in fact a useful way to look at it.

The DDC model[0] proposes that one of the drivers of evolutionary change is polyploidy, where after an organism has multiple copies of the genome, genes are free to drift into new functions.

An organism with four copies of a gene instead of the usual two is more rad-hardened than the basal non-ploid organism.

[0]: https://www.researchgate.net/figure/The-duplication-degenera...

Maybe it is the cell that is the quine?

It's not robust to any point mutation, only some, but I would still say this is a fair point

I think it’s just aesthetically reminiscent of radiation hardening. Pretty sure protecting agains arbitrary bit flips is impossible. If the MSB of the first character gets flipped, the code is illegal no matter what you do.

That's what this program is doing - the mutated code with one character missing will output the original program.

I think it would be more impressive if it produced itself (with character removed) after a character is removed

It's a quine!!

https://github.com/mame/green-square-quine

Not sure about “e xit” off the top of my head, this isn't one of my “natural” languages, but I assume breaking eval is protected against by the multiple invocations and the fact that assignment is an operator that returns its result as well as setting the target variable. If one of the evals is broken (or one of the =s between is removed) it just becomes a variable that is assigned to and the result is passed along. Three evals is enough to give the “any single character deleted” survivability, for “any two characters” you would need five (and many of the other tricks would need to be altered/expanded also).

There would also be a difference between deletion and replacing with a space character. Ie shorten the program file by one char (however many bytes depending on encoding). Can anyone explain what deletion means in this useage?

This is what “radiation-hardening” means in the context of programming challenges, it doesn't refer to actual radiation.

I'm quite confident I understand what is going on with such things, so it isn't black magic to me, but I doubt I'd be able to implement these tricks to do something like this myself in any practical amount of time.

There are multiple versions in the repo. The first one is essentially just two copies, the second was an improved design from someone else and the last was an ASCII-art version (of the radiation symbol) that was based off the second.

It is.

ChatGPT will write a ‘hello world’ that survives character deletions. I’m pretty impressed it can do this.

Defense in depth. Like the Space Shuttle that had four rad hardened processors. And a voting system to reject anomalous outputs. With two you don't know which one is right. With three you're OK. Four allows for one to permanently fail and still leave three.

This is analogous to having at least three NTP servers. Or filesystem level checksums on top of ECC RAM and LDPC in the SSD. Or TCP checksum on IPv4 header checksum on Ethernet/LTE/Wi-Fi checksum.

Protecting against cosmic bitflips for example, relevant if you write software that ends up on airplanes/space crafts. Also if you just want resilient software that work even though hardware is starting to fail. See https://en.wikipedia.org/wiki/Soft_error

In this case, it's just for fun.

It is self healing. The output matches the original

So by "character mutation" you mean the deletion of characters? Because to my ears that term still sounds like bit flips, i.e. changing characters.

Ah, I wasn't aware it was the name of a common code golf challenge, I do code golfing myself but apparently not enough :)

I guess it makes sense people would frame the game that way, arbitrary bit flips seems way too hard, I'm not even sure it's possible for a program to cope on it's own.

To be fair, "radiation" suggests only bit flips.

Someone said similar elsewhere, but the problem is the "meta code" that does the comparison needs to be hardened as well.

Yes, triple redundancy is nice, but then the problem becomes how to make the code that checks the code also tipple redundant and checked without creating another layer to deal with.

Most software that does this simply tries to make the test code as small and reliable as possible. But it's an interesting challenge to make the test code somehow self checking with the same properties.

> Isn't the solution to simply duplicate the code and compare it before execution? Do it 3 times and use the majority

Yes, voting is a common way to deal with radiation or critical software. There are of course also complications about the voting software itself needing to also be redundant. Some can be done with hardware, or you can just radiation harden parts of the system (reducing overall cost).

This is definitely one of those problems where at a quick glance it seems like there's a few simple solutions that can resolve 90% of issues but when you dig into the weeds you find out that 20% dictates most of the outcomes and there's at most a 10% overlap with your quick/obvious solutions.

Hardware radiation hardening techniques have existed for a long time, and are applied commonly in space, satellites, nuclear power, military.

Roughly speaking it breaks down into a couple categories including the manufacturing of electronics and chips themselves, including everything from substrate differences to using entirely different types of RAM and block storage [0], to the higher level strategies employed by many generations of space probes where a variety of total system redundancy is employed, e.g the Voyager probes used discrete component level redundancy, and most modern probes use almost full system redundancy where they run 3 complete computers in lock step, the idea being that triple redundancy is the minimum needed to detect which computer is wrong.

Another potential strategy not so commonly applied for this purpose is software resilience, such as the techniques applied by the Minix3 microkernel, the idea being to minimise the critical kernel code to be so small that it's unlikely to have bugs or be affected by hardware level affects, then everything else underneath can be kept alive by the kernel, even block device drivers, by employing triple redundancy and a "resurrection server". This was intended to protect against bugs in critical software like device drivers and hardware/firmware bugs rather than radiation, but it could be similarly effective especially as a layered strategy.

[0] https://en.wikipedia.org/wiki/Radiation_hardening#Radiation-...

That's part of the strategy for Europa Clipper.

https://europa.nasa.gov/resources/210/complete-europa-clippe... https://europa.nasa.gov/resources/342/electronics-vault/

Try doing that in space