Is the halting problem pointless?
The point of the halting program IMO is not to show that you can't check whether an arbitrary program can halt--that's not a very interesting fact on its own. The point of the halting program, is to use &quot;reduction&quot;, to go on and prove that a (very large number of) procedures you might like to have a tool do are also impossible in general:

Deciding whether two programs are the same (including, whether a program always outputs &quot;true&quot;). This is true even for even many simple definitions of &quot;program&quot;.
Deciding whether a mathematical fact is true or false
Determining the longest time a program could run
Checking whether a particular line of code like an error condition, is possible to reach

Of course, much like NP-complete problems, it may still be worthwhile to work on heuristic versions or special cases. But knowing that it's impossible in general, saves us a lot of time trying to come up with a perfect version--after all, we usually want a perfect version if we can get one. And knowing that a problem is impossible in general, is a good hint that it may be hard in specific cases you're likely to run into (checking if two programs are identical for example, is actually really hard in practice).
I think it's fairly reasonable to assume that for any program a human would write, the answer is &quot;yes, it halts&quot;--otherwise it's a bug! So the class of &quot;programs a human would write on purpose&quot; is not really that interesting to look at.
A more interesting question is, &quot;what sorts of things in real programming, lead to problems analyzing whether the program halts?&quot;. For example:

Almost all opcodes (ex. addition) complete
Bounded loops complete (if the inner loop completes)
Function calls with no recursion complete (if the body of each function does)
Arbitrary while loops are hard to analyze
Global variables may be hard to analyze
Recursive function calls are hard to analyze

It's quite possible to invent a language (Charity, Epigram, and LOOP are academic/niche langauges, but you can also just imagine making a list of all these features and banning them from Java) where all programs halt. The challenge then becomes, can you express what you want to do in this language?
Edit: For an example of a practical program that is hard to analyze, here is bubble sort in python:
swapped = True
while swapped:
    swapped = False
    for i in range(0, len(list)-1):
        if list[i] &gt; list[i+i]:
            list[i], list[i+i] = list[i+1], list[i]
            swapped = True

As a human, we can tell that this program halts for all inputs. It's much harder to get a computer to realize the same thing.