User: Password:
|
|
Subscribe / Log in / New account

No thanks.

No thanks.

Posted Nov 9, 2012 8:00 UTC (Fri) by paulj (subscriber, #341)
In reply to: No thanks. by HelloWorld
Parent article: Haley: We're doing an ARM64 OpenJDK port!

He's stated it in terms that aren't correct, but I think he means exceptions increase the number of possible control-flow branch points in the code. Without exceptions, the branch points in a block of code are visually obvious. With exceptions, there may be multiple branch points per statement - and they are *implicit*, you can't see them.

This certainly raises the bar to fully understanding the behaviour of exception using code.


(Log in to post comments)

No thanks.

Posted Nov 9, 2012 9:33 UTC (Fri) by Cyberax (✭ supporter ✭, #52523) [Link]

Nope. Exceptions force you to restructure you code to be exception-sane.

I.e. if you open a resource then you should do it in a try-finally block (or its analog). In C++ you should wrap in automatic object.

Error codes, on the other hand, promote sloppy design. Certain error codes are almost always ignored, like printf() return result (do you know that it can be used to process SIGINT gracefully?) or close().

No thanks.

Posted Nov 9, 2012 9:47 UTC (Fri) by paulj (subscriber, #341) [Link]

Sorry, but it's a fact that exceptions introduce implicit control-flow branch points at each statement, potentially even multiple such. That you can disagree with my comment on that point suggests either that you do not understand how exceptions are implemented, or else you somehow ignored the content of my comment in replying to it.

That coping with this requires structuring code in certain ways when using exceptions is true, but a different point, and it is still non-trivial at times because of the prior point. Just have a look at discussions on exceptions in C++ in constructors and destructors.

Note that I was not advocating for error return codes. That's a strawman argument you're incorrectly attributing to me.

No thanks.

Posted Nov 9, 2012 10:22 UTC (Fri) by hummassa (subscriber, #307) [Link]

That is the point:

> Sorry, but it's a fact that exceptions introduce implicit control-flow branch points at each statement, potentially even multiple such.

THAT IS NOT A FACT AT ALL.

Those implicit control-flow branch points WILL HAVE TO BE DEALT WITH ANYWAY, they were already there. Only without exceptions you have to deal with them all at all positions in your code. Explicitly. You are writing code that is scaffolding code, not code that does what the program actually needs to do.

When you use exception, you write only the code that does what the program actually needs to do, with some sanity checks here and there. You follow the sanity rules, you are safe.

For instance, every time you open a file things can go wrong. Supposing you have a function call hierarchy main -> f -> g -> h, and h() wants to open a file, one of the following will happen:

1. you (generic "you", ok?) won't check open() results, will proceed as if the file was open, and undefined and terrible things will happen;

2. (try#2) you will check open() results, return an error code, g() does not check for the error code and proceeds, hilarity ensues;

3. (yes it finally works) g() checks h() error code, f() checks g() error code, main() checks f() error code, prints a suitable message.

4. (despair happenning) you have to call i() from g() and j() from f() and both have to open files. At this point, if you don't forget anything (you have to do every of these checks yourself, manually) you have a program that is at least 25% scaffolding.

With exceptions, one of those will:

1. open() throws, _main() aborts and prints "unexpected exception". The program already works.

2. (let's make this pretty) you put a catch() block on main(), print a pretty message cerr << "file " << name << " could not be open". The program still works.

3. (down the road) you have to add i() and j() and the program still works. No need to repeat step 2.

> Note that I was not advocating for error return codes.

No, but you are differentiating "implicit control-branch points" from "explicit" ones and it does give that impression. My point is that: implicit control-branch points are there anyway (you open a file, things can go wrong in the process), and dealing with them implicitly is better then explicitly.

Yes, dealing implicitly with exceptions means that sometimes you have to be exceptionally (ha!) safer (constructors/destuctors). But it just helps you to clarify your code and tell better when things can go wrong.

No thanks.

Posted Nov 9, 2012 10:29 UTC (Fri) by paulj (subscriber, #341) [Link]

So the control-flow branch points which you disagree exist have to be dealt with anyway? So they don't exist but they do.

There are other ways to deal with errors, besides exceptions or error return codes. You can design the underlying, called-into code to explicitly follow a state machine, and have idempotent error state. Calling code then do a number of operations on such objects, and check at the end whether they succeeded or not, and if not, query the reason for the error.

No thanks.

Posted Nov 9, 2012 16:35 UTC (Fri) by HelloWorld (guest, #56129) [Link]

> So the control-flow branch points which you disagree exist
Did you even read what he wrote? He didn't say they don't exist, he said that they exist regardless of whether you use exceptions or error codes to handle errors.

No thanks.

Posted Nov 9, 2012 23:40 UTC (Fri) by nix (subscriber, #2304) [Link]

Each statement? If only it were so easy. At each statement, each function call, and each potentially overloadable operator. The number of abnormal edges can get ridiculous. There could be *dozens* in a single thing that looks like one statement.

No thanks.

Posted Nov 10, 2012 3:26 UTC (Sat) by Cyberax (✭ supporter ✭, #52523) [Link]

Nope. The number of statements where special exception handling is needed is SMALL. Basically, only the code that works with external or shared long-living resources.

No thanks.

Posted Nov 10, 2012 10:21 UTC (Sat) by paulj (subscriber, #341) [Link]

There you go again saying "Nope" to something that is factually correct. At this stage it's hard to conclude anything other than that you simply don't understand how exceptions work under the hood.

No thanks.

Posted Nov 10, 2012 16:10 UTC (Sat) by nix (subscriber, #2304) [Link]

It's clear he's never written any significant body of exception-safe code in C++, that's for sure. (Hint, Cyberax: consider a simple RAII object which allocates some memory in its constructor, in two tranches, with a single assignment between. Now consider that memory allocation can throw bad_alloc, as can the invocation of the assignment operator, if not elided by the compiler, as it can sometimes be -- and consider that if this is templated, you have to consider that *every possible point* that might throw exceptions, will throw exceptions, since you don't know what types you'll eventually be dealing with.

That memory allocation is not a shared resource except inasmuch as the heap is shared -- in which case you have to consider almost *everything* a use of a shared resource -- but you still need to consider the semantics of exceptions in order to figure out how to avoid a memory leak. And this soon gets thoroughly unobvious.)

No thanks.

Posted Nov 10, 2012 21:48 UTC (Sat) by Cyberax (✭ supporter ✭, #52523) [Link]

>Hint, Cyberax: consider a simple RAII object which allocates some memory in its constructor, in two tranches, with a single assignment between.
#include <stdio.h>
#include <memory>
#include <stdexcept>

class tracer
{
public:
	tracer() { printf("Constructing\n"); }
	~tracer() { printf("Dying\n"); }
};

class tester
{
	std::auto_ptr<tracer> t1_;
	std::auto_ptr<tracer> t2_;
public:
	tester()
	{
		t1_=std::auto_ptr<tracer>(new tracer());
		throw std::runtime_error("Test");
		t2_=std::auto_ptr<tracer>(new tracer());
	}
};

int main()
{
	try
	{
		tester t;
	} catch(const std::runtime_error &ex)
	{
		//Print exception info
	}
	return 0;
}

cyberax@cybmac:~/work$ ./a.out 
Constructing
Dying
And your point is?

Consider that you have to deal with exactly the same crap if you DO NOT use the exceptions. EVERY function you invoke can cause error conditions (such as out-of-memory).

Now please rewrite my example without exceptions, providing the same level of guarantees and functionality.

No thanks.

Posted Nov 10, 2012 23:06 UTC (Sat) by nix (subscriber, #2304) [Link]

You really don't understand, do you?

Consider just these three lines of your example:

t1_=std::auto_ptr<tracer>(new tracer());
throw std::runtime_error("Test");
t2_=std::auto_ptr<tracer>(new tracer());

Let's replace the stupid throw with something more likely to be actually seen in practice, say:

t1_=std::auto_ptr<tracer>(new tracer());
ptr=std::auto_ptr<blah>(new raiied_blah());
t2_=std::auto_ptr<tracer>(new tracer());

Now... if any of those constructors but the first throws, what do you do about it? If, for whatever reason, you cannot use auto_ptr (which is, to be honest, simply pushing off the RAII memory-allocation overhead to something else that has already done all the work) how do you prevent the earlier-allocated ones from leaking? That's right, you have to free at appropriate times in a catch handler. Now figure out which bits can throw. It's hard. It's very, very hard. I recommend Scott Meyers's Effective C++ books for more than you can possibly stomach on this (I wish I could reread mine, but I loaned them out and they never came back, I'm sure you know how it is).

No thanks.

Posted Nov 10, 2012 23:22 UTC (Sat) by Cyberax (✭ supporter ✭, #52523) [Link]

Try it. I really mean it - try it. It would work just fine. Everything will be correctly destroyed.

>If, for whatever reason, you cannot use auto_ptr (which is, to be honest, simply pushing off the RAII memory-allocation overhead to something else that has already done all the work) how do you prevent the earlier-allocated ones from leaking?
By using auto_ptr or any other fitting smart pointer, there's literally no measurable overhead in using it. And there's no excuse in not doing it - and that was clear from the very start. That's actually a rationale for not including the "finally" keyword in C++ - because it might detract from using RAII.

Of course, if you really don't want to do it then you'll have to do the try..catch dance. Exactly like in C where ALMOST EVERY function might result in error and the most common pattern of error handling is "goto err_exit". That's actually why glibc handles OOM by calling abort() - it's simply too complicated to make everything in C error-safe.

PS: I had actually written a simple model verifier to verify my own collection library for upholding exception guarantees. That means that I've obviously read Sutter, Meyers, Stroustroup, Alexandrescu and quite a lot of other C++ writers.

No thanks.

Posted Nov 10, 2012 23:25 UTC (Sat) by foom (subscriber, #14868) [Link]

> Now... if any of those constructors but the first throws, what do you do about it?
You don't have to do anything, because auto_ptr's destructor takes care of it for you.

> If, for whatever reason, you cannot use auto_ptr ( which is, to be honest, simply pushing off the RAII memory-allocation overhead to something else that has already done all the work

That's the whole point! You *always* just use auto_ptr (or another smart pointer, e.g. unique_ptr) to take care of it for you! That's exactly why RAII is so nice, and has been best practice in C++ for years!

No thanks.

Posted Nov 11, 2012 9:32 UTC (Sun) by paulj (subscriber, #341) [Link]

That smart pointers are required exemplifies the "non-trivial" observation made of exception using code. And remind me again, how long have these been available as part of the standard C++ environment?

No thanks.

Posted Nov 11, 2012 10:37 UTC (Sun) by Cyberax (✭ supporter ✭, #52523) [Link]

Since at least 80-s. The problem was mostly in old C programmers who don't know better.

No thanks.

Posted Nov 11, 2012 12:53 UTC (Sun) by paulj (subscriber, #341) [Link]

Rubbish. I have books from the 90s on C++ that fail to mention smart pointers anywhere, written by C++ committee members.

Could good C++ programmers have created their own smart pointers in the 80s? I guess so. My strong impression though is that C++ programmers would have been *way* ahead of the state of understood wisdom in the C++ world at that time. My impression

To claim smart pointers are trivial, widely understood techniques since the 80s stretches credibility somewhat. If they're so trivial, so widely understood for so long, why did it take 20+ years to standardise some? Why is an only relatively recently standardised form of smart pointer already being deprecated in the next C++ standard? (auto_ptr for unique_ptr). My sense is that smart pointers are so trivial that even C++ standards committee members hadn't really fully grokked the implications of copying, moving and sharing them until relatively recently - but I guess they're just "old C programmers who don't know better".

Unfortunately, in the real world, many programmers just aren't quite as brilliant as you.

No thanks.

Posted Nov 11, 2012 13:04 UTC (Sun) by Cyberax (✭ supporter ✭, #52523) [Link]

> Rubbish. I have books from the 90s on C++ that fail to mention smart pointers anywhere, written by C++ committee members.
[citation needed]

> Could good C++ programmers have created their own smart pointers in the 80s? I guess so. My strong impression though is that C++ programmers would have been *way* ahead of the state of understood wisdom in the C++ world at that time. My impression
Well, you'd be wrong. The need for RAII-d resources was understood quite early in the game. I'm not sure about 80-s - there was no significant amount of C++ code then, but surely during the early 90-s.

http://www.stroustrup.com/bs_faq2.html#finally

>If they're so trivial, so widely understood for so long, why did it take 20+ years to standardise some? Why is an only relatively recently standardised form of smart pointer already being deprecated in the next C++ standard? (auto_ptr for unique_ptr).
Mostly for historical reasons. The first C++ Standard was developed in great haste (by ISO standards), there simply was not time to test the proposed things in production. And then it was too late so major additions had to wait until C++11. The same story happened with hash maps, btw.

However, Boost and other libraries had no shortage of various smart pointers.

No thanks.

Posted Nov 11, 2012 14:56 UTC (Sun) by paulj (subscriber, #341) [Link]

Herbert Schildt, "C++ Nuts & Bolts for Experienced Programmers", Osborne McGraw-Hill, 1995. (Yes, Schildt has gotten flack for technical errors / flaws on C++ in his books, and yes, this book wasn't intended to be a reference).

When was Boost created? late 90s. Before Boost there was the HP and SGI STL, which I gather inspired the standardised STL (and Boost?), and iostream. That work dates from the early 90s AFAICT. The SGI STL page doesn't seem to have any kind of smart pointer, dated 1994. C++98 has the auto_ptr, but it apparently is flawed. The early Boost pages reference this: http://web.archive.org/web/19991222182604/http://www.boos... which references books discussing smart pointer programming *patterns* from '92, '94.

I know this stuff is all trivial to you, but it does seem to me that it took about 10 to 15 years (80s to mid/late 90s) for leading C++ programmers to agree on patterns for dealing with exception safety, such as RAII, then getting some kind of smart pointer support in the language (standard or generally available libraries) in order to cope with remaining pitfalls in C++ RAII+exceptions. That smart pointer support then needed further refinement in the mid/late 90s and early 2000s to get to where we are today.

That doesn't quite suggest to me that this stuff is quite as trivial as you suggest to is. Finally, even with smart pointers, I still don't find exception handling code that uses them to be non-trivial! However, you do seem be a superior breed of programmer to the rest of us, so perhaps that's the reason for the discrepancy in views ;). (Intended as a gentle jibe, I hope you'll accept it in that spirit).

No thanks.

Posted Nov 12, 2012 2:05 UTC (Mon) by Cyberax (✭ supporter ✭, #52523) [Link]

>Herbert Schildt, "C++ Nuts & Bolts for Experienced Programmers", Osborne McGraw-Hill, 1995. (Yes, Schildt has gotten flack for technical errors / flaws on C++ in his books, and yes, this book wasn't intended to be a reference).
He's not a member of C++ committee.

>When was Boost created? late 90s. Before Boost there was the HP and SGI STL, which I gather inspired the standardised STL (and Boost?), and iostream.
The STL specification was written before there was a single more-or-less complete STL implementation (and it shows). That was also a problem with lots of C++ features (like exception specification or template export).

Exceptions appeared in GCC 2.7 in 1997, I think. Before that there was little reason to use them and to create best practices for them. Though the usefulness of RAII was understood earlier.

In Java exceptions with try..finally also appeared at about the same time. But without RAII.

No thanks.

Posted Nov 12, 2012 14:35 UTC (Mon) by paulj (subscriber, #341) [Link]

Well, Schildt's wikipedia page says he was involved in C++ standardisation in the 90s. I don't know myself if that's correct or not.

As for exceptions, they were developed in the late 80s, standardised in the early 90s, and there were commercial compilers supporting exceptions since at least '92 apparently. See: http://www.stroustrup.com/hopl2.pdf. The release history of GCC possibly isn't that relevant, a number of proprietary implementations of C++ had more significant usage than g++ back then iirc.

Anyway..

No thanks.

Posted Nov 12, 2012 14:38 UTC (Mon) by paulj (subscriber, #341) [Link]

Oh, the '95 Schildt book has a section on exceptions.

No thanks.

Posted Nov 9, 2012 23:38 UTC (Fri) by nix (subscriber, #2304) [Link]

Consider how long it took after the introduction of exceptions into C++ to figure out how to write truly exception-safe code. It took *decades*. Doing it is not remotely obvious.

No thanks.

Posted Nov 10, 2012 3:25 UTC (Sat) by Cyberax (✭ supporter ✭, #52523) [Link]

Nope. The way to write exception-safe code has been clear from the start (modulo a few foulups in the Standard). That's why there's no "finally" keyword in C++.

The main problem was that exceptions were added quite lately in the game, and they were not reliable and/or generally available until at least early 2000-s. So we're stuck with huge amount of legacy non-exception-safe code.

But that's a poor excuse for creating a new language without exception support.

No thanks.

Posted Nov 10, 2012 16:06 UTC (Sat) by nix (subscriber, #2304) [Link]

Well it's curious the way I have multiple whole books which have about a third of their total page count discussing how to write exception-safe code in the presence of copy constructors, assignment operators, operator() and other such things which throw exceptions (throw in the possible elision of temporaries if you want to make it really fun).

Perhaps I was hallucinating and e.g. Herb Sutter's writings on the subject do not in fact exist, and it was 'clear from the start'. That would explain it, but I don't think that's so.

No thanks.

Posted Nov 10, 2012 21:49 UTC (Sat) by Cyberax (✭ supporter ✭, #52523) [Link]

And the whole books should have been written on writing safe C code in presence of errors.

A simple question - how do you deal with errors in the ubiquitous "goto error_exit" pattern in C?

No thanks.

Posted Nov 10, 2012 23:08 UTC (Sat) by nix (subscriber, #2304) [Link]

I actually solved this once with a really ugly exception-unwinder (implemented mostly in macros with one fugly bit of arch-dependent code). A few years later I had to port it to a new platform and wished I'd done something else.

(btw, I wish you'd be less bloody combative all the time. You turn every discussion on LWN into a minor war.)

No thanks.

Posted Nov 11, 2012 0:45 UTC (Sun) by hummassa (subscriber, #307) [Link]

Kettle, meet pot. :-D
But j/k, I love your discussions. From both of you. I learn a lot.

No thanks.

Posted Nov 11, 2012 5:12 UTC (Sun) by Cyberax (✭ supporter ✭, #52523) [Link]

>I actually solved this once with a really ugly exception-unwinder (implemented mostly in macros with one fugly bit of arch-dependent code).
Yup. Each sufficiently complex error handling system is indistinguishable from exceptions.

> (btw, I wish you'd be less bloody combative all the time. You turn every discussion on LWN into a minor war.)
Well, it's clear for me that there are only two kinds of opinions: mine and incorrect. I don't understand why other people still disagree.

No thanks.

Posted Nov 11, 2012 9:54 UTC (Sun) by paulj (subscriber, #341) [Link]

You can structure your code (in C, C++, Java, etc) so that you only have to check for errors at object creation, and thereafter only where it is convenient - i.e. you can do as many operations on the objects as you want without having to check for erros, without any use of control-flow branch points exploding exceptions:
do {
  var f = foo_new ();
  var b = bar_new ();

  if (!f || !b)
    break;

  f.twiddle ();
  b.jiggle ();
  
  <do as many more operations as you want on f and b,
   without need for checking for errors>

  if (f.state == ERROR || b.state == ERROR)
    break;

  <do whatever updates to this objects internal state,
   and update its .state appropriately>
  return;
} while (0);

if (f)
  foo_delete (f);
if (b)
  bar_delete (b);

<set this object to its error state>

return;
You do this by having the objects keep a finite state machine internally, with an idempotent error state. You could do more sophisticated error recovery by also tracking the prior state, that transited into the error state and potentially other more detailed info, e.g. with:
if (b.state == ERROR) {
  switch (b.prev_state) {
     ...
  }
}
Most of the same benefit of exceptions - of being able to move error handling out of the primary flow of code - but without the control-flow explosion (no need for goto either).

No thanks.

Posted Nov 11, 2012 10:03 UTC (Sun) by Cyberax (✭ supporter ✭, #52523) [Link]

So you now have to prefix ALL methods of f's class with "if (error) return error;". Nice.

And of course, you can forget about doing "b.twiddle(f.jiggle())".

And it'll be especially vexing in code that might be reused in several parts of a project. Additionally, your deleters (foo_delete, bar_delete) might in turn cause errors, how are you going to process them?

It's amazing to what lengths people would go just to avoid using exceptions. Why, they'd even re-invent exceptions without all their nice properties and with all the bad ones.

No thanks.

Posted Nov 11, 2012 11:01 UTC (Sun) by paulj (subscriber, #341) [Link]

Whether you do or don't use exceptions, it's far from a bad idea for objects to always check their internal consistency on entry from external callers. As for dealing with errors in clean up, remind me again how exceptions improves on that? Would you throw an error from a destructor?

Also, you seem to be suffering from some kind of binary thinking - that people are either for or against something - and projecting that onto others. I have not at any stage expressed an opinion on whether exceptions should be avoided or not.

No thanks.

Posted Nov 11, 2012 11:20 UTC (Sun) by Cyberax (✭ supporter ✭, #52523) [Link]

>Whether you do or don't use exceptions, it's far from a bad idea for objects to always check their internal consistency on entry from external callers.
That's a bad idea because of a several reasons. All reliable systems should be built on the idea of invariants and contracts. The violation of the contract/invariant should be treated as a fatal error.

So putting "assert(someInvariantState==43)" in method's body is fine as a purely debugging tool to find programmer's error. However, doing "if (someInvariantState!=42) return -ERR;" is a big NO-NO.

>As for dealing with errors in clean up, remind me again how exceptions improves on that? Would you throw an error from a destructor?
C++ doesn't have a nice solution for that. Java has one in the form of nested exceptions - it's possible to replace the current exception with the new one, retaining the current one as a nested exception.

No thanks.

Posted Nov 11, 2012 15:29 UTC (Sun) by paulj (subscriber, #341) [Link]

From my perspective, programming network services, where inputs may come from bad actors, and where the last you want to do is to allow a bad actor to cause your system to deny service to the good actors, I flatly disagree that violation of contracts should result in fatal errors - termination of that service to that actor, in a clean way, yes, fatal end of programme and all service: absolutely the wrong goal. (Invariants should be fatal, but that's a different thing).

And if you think I've been arguing that errors should be returned and caught and handled at each method call you've simply not read my comments, and you're just arguing with a figment of your own imagination. Good luck with that :).

No thanks.

Posted Nov 11, 2012 15:57 UTC (Sun) by raven667 (subscriber, #5198) [Link]

Fatal termination of the program might be the only safe bet if the internal state is compromised by a bad actor, I would be distrustful of claims to "cleanly" recover or try to "handle" errors that they actually can't handle. That's why long-running processes should be run under high availability supervision like daemontools or systemd.

I'm no expert on implementation details but the idea of Exceptions seems right to me, errors can't be ignored, they have to be handled or the program dies, which seems better to me than having your program jump the track and keep stupidly barreling along mowing through your data, driving through your living room window 8-)

No thanks.

Posted Nov 11, 2012 16:19 UTC (Sun) by paulj (subscriber, #341) [Link]

If the internal state is compromised yes. However, you want to reject the bad actor's input before that happens. Parsing things with state machines and related automata, and cleanly rejecting invalid input (and dispensing with associated state) is not rocket science. (Note that method calls related to some piece of state can be viewed as inputs/transitions on an automaton).

Asserting and crashing should be a last resort in daemons that must provide shared-state services to multiple actors. While it is preferable to assert than to allow a security critical error, asserting itself may be a security critical error - handling errors cleanly is again preferable to the assert. A better approach is to have multiple layers of defence, with asserts against critical inconsistency errors at lower layers (e.g. forcing all IO through checked, bounded buffer abstractions), and well-defined automata at higher layers to provide clean error semantics (potentially multiple levels of such). You can't just restart, because of the shared-state. If you externalise the shared-state so that the code can be restarted, you still need to ensure that shared-state can never be manipulated into an inconsistent state.

All the world is a state machine, even the functional programming world. ;)

No thanks.

Posted Nov 11, 2012 10:39 UTC (Sun) by Cyberax (✭ supporter ✭, #52523) [Link]

Oh, and if "f.twiddle ();" returns with an error and "b.jiggle ();" depends on some side effects of "f.twiddle()" that hasn't happened then you get a very nice "wish you happy debugging!" moment.

No thanks.

Posted Nov 11, 2012 10:55 UTC (Sun) by hummassa (subscriber, #307) [Link]

And more -- good look synchronizing the FSMs for 42 instances of each of 42 different types of objects (think a *simple* payroll application). THAT is full of happy debugging moments.

No thanks.

Posted Nov 11, 2012 12:36 UTC (Sun) by paulj (subscriber, #341) [Link]

Pretty much all non-trivial objects (composites, or ones with implicit constraints on fields that can't be expressed in the type system or language) have an FSM, at a minimum the 2-state FSM of "Internal state is consistent" and "Internal state is not consistent". You have to deal with that reality one way or another. Tracking that consistency internally through an explicit FSM is one way. Dealing with invalid use of that object after errors through an idempotent error state or assertions or exceptions all have their pros and cons.

You don't have to synchronise all the FSMs. Or at least, if you do, then it wasn't because you added an explicit FSM - you had to effectively be synchronising their state already anyway. All it does is crystalise and making explicit (inc making it queryable to outside users) requirements that are already there.

No thanks.

Posted Nov 11, 2012 13:06 UTC (Sun) by Cyberax (✭ supporter ✭, #52523) [Link]

That's about THE WORST possible system to write software. It combines everything:
1) Hidden state, affecting execution silently.
2) Completely decoupling the error site and the place where error is detected/handled.
3) Possible unforseen interactions through side-effects.
4) Mutable objects.
5) Non-thread safety by design.

No thanks.

Posted Nov 11, 2012 15:07 UTC (Sun) by paulj (subscriber, #341) [Link]

1. Many state+code objects in software have hidden state - it's called encapsulation.

2. Decoupling error handling from the error site (in terms of the programming language syntax) is exactly what exceptions do!

3. You could level this argument at pretty much any OOP code, you'd have to be writing pure functional code to avoid this charge.

4. Ditto.

5. Thread safety is completely orthogonal. Making it thread-safe is no different to making other stateful objects thread safe.

You're just throwing accusations blindly in the hope some stick, methinks. :)

No thanks.

Posted Nov 12, 2012 1:52 UTC (Mon) by Cyberax (✭ supporter ✭, #52523) [Link]

>1. Many state+code objects in software have hidden state - it's called encapsulation.

Normal designers try to MINIMIZE it. You are not only add it gratuitously, but also introduce non-trivial interdependencies between objects.

For instance:
>f.twiddle();
>j.jiggle();

What if j.jiggle() takes 10 minutes to complete? Then your code would just be losing time if "f.twiddle()" is in error.

>2. Decoupling error handling from the error site (in terms of the programming language syntax) is exactly what exceptions do!

Not error handling, but error _detection_. You can simply forget to check that f's state is OK after the loop. Then there's a problem with compounded errors.

> 3. You could level this argument at pretty much any OOP code, you'd have to be writing pure functional code to avoid this charge.

Nope. Good modern OOP code tries to minimize mutability (it's OK to use mutable objects where it's necessary) - a lot of new OOP languages even have variables that are immutable by default, for example.

> 5. Thread safety is completely orthogonal. Making it thread-safe is no different to making other stateful objects thread safe.

No. For instance "f" object might be immutable except for its "error" state.

BTW, I think that there should definitely be a death penalty for those who abuse do..while loops to emulate "goto".

No thanks.

Posted Nov 12, 2012 10:05 UTC (Mon) by paulj (subscriber, #341) [Link]

No dependencies have been added between objects.

In extreme cases, such as j.jiggle () taking 10 minutes, then you might want to check before it. I gave a sketch of a programming pattern - it wasn't intended to be an exact solution for every possible programming problem. If you use it, you will still need to apply some intelligence of your own.

Note further, I was not even claiming that this is *THE* pattern to solve all error-handling. I was just giving it as an example, for consideration, as you earlier had asked for examples of error handling without exceptions (well, you asked for a goto error-exit pattern example, but I assumed other examples would also be allowed).

Object mutability: If an object is immutable, then its state doesn't change and will be immutable. Clearly there is little point in applying state-tracking patterns to single-state objects. This pattern applies to objects with a finite multiplicity of states. Despite your contention, I am fairly sure programming is full of such objects.

Even if you use a series of immutable objects and transition between them, you will still have an FSM with mutable state at a level above those immutable objects, implicitly or explicitly.

No thanks.

Posted Nov 11, 2012 12:27 UTC (Sun) by paulj (subscriber, #341) [Link]

You have to query the state of the objects FSM before using any of its other state in this pattern, yes. For other querying methods, returning state other than the FSM state, you can make that a terminal exception (in the "assert()" sense) if such other state is queried for when the object is reached its error state, or you could throw an exception.


Copyright © 2017, Eklektix, Inc.
Comments and public postings are copyrighted by their creators.
Linux is a registered trademark of Linus Torvalds