Re: The origins of CL conditions system

Den Sat, 01 Dec 2007 13:15:58 -0500 skrev Kent M Pitman:

Proponents of static languages typically have a hard to accept the idea
that it may be good to let the user steer the behavior of the program.
(What if the user makes the wrong choice? Aren't our 'correctness
guarantees' potentially violated then?)

Yes, and the hard part is to see that this steering issue applies to
everywhere... all kinds of notations, not just conditions. Conditions, I
believe, are singled out disproportionately not because of their nature
but because they missed the boat in the metaphorical Noah's Ark that
separated the proto world of programming languages that were initially
conceived in early CS and the relatively small zoo of animals that are
present in the modern marketplace. The world reified around the
Algol/Pascal/C lineage of languages, and they didn't have those
characteristics, so people have come to think of the characteristics as
strange and exotic and ill-formed, when really their only crime was to
be omitted and therefore not to have a careful history of established
practice. People fear the unknown, whatever its form.

I wonder if some sort of insight couldn't be gained from the final form
C++ exceptions took, to try and reconstruct what might've been going
through its designers' minds at the time. C++ exceptions are a constant
source of problems, their odd suspension between static and dynamic
causing them to get the worst of both world. Problems and hacks like
"throw;" to work around the exception object being truncated to the base
class declared in catch(), oddities of catching by pointer and by
reference, the possibility of throwing destroyed objects, and the
incredibly shabby introspection capabilities RTTI offers; they all hint
at what might've been the idea of condition system the C++ committee got.
Presumably in this world introducing restarts was indeed a scary idea.

Probably better documented (or at least documentable) was the resistance
to lexical scoping. A LOT of people were VERY worried that dynamic
scoping had been used a long time and was tested (and, geez, it didn't
work that great since it compiled away if you didn't use SPECIAL
declarations, making compiled code and interpreted code work way
different from one another ... but people were used to that, even as
icky and rough-edged as it was, and were leary of this lexical thing).

I insist that you explain this in greater detail.

Heh. Could be. Oddly, I don't know that a lot of people understand
exception systems well enough to realize this. For example, I actually
worked for a while with some people trying to design a lexical errors
system and finally came to the conclusion it can't work. It's like
trying to lexically compile your web server and client together so you
don't have to talk to anyone who dynamically approaches. Protocols are
about disjoint pieces. And yeah, that makes it harder, but more
interesting.

As one of my favourite quotes states, "Functions are usually invoked at
runtime...". I always found C++'s pretense of having a real static type
system, when the starting point was portable PDP-10 assembly, laughable
at best.

And, for myself, I am probably UNDERsimplifying here, which is why I run
on for so much longer than others do. Sorry for rambling. I never know
what parts people will care about and what they won't...

No, no, why do you think I started that thread, if not to get you to
share some of stories from when the Earth was still green?

Cheers,
Maciej
.

Relevant Pages