The Classic C Quine (2003) (susam.net)

More modern and up-to-date references: https://rosettacode.org/wiki/Quine

For esoteric programming languages this might be more complete: https://esolangs.org/wiki/List_of_quines

You are writing in Text [1], where every program is a quine.

[1] https://esolangs.org/wiki/Text

  #!/bin/sed 1d
  Hello, World!

That is a polyglot which is written in two languages.

It is written and interpreted using the cat language, which is an interpreted language in which every possible byte stands for a self-printing action, and those actions are carried out in order for all bytes of the input.

It is also written in the hash-bang language, which is placed into a file to specify to the OS kernel what interpreter to use for the file.

So first this is interpreted as a hash-bang language statement, which then causes the cat interpreter to be applied, causing it to be a cat language statement.

The hash-bang interpretation is what induces the binding between the cat interpreter and the hash-bang statement, evoking the cat language interpretation.

:)

I like it, although if one is going for pure code-golf, then an executable empty file is a quine too :)

  touch foo && chmod +x foo
  ./foo

Unless one considers the commands to create & invoke it (as above) to be a part of the "source code" of course...

I suppose it would be posssible with a lisp.

I think this is what you're trying to do:

Y = (X + information) + X diff Y (This is kind of golden ratio-ish, imo)

It seems to be self referential which doesn't make it impossible, just maybe impossible.

I think the trick here would be calculating the lower bound of a massive block of text that could be encoded somehow to produce a sort of hash collision.

The program would essentially just read from a big chunk of text, and reconstruct the actual source code.

You'd have a separate program to read the previous text, read your program, and find a collision in your encoding scheme that satisfied your changes and also diffed correctly.

What that encoding algorithm is, I don't know, and I'm not sure it can exist. But if it does, I think you'd have to have to have a pretty big chunk of data to collide to even write a hello world program.

This is a pretty interesting problem, but I bet it can be reduced to a simpler computability/information theory deal. I'll be thinking about this all day.

The next step is basically a quine with a template of diff cruft around it. It has to output this, where N is the number of lines in the program:

  1,Nc1,3
  < HERE IT REPRODUCES
  < ITS OWN N-LINE IMAGE
  < ...
  ---
  > #!/bin/sh
  > head -n2 $0 | diff - /dev/null
  > exit 0

Since "quining" via $0 is evidently fair game, that simplifies things a lot. Here you go:

  #!/bin/sh
  sed -e 's/^X//' <<!
  X1,9c1,3
  $(sed -e s'/^/< /' $0)
  X---
  X> #!/bin/sh
  X> head -n2 \$0 | diff - /dev/null
  X> exit 0
  !

On first try, I didn't escape the dollar sigil on $0, so that got expanded to ./x3.sh, resulting in a minor difference. But since we are not doing any true quining, all I had to do was add the backslash without having to rack my brain on how to compensate for that character elsewhere; the "reproduce self accurately" requirement is trivially taken care of with $0.

With the above template, you can diff back to any body of text, so it can be easily continued.