Re: Exception Misconceptions
On Dec 22, 12:48 am, ta...@mongo.net (tanix) wrote:
In article
<a65d3221-02ca-4a18-907f-9027cce07...@c34g2000yqn.googlegroups.com>, James
Kanze <james.ka...@gmail.com> wrote:
[...]
Well, THEORETICALLY, it can happen even without using
exceptions. In reality, it is just a joke.
It's no joke. It's an everyday reality. Most of the phone
switches and transmission systems go back to a time before
exceptions, and they work. Year in, year out, without
interruption.
Yep. No argument there. Except those apps are infantile
by todays standards.
They were a good deal more complex than anything I've seen
written recently.
If you tell me I have to write my code WITHOUT exeptions, I
won't take your job offer. Sorry.
It would depend on the context. If they had a good reason for
not using exceptions, then OK. Otherwise, no.
I do not know why some claim the exception mechanism is so
inefficient even in cases where there are not exceptions, but
that is another matter.
Memories of early compilers?
I can only guess that if you want to get TOO sophosticated and
assure that you can unwind the stack even considering the on
heap allocations and things like that, and, as a result, have
to save all sorts of things prepairing to run the exceptions
bound code, may be.
I'm not sure which side of the issue you're looking at above.
From the language point of view, it's clear what has to be done,
and techniques exist (and are used in most compilers) which have
0 overhead (or almost) in the case when an exception isn't
thrown. From the programmer's point of view: if you have to
write any special handling in C++, you're not writing idiomatic
C++. But one of the more frequent errors I've seen in Java is a
missing finally block, when there are things that have to be
cleaned up, and the author didn't think about exceptions.
Who knows?
For one thing, without exceptions your code becomes a huge
pile of spegetti code and I know what I am talking about.
Apparently not,
Apparently yes.
I've worked on some very large projects without exceptions, and
the code was not at all a pile of spaghetti. It was, in fact, a
lot cleaner than a lot of code I see today, with exceptions.
I just wrote too much code to make such a statement. It is
simply inevitable.
So inevitable that it doesn't take place.
I'm tempted to say the opposite. Exceptions are just another
tool. A very convenient and effective one in specific cases,
but still just a tool. If you can't write clean code without
them, then you can't write it with them. Like any tool, they
don't change your native ability; all they do is make some
things (that you could do anyway) easier and less effort.
because I've worked on very large code bases,
without exceptions,
Again, this is a general purpose statement that does not
prove anything.
It's the exception that disproves your claim. (Obviously, I
can't post the code here, because it was propriatory. And
because it was several million lines of code, which would make
for a pretty large posting.)
Either you do test of your return codes, or you don't.
If you decide to do, and your logic runs to check all the
codes, then your code size and the amount of spagetti is
probably at least 30% bigger.
That's only if you don't know how to write code.
With exceptions, you do not check ANY return code
more or less. Clear to a 5 year old what it means.
Yes. That you're not handling a lot of errors the way they
should be. There aren't that many errors which warrent
exceptions. Most should be processed immediately.
[...]
Sorry. I can not agree with you on this one.
I think you are somehow predisposed AGAINST exceptions.
Not at all.
Yes you are. I have seen some of your posts.
Then you know that I'm not against exceptions. That I use them
when appropriate.
[...]
and we still managed to write robust and
maintainable applications.
Well. I am not saying it is not possible in PRINCIPLE.
I am saying it is a royal pain on the neck.
It's more effort, that's for sure. But there are a lot of
other things with even more impact.
In fact, I will make this claim:
If you do NOT use exceptions, you are just a lazy bum.
Or you're working in a context where they aren't appropriate,
for some reason. (On a really small embedded system, for
example.) But I do use exceptions. I also use return codes,
assertion failure, and deferred error checking (as in iostream
or IEEE floating point). I have more than one tool in my tool
kit, and I use which ever one is most effective for the job at
hand.
--
James Kanze