Glad you said this, because I was about to. ;-)
With one turnaround per day, plus a core dump (yes, it was core memory) on
execution errors, *every* data structure in memory was painstakingly
examined to find multiple problems per compile-execute cycle. Of course the
stack--and the stack "residue" beyond the current top-of-stack--was one of
the first data structures examined forensically.
Any detail that was not exactly as expected resulted in either finding a
latent error or revising my understanding of the program's behavior, or
The result was that after several cycles, my understanding of the
implications of the code I had written and it's interactions with the
hardware/software environment was richly improved. My confidence in the
code that worked was substantiated and my corrections to code that failed
were well thought out.
I sometimes found both compiler and OS bugs as well as my own, many of
which did not actually prevent my code from getting correct answers!
When computer cycles are precious, brain cycles are required to wring the
maximum amount of information from each trial run. The effects on both code
quality and programmer confidence (and humility) are remarkable.
My experience managing today's programmers is that they frequently have no
idea what their code actually does during execution. They are often amazed
when they discover that their use of dynamic storage allocation is wasting
90% of the allocated memory, or that a procedure is being executed two
orders of magnitude more frequently than they expected! And their tools
and tests, combined with their inaccurate understanding of their code's
behavior, prevent them from finding out.
They are very poorly prepared to program for performance, since, for
example, they have no practical grasp that a cache miss costs an order of
magnitude more than a hit, and a page miss, perhaps four orders of
Interactive programming does not preclude the development of craft, but it
apparently significantly impedes it.
All this becomes practically hopeless in modern application environments
where one's code constantly invokes libraries, that call libraries, etc.,
etc., until "Hello, world" requires thirty million instructions and has a
working set of a hundred megabytes!
Such progress in the name of eye candy...