TITLE: Proving that the halting problem is undecidable without reductions or diagonalization?
QUESTION [12 upvotes]: I'm currently teaching a class on computability and recently covered the proof that the halting problem is undecidable.  I know of three major proof avenues that can be used here:

Diagonalization - show that if the halting problem were decidable, we could build a machine that, if run on itself, is forced to do the opposite of what it says it will do.
Recursion theorem - show that if the halting problem were decidable, then we could build a machine that obtains its own description, determines whether it halts on its input, then does the opposite.
Reduction - show that some other undecidable problem reduces to the halting problem.

While I completely understand these proofs and think that they're mathematically beautiful, many of my students are having trouble with them because none of the proofs directly address why you can't tell if a program will halt.  Nothing in the above proceeds along the line of "computations can evolve in a way that is so complicated that we can't predict what will happen when we start them up" or "machines can't introspective on themselves at that level of detail."  I often give these intuitions to my students when they ask why the result holds, but I'm not aware of any formal proofs of that form.
Are there any proofs of the undecidability of the halting problem that directly explore why it's impossible for a program to decide what another program will do?
Thanks!

REPLY [3 votes]: I agree that the usual proofs are not very "informative", in the sense that they don't usually satisfy a student's desire to know why this is the case.  A "fully informative" proof would presumably construct the object in question -- but obviously you can't construct an object to show that it doesn't exist!  I wouldn't exclude the possibility of finding a "somewhat informative" proof, but I think such a proof, if it exists, might be complicated enough that a persuasive but non-mathematical argument might be better.
Appealing to the idea you mentioned, that "computations can evolve in a way that is so complicated that we can't predict what will happen when we start them up", seems to be a good approach (possibly using the Collatz sequence as an example of a computation that, clearly, evolves in ways we don't yet understand very well.)
A complementary approach might be to ask the student to consider program analyzers.  These are programs that take a program as input, and output "yes" if they can prove it has some property (like halting), "no" if they can prove it doesn't, and "don't know" if they can't prove either.  There are real-world examples of these programs, and it can be shown some are more sophisticated than others, and tying the argument to real software may help some students get a better conceptual grip on it.
Now ask: what happens if we run one of these program analyzers on, say, the standard Python interpreter?  The program analyzer can't truthfully say "yes" or "no", because it doesn't know what Python program the interpreter will be asked to run.
Even if we stipulate that the script that the Python interpreter will be running on be provided to the analyzer, the script itself could be an interpreter for some other programming language (ad infinitum).
Even if we stipulate that the program being analyzed take no input, it might be a Python interpreter with an arbitrary Python script hardcoded in it.  (I believe there are actual tools available for Python to do just this.)
Now, this reasoning is not absolutely watertight, but the idea is to emphasize that you can make programs arbitrarily convoluted, and to try to get across, "oh, no matter how sophisticated my program analyzer is, there will always be some program that is so convoluted that it is out of its reach."