At what point does the get command (Befunge, ><>, etc) count as reading your own source code?

Question

Related

The get command, shared by Befunge and ><>, is a command that pops two values x and y and retrieves a value stored at that cell (its counterpart is the put command, which stores a value at a certain cell). The problem is that the 2D surface is the same surface the source code is running off, with uninitialised cells being value 0.

Here is an example of 3 ><> quines, with varying use of the g command:

0:0g:?!;o1+!

This simply iterates over the first line using the get command until it reaches an uninitialised cell (disregard that it's invalid for other reasons).

"r00g>o<

This gets the " from the first cell, avoiding having to calculate the value manually, which is two bytes longer(75*1-).

'rd3*>o<

This avoids the use of the g command altogether and should be valid regardless.

---

Okay, let me add an edge case to illustrate.

Say there's a challenge to find the product of two positive numbers below 5 without actually using multiplication. Underneath our actual code, we create a box with the appropriate values so that we could simply grab the value at that point on the grid. In Befunge, for example:

&  &  g  .  @
   1  2  3  4  5
   2  4  6  8  10
   3  6  9  12 15
   4  8  12 16 20
   5  10 15 20 25

(Pretend that the numbers are the cell values). Does this count as reading the source code, even when the closest analogy would be declaring a 2D array?

How about the wrapping string literal, a common staple of the 2D language quine? It is also accessing the exact same data that the get command is fetching its data from, which seems like a bit of a double standard to me.

And just the normal string literal? Take the Befunge program "@"#,<, which reuses the @ as both the printed character, and the terminating instruction. Does this count as reading the source code, as it both executes and reads the same character?

Answer 1

This is no different than self-modifying brainfuck in regards to the rules: it only counts as reading its own source if it does, in fact, read its own source. If the cell being read is outside of the bounding box of the source code, then it's fine. If not, then you're reading the source code.

Answer 2

If the read value depends on the original source code, then it reads the source code

For example, in a self-modifying language, if the source code has not been modified since the program has started, then executing get would always count as reading your source code.

Another example that counts as reading your source is if get reads a byte which has only been incremented since the start of the program, thus still depending on the original source code.

An example which doesn't count as reading your source code is if get reads a byte which has been replaced with another byte which doesn't depend on the program's source code itself, for example get reading a byte which has been replaced with @, then incremented to A, since the @ hasn't been inferred from the original source code itself via getting.

Examples with ><> programs

01go;
X

This pushes 0 and 1 to the stack (01), then pops those two values and reads (g) the character at that 0-indexed (y, x) position (1, 0) in the (possibly modified) source code (X in this case), prints it (o) and then exits (;). Try it online! Try changing the X to another character, and you'll see that the printed character changes accordingly. Thus, it's evident that g reads part of the original source code.

01g1+01p01go;
@

This gets the character at position (1, 0) of the source as before (01g), increments it (1+), then replaced the character at position (1, 0) of the source with the incremented character (01p), then again gets the character at (1, 0) (01g), and finally prints it and exits (o;). Try it online! As before, if you change the @ to a different character the result will also change. Again, you can see g reads from the original source.

f4*4+01p01go;
I

This pushes 15 (f), multiplies it by 4 (4*) and then adds 4 (4+), resulting in 64, then puts the character with that ASCII code (i.e. @) on (1, 0) (01p), then gets the character at (1, 0) (01g), prints it and exits (o;). Try it online! In this case, if you try changing the I to another character, the output won't change. This is because, regardless of what character you change it to, it will be always replaced with @, therefore making it not count as part of the original source code anymore.

Answer 3

get is cheating, although the line is blurry

As mentioned in the OP, a prior thread about SMBF resulted in a clear consensus that using the tape values initialized to the source code character values was "cheating" and not a proper quine. It's a fairly strong consensus.

However, a different meta question about Javascript resulted in an equally strong consensus that printing the string representation of a function's source code is valid. The question then becomes, what makes these two different, and which one is get more like?

To put it simply, my interpretation of why the Javascript is valid is just because it accesses a string representation of a function not the program. At least, that's the only distinction I can see between the two. In none of the example programs do I see any indication that the source code of a function is read, but rather that the program's source code is available in full, just like SMBF. If we assume that both prior consensuses are still valid, then get must follow the SMBF precedent.