The new std.process is ready for review

deadalnix deadalnix at gmail.com
Sun Mar 3 03:11:16 PST 2013


On Tuesday, 26 February 2013 at 18:48:08 UTC, Jonathan M Davis 
wrote:
> On Tuesday, February 26, 2013 09:02:11 Steven Schveighoffer 
> wrote:
>> On one hand, I think the correct behavior is to return null, 
>> and let the
>> program deal with checking the error, or use get if they have 
>> a default.
>> If we throw an exception, people will end up catching the 
>> exception in
>> order to avoid an unintended error. Exceptions are not good 
>> for flow
>> control, they are for exceptional situations that you didn't 
>> plan for.
>
> I think that it's far more correct to say that exceptions are 
> for situations
> where it's reasonable for code to assume that something's the 
> case when it
> might not be or when it's impossible for it to check. For 
> instance, it's much
> cleaner to write a parser if the parser in general assumes that 
> operations
> will succeed and throws when they don't. Then only a small part 
> of the parser
> needs to worry about handling error cases. Or an example of 
> when it would be
> impossible to check would be with file operations. You can (and 
> should) check
> beforehand that the file exists, but there's no way to 
> guarantee that the file
> will still exist when you actually operate on it (e.g. another 
> process could
> delete it out from under you), so the file functions have to 
> throw when the file
> isn't there anymore or you don't have permissions or whatever.
>

That is best explanation I've read on the subject. I'm dead 
serious.

> If you have to keep checking return values for functions, then 
> you should
> probably be using exceptions. The place to avoid exceptions is 
> when the odds
> of an operation succeeding are low (or at least that there's a 
> fairly good
> chance that it'll fail), because then it really is just 
> becoming flow control.
> But I actually think that pushing for exceptions to be for 
> "exceptional
> situations" is harmful, as that leads to people not using them, 
> and the code
> ends up checking return values when it would be much cleaner if 
> it didn't have
> to. Of course, there are plenty of people who are quite poor at 
> that balance
> and end up over-using exceptions as well, so striking a good 
> balance can be
> hard.
>

I want to add a point that you don't address here : it is easy to 
forgot to check return value. For instance, how much C code don't 
check the return value of printf ? I'd be surprised if it is even 
1% . When you don't, and things fail, you program is in undefined 
state and start doing crap. As exception are costly only when the 
are thrown, it don't make any sense to not use them for speed, as 
doing crap very fast is rarely a goal that people want to achieve.


More information about the Digitalmars-d mailing list