Suppose you wanted to write a program in QBASIC (or Java or Haskell or English or whatever your favorite programming language is) that referred to its own source code at some point.

Well, you might find it to be too tricky at first. So nevermind QBASIC; you decide to instead invent a hypothetical new programming language QBASIC++, which is just like QBASIC, but augmented with *built-in* support for programs to be able to access their own source code: this language has a basic keyword "myOwnSourceCode" within it, which is to be interpreted as just what you'd think from the name.

How does one actually run a QBASIC++ program? Well, one thing you might do with a QBASIC++ program (let's call it P) is compile it into an ordinary QBASIC program, by going through its source code and replacing every instance of the keyword "myOwnSourceCode" with, of course, the expression of the actual source code for P.

So now we know how to make QBASIC++ programs which refer to their own source code (it's trivial by the design of the QBASIC++ language), and we also know how to compile QBASIC++ programs into ordinary QBASIC programs.

Of course, by combining those two, this means you can write QBASIC++ programs which refer to the compilation of their own source code into QBASIC.

And then, by actually compiling such a program into QBASIC, you're left with, in fact, an ordinary QBASIC program which refers to its own source code.

This is precisely the structure of the fixed point theorem: $F$ is some QBASIC-definable function, the free variable $v$ (in a QBASIC++ program) is the "myOwnSourceCode" keyword, $sub(P, num(P))$ compiles a QBASIC++ program $P$ into QBASIC, $H$ is the QBASIC++ program which applies $F$ to the compilation of its own source code into QBASIC, and $A$ is the compilation of $H$ into QBASIC.

[The fact that the free variable of $F$ was also chosen to be named $v$ in the presentation given in the question is, incidentally, an unnecessary and irrelevant distraction]