Conditional catch clause

John J Barton johnjbarton at
Wed Dec 19 21:19:38 PST 2012

On Wed, Dec 19, 2012 at 7:55 PM, Brendan Eich <brendan at> wrote:

> John J Barton wrote:
>> On Wed, Dec 19, 2012 at 11:23 AM, Brendan Eich <brendan at<mailto:
>> brendan at>> wrote:
>>     The value of (2) is low but real.
>> I disagree. (2) is essential exactly because we depend on subsystems.
> Disagree on "low" or "real"? Evidently not "real", so must be "low". What
> I mean is using try/catch near the event loop to drop a "do not understand"
> exception on the floor instead of allowing it to terminate the loop (or do
> whatever an uncaught exception would do) is pretty low-value. Perhaps the
> event loop auto-restarts without a catch. Is the canonical console.log of
> the uncaught exception useful? Only if a developer is watching.

throw happens at any depth and trapping the throw in a development system
is -- or should be -- one of the fundamental operations supporting
development. An exception may arrive from outside of the developers
control, but during development most exceptions are bugs. In a dynamic
development environment we are mostly handling exceptions because our code
far from our goal. In a dynamic system syntax errors, reference errors, and
many kinds of algorithm errors surface as exceptions. Eventually we
approach our goal and the normal code has no exceptions. Unless we have
foolishly polluted our error handling mechanism with non-errors.

> My "low" does not mean "zero" -- that would take away the "real" value I
> ascribed. But it's pretty silly to say that try/catch for (2) is highly
> useful, in the sense that it adds a lot of value. If event loops
> auto-respawn it's at best a convenience and logging opportunity.

That's a very pessimistic view.  The primary goal for try/catch should be
to guard our code from subsystem issues. That means the try/catch should be
near the bottom of our stack, where we cross over. Placing try/catch at the
top for logging just means the subsystems are unpredictable and our
development solutions are so primitive we must resort to logging.

>>     StopIteration is only one example of (1).
>> And one too many, exactly because (2) is so vital.  We should not pollute
>> the critical feature of "throw exceptions" with "throw because I can't
>> figure out another implementation"
> The two use-cases are almost always disjoint. StopIteration is almost
> always auto-handled by for-of constructs.

Nevertheless the StopIteration triggers the exception handling machinery as
if it were an exception. The fact that it is handled by a catch is sadly
opaque to this machinery.

>          The mistake of including StopIteration should not be used to
>>         justify including more mistakes.
>>     This is Crockfordian in its dire sweep but I don't think you've
>>     made the case. What's your preferred alternative?
>> Don't include features that require StopIteration.
> The alternatives are worse. We've been over this. If you don't have
> something new to propose, you're not going to move the needle here at all.

I'm only trying to prevent the needle from moving further, as proposed by

I don't have any interest in StopIteration, but it seems pretty obvious
that an alternative could be created:
  dry {
   } datch(iStopped) {
That is, the entire try/catch/throw machinery could be copied and wired
into new syntax for the StopIteration case. The dry/datch/dhrow would be
independent of try/catch/throw.

Such a solution make the cost of StopIteration much higher, as it should
be. By hi-jacking the exception machinery, the cost of StopIteration is
artificially low. That is what we mean by a hack: a way of accomplishing a
goal that shifts costs on to others in the future.

-------------- next part --------------
An HTML attachment was scrubbed...
URL: <>

More information about the es-discuss mailing list