There's a lot of questions that result in code that refers to itself. Typically these questions get assigned the tag, though it's not quite applicable in some cases.

I propose a new tag , which is applied to questions where the answers in someway refer to their characteristics, such as length or characters. While there's some overlap with , I believe this can be reconciled by having refer to challenges that have to output or generates versions of themselves, such as permutations, sections, or backwards.

Some questions that would benefit from adding the tag (and maybe removing the tag):

Something like the self-identifying quine or print every character you program doesn't have might get both tags.

  • \$\begingroup\$ So self-referential programs doesn't need to fully know all information about itself, while quine does. \$\endgroup\$
    Apr 16, 2018 at 4:49
  • \$\begingroup\$ For example "a program that calculates its sha-256 hash" is self-referential (... or it is not?) \$\endgroup\$
    Apr 16, 2018 at 4:50
  • \$\begingroup\$ And... no, I think self-identifying quine should be a quine. It's possible to calculate its own source code by running it over all strings until something matches. \$\endgroup\$
    Apr 16, 2018 at 4:50
  • \$\begingroup\$ @user202729 In the question I suggested quine refer to code that outputs its source code transformed in some way. It makes more sense to call a self-identifying program "self-referential" than "quine-like", though the fact that programs would usually have to generate the source code to compare against is why I suggested it gets both tags. A "sha-256" program would probably be closer to a quine because while the hash is semi-unique for each text, it's not an intrinsic attribute of a program. \$\endgroup\$
    – Jo King Mod
    Apr 16, 2018 at 5:03
  • \$\begingroup\$ @user202729 Not necessarily. You might end up with a collision instead. \$\endgroup\$
    – mbomb007
    Apr 16, 2018 at 18:08

1 Answer 1



would be strictly weaker than . should only be used for tasks involving the actual manipulation of the program's source, which is not required for the challenges linked.

While "Output with the same length as the code" could theoretically be done by using a standard extensible quine to get the source, computing the length of the source and using that to generate a string, it is unlikely that would be competitive. Because it is not the only viable approach to solving the challenge, is more appropriate.

This distinction seems useful to make.


You must log in to answer this question.

Not the answer you're looking for? Browse other questions tagged .