🚀 go-pugleaf

I think compilers and operating systems should go out of their way to punish
bad code. Things like unmapping the zero page, and initializing the stack
with something other than 0s are good examples of what I have in mind. Bad
code is due to one of two things, either the programmer is being lazy, or
he/she just didn't know about it. In the latter case, I am sure that the
programmer would prefer to know he/she screwed up instead of letting somebody
else find out about it. Even more important is the fact that a lot of this
"bad code" is flaky and a genuine pain to debug, regardless of the issue of
portability.

As an example, indirecting a NULL function pointer on an IBM RT will
effectively jump to the main() function of your program. Because of this, we
had a lot of fun one day trying to figure out why a certain program was
"infinitely tail-recursive". Indirecting a NULL pointer is likely to be an
unintentional error. Giving the guy a 0 just means that it will take longer
to find the bug.

Another bug I have seen twice in the last week is the following:

struct foo *InitFoo()
{

    register struct foo *tempFoo = (struct foo *) malloc(sizeof(struct foo));

    tempFoo->bar = 1;
    tempFoo->bletch = 2;
    tempFoo->baz = "loselose";
}

Notice there is no return statement there! Surprisingly, this code will work
on a lot of machines. The compiler wisely decides that it can use the return
register as a temporary (since there is no return value).

Sincerely,
Zalman Stern
Information Technology Center
Carnegie Mellon
(ARPA) zs01#@andrew.cmu.edu
(UUCP) try something like
...seismo!rochester!pt.cs.cmu.edu!andrew.cmu.edu!zs01#