Halting Problem without self-reference: why does this argument not suffice (or does it)?
I don't think this is a good way to present the halting problem, because it sweeps a critical issue under the covers in a sneaky way.  I suggest sticking with a more standard presentation, such as the one you linked.  If you want to find a way to explain it in a way that minimizes the technical content, the presentation in this video is surprisingly accessible, and remains true to the logic of the standard proof.

On to the difficulties with your proposal.  In your proposal, it's not trivial to write down the code for such a Q.  Think about what it means to have the line

  if H(Q,J) then loop forever 


Recall that the first argument to H is a bit-string that contains the code /  algorithm / Turing machine -- it's not a pointer to the function, but a string.  Naively, this seems to mean that we include a hardcoded string that contains the source code for Q, inside the code of Q.  But that's not possible.  Suppose the code for Q takes 100 characters.  Then we need to hardcode a 100-character string constant inside the definition of Q, plus we also need some more characters for the rest of the logic -- and that adds up to more than 100 characters.  If you think about it, it's obvious that we can't have a string constant inside the code of Q that is the code of Q, because it would be too long.

Maybe you're thinking that's not what you had in mind.  Maybe you were thinking that the programming language will have some built-in API to get the code of the current function, so actually the code you were thinking of is something like:

def Q(J):
  if H(get_source_code_of_current_function(),J) then loop forever
  else halt


OK, fine.  This proves that the halting problem can't be solved for code written in any programming language that has a get_source_code_of_current_function() API.  However, my favorite programming language doesn't have such an API.  So, this proof doesn't prove anything about my favorite programming language -- perhaps the halting problem is solvable for my language, who knows?  Similarly, Turing machines don't have such an API, so this doesn't prove that the halting problem for Turing machines is undecidable.

And that's a major flaw in your proof.  And it's a flaw that is subtle and not at all evident.  I don't think it's pedagogically a good idea to present a proof that "looks valid" on the surface but is actually, once you dig into it deeper, flawed.

Now, it is possible to rescue your proposed proof.  It actually is possible to construct a function Q that works the way you said; you basically need it to be a quine.  I suppose in principle you could explain the idea of quines, then present your proof and explain how to implement a function Q using those ideas.  But that seems like a bad idea to me, from a pedagogical perspective.  Quines are mind-bending and mysterious and freaking hard to understand.  A student who doesn't understand quines won't understand your proof.  And it makes the proof of undecidability for the halting problem look a lot more mysterious than it needs to be.  So this does not seem to me like a more accessible way to understand the halting problem.