News for hackers. Stuff that matters.
Re:Errors – Gotta Catch 'Em All by rcfox on Thursday April 04, 2019 @10:35AM (#19572766)
Say you have library that takes a filename and returns the contents after some kind of decoding. If the file is inaccessible (doesn't exist, in use, user doesn't have permission), you don't want the library to take any real action on that. It shouldn't display a message, attempt to correct the filename or retry the same file. It should just let the caller know that an error occurred, and ideally what that error was.

Okay, so we'll return early with an error code and probably some kind of nil result. (Because we're not using a system that's so archaic that it can only return one value!)

But the caller of the library was some middleware that also can't be expected to handle the error usefully. It returns the same error and result to its own caller. And let's say there are a few layers like this until we finally get to the top layer where we can translate that error code into a big, red message for the user saying "file not found".

Now how is that any different from raising an exception? (Other than the extra 'if error: return error, result' lines you need.)

Re:Errors – Gotta Catch 'Em All by kaoD on Thursday April 04, 2019 @11:08AM (#19573182)
> Now how is that any different from raising an exception?

Exception bubbling is implicit.

There's no way to know which exceptions can be thrown from a function just by looking at its code, nor looking at the called-functions code. You have to keep in your head all the call chain up to the first function that does not call any other function (good luck with that).

Even worse: we don't even know _where_ the function can stop running and start unwinding. This leads to defensive programming. Hello try-catch soup!

It's a slippery slope that gets worse and worse with each abstraction layer.

Languages with typed errors have been nothing but a joy for me.

Re:Errors – Gotta Catch 'Em All by wvenable on Thursday April 04, 2019 @11:46AM (#19573676)
> There's no way to know which exceptions can be thrown from a function just by looking at its code, nor looking at the called-functions code.

It's good you don't actually need to know that! And if you did, it wouldn't matter anyway because somebody could come along in the future and change that code that currently uses a database and change it a web service and all that knowledge would be wasted.

All you need to know is what exceptions you can handle and where you handle them. What error codes or exceptions each individual function everywhere up the call chain can raise is almost inconsequential.

Re:Errors – Gotta Catch 'Em All by kaoD on Thursday April 04, 2019 @11:57AM (#19573829)
> All you need to know is what exceptions you can handle

Ah, so that's "all" I need to know!

And that's what typed errors do.

Re:Errors – Gotta Catch 'Em All by wvenable on Thursday April 04, 2019 @12:26PM (#19574177)
You might only be able to handle restartable network exceptions. In my case, that might be a single base type. So I put a try block in where I can handle that exception (where my network code starts) and I'm done.

Do I need to check the return type of the thousands of methods that might make up that operation? Nope. Typed errors make me do a lot of work passing stuff around and declaring types that literally don't matter. If somebody adds a new method that does another network call, I'm still good and I didn't have to do anything.

Re:Errors – Gotta Catch 'Em All by kaoD on Thursday April 04, 2019 @12:33PM (#19574242)
You like implicit. I don't.

I don't think we can discuss deeper than that.

Re:Errors – Gotta Catch 'Em All by wvenable on Thursday April 04, 2019 @12:38PM (#19574301)
Actually, for the most part I don't like implicit. But I also like encapsulation and polymorphism and you can't have those things if you are exposing implementation details all over the place.

The other thing I don't like is pointless boilerplate code.

But I do like strongly-typed languages and originally I thought I'd like checked exceptions before realizing just how wrong that concept is. It's not hard to see the parallels between checked exceptions and error returns.

Re:Errors – Gotta Catch 'Em All by shawnz on Thursday April 04, 2019 @11:59AM (#19573850)
If you want strongly typed errors then you could use a language with checked exceptions (Java). What you are describing is not a complaint about exceptions, it's a complaint about weakly typed errors. You can have the same problem even if you don't use exceptions -- e.g. what happens if one of your inner-inner-inner functions returns null when the docs say it shouldn't? You will just end up with if-null soup instead of try-catch soup if the language doesn't support exceptions.
Re:Errors – Gotta Catch 'Em All by kaoD on Thursday April 04, 2019 @12:01PM (#19573888)
> what happens if one of your inner-inner-inner functions returns null when the docs say it shouldn't?

My choice of language wouldn't have the concept of "null".

If it somehow returns an Option type... well, the docs would say it, and it won't typecheck unless I handle it.

> If you want strongly typed errors then you could use a language with checked exceptions (Java).

Yes, typed error handling looks an awful lot like Java's checked exceptions.

Buuuuut exceptions magically unwind the stack at unknown points. I don't like my stacks unwinded unless I explicitly tell them to. Function exit points should be explicit.

Also: it has unchecked exceptions too, runtime exceptions (null pointers, anyone?) and lacks the expressiveness to handle error propagation while not being a pain in the ass.

Re:Errors – Gotta Catch 'Em All by shawnz on Thursday April 04, 2019 @12:08PM (#19573967)
I actually think checked exceptions make handling error propagation much easier than Option types. In a language with checked exceptions, if you want to propagate the error, all you have to do is declare that intent. With Option types, there is a need for boilerplate unwrapping code in almost every place where you want to use the value.
Re:Errors – Gotta Catch 'Em All by kaoD on Thursday April 04, 2019 @12:10PM (#19573985)
> With Option types, there is a need for boilerplate unwrapping code in almost every place where you want to use the value.

Disagree, in my favorite language you just add "?" to the possibly-erroring function et voilá, error propagated. Even better, since errors are functor-like (map) and monad-like (and_then), I'm mostly never unwrapping myself.

This has the advantage that it's explicit, instead of exceptions implicitly returning early (sometimes to great amusement).

Re:Errors – Gotta Catch 'Em All by Faark on Friday April 05, 2019 @02:30PM (#19585617)
> Disagree, in my favorite language you just add "?" to the possibly-erroring function et voilá, error propagated

And one of the first things I had to learn in rust was how make this happen with different error types. After that it was pretty much the same as exceptions. What functions return errors is a little more obvious, at the cost of extra boiler plate (most stuff being Result<...> anyway)

Checked exceptions Java style could be a perfect balance with just a few modifications. Compiler/IDE should mostly know whats thrown where, so specifying it manually should rarely be necessary. And still could visualize what can fail and with what errors.

Re:Errors – Gotta Catch 'Em All by rcfox on Thursday April 04, 2019 @11:31AM (#19573484)
> There's no way to know which exceptions can be thrown from a function just by looking at its code, nor looking at the called-functions code.

But is this different from error codes? Does seeing a file open tell you every error that might occur from that?

If you're arguing that you could just look at the file-open code to see the errors it returns, couldn't the same apply for seeing which exceptions are thrown?

Re:Errors – Gotta Catch 'Em All by kaoD on Thursday April 04, 2019 @11:36AM (#19573557)
> If you're arguing that you could just look at the file-open code to see the errors it returns, couldn't the same apply for seeing which exceptions are thrown?

No, because then you have to look at every function inside there. And there every function inside those functions. And then...

With typed error handling they're only one-level of abstraction deep. Actually zero-levels, since your function won't typecheck unless you handle the errors.

Re:Errors – Gotta Catch 'Em All by wvenable on Thursday April 04, 2019 @11:48AM (#19573704)
So if you have a potential call chain of dozens of methods, your error return includes every single possibility? That's pretty doubtful. What happens is the same thing that happens with checked exceptions; the errors are massaged or placed untyped in properties and while you're handling all the errors you're doing it in a sloppier way.
Re:Errors – Gotta Catch 'Em All by kaoD on Thursday April 04, 2019 @11:55AM (#19573788)
> So if you have a potential call chain of dozens of methods, your error return includes every single possibility?

Mostly yes, usually as a sum type.

Pattern matching is your friend.

> the errors are massaged

Why would I take the extra effort?

Unless it's my responsibility to handle it (i.e. it's part of the function's logic) I will just return it untouched and let the consumer decide what to do (if anything at all).

> or placed untyped

That's not possible (at least in the typed languages I tried).

Re:Errors – Gotta Catch 'Em All by wvenable on Thursday April 04, 2019 @12:24PM (#19574151)
Java has checked exceptions (which honestly is more like error-return) and the innerException property is used extensively to hold the "real" exception and, of course, it's type is just "Exception".

Making the real error types part of the signature of the method means that implementation changes require changing the signature, completely breaking encapsulation. In fact, I'd argue it makes polymorphism completely impossible.

Re:Errors – Gotta Catch 'Em All by kaoD on Thursday April 04, 2019 @12:39PM (#19574305)
> Java has checked exceptions (which honestly is more like error-return) and the innerException property is used extensively to hold the "real" exception and, of course, it's type is just "Exception".

Yeah, well, Java's semantics and programer laziness make a mess. News at 11.

> I'd argue it makes polymorphism completely impossible.

Oh, so two birds with one stone!

Re:Errors – Gotta Catch 'Em All by wvenable on Thursday April 04, 2019 @12:45PM (#19574393)
It's like it's 1992 all over again. Every change requires changing every caller everywhere. Yes, it's an improvement now that the typechecker will tell us all the places we need to change but it still doesn't sound enjoyable or useful.
Re:Errors – Gotta Catch 'Em All by kaoD on Thursday April 04, 2019 @01:34PM (#19574960)
> Every change requires changing every caller everywhere

I don't see why.

Re:Errors – Gotta Catch 'Em All by wvenable on Thursday April 04, 2019 @01:38PM (#19575005)
Non-trivial changes to functions typically change what errors they will trigger. Thus changing what errors their callers will trigger. And so on.

Putting error conditions in the function signature means that the signature reflects the implementation details of the function. Change those implementation details and the signature changes, affecting the callers and their signatures. Unless you abstract the error and then you lose the only advantage of passing the errors around rather than using exceptions.

Re:Errors – Gotta Catch 'Em All by kaoD on Thursday April 04, 2019 @01:49PM (#19575114)
I still don't see why.

https://play.rust-lang.org/?version=stable&mode=debug&editio...

Let's add a new error condition:

https://play.rust-lang.org/?version=stable&mode=debug&editio...

Only the function raising the error, and the consumer, had to change (and the consumer only changed because it _cared_ about the error type!)

If you want an example with nested errors I can do it, you'll see it's mostly the same.

Re:Errors – Gotta Catch 'Em All by wvenable on Thursday April 04, 2019 @01:55PM (#19575190)
If you had an external compiled library the consumed MyError or called caller, you just broke it, becuase you changed the type.

This isn't a realistic example at all because your MyError is simple enum that you changed to make it work. If you add another error, or have more than one level, or call it multiple locations, and don't eat the error then now you're changing many more functions, just as I said.

Re:Errors – Gotta Catch 'Em All by kaoD on Thursday April 04, 2019 @02:01PM (#19575254)
> This isn't a realistic example at all because your MyError is simple enum that you changed to make it work.

Well, that's what an error is. A simple enum of the error cases and maybe some metadata.

EDIT: e.g. IO errors in Rust's std: https://doc.rust-lang.org/src/std/io/error.rs.html#91-174

If your first guess is this isn't realistic because it's "too simple" then maybe you've never been exposed to this kind of error handling? It's so simple it's unbelievable?

> If you add another error

That's what I did, I added a new error.

> or have more than one level and don't eat the error now you're changing more methods, just as I said.

As I said, if you want an example with nested error types I can do it:

https://play.rust-lang.org/?version=stable&mode=debug&editio...

As you can see, caller() (which would be our "middleman" here, the one that neither produces nor uses the error) didn't change at all.

> If you had an external compiled library the consumed MyError or called caller, you just broke it, becuase you changed the type.

You mean a dynamically-linked library? Yep, completely broken, but that's not the only problem with DLLs. Static linking is fine.

Anyways, the contract changed, so it's a breaking change, so that's good in my book. The contract changed in the case of exceptions too, you just hand-waved over the issue and called it a day.

Wouldn't it be the same with exceptions across library boundaries?

Re:Errors – Gotta Catch 'Em All by wvenable on Thursday April 04, 2019 @02:47PM (#19575755)
> If your first guess is this isn't realistic because it's "too simple" then maybe you've never been exposed to this kind of error handling?

I explained why the example is too simple. If you coded this in C with an integer error code the code would also be roughly the same size.

> Wouldn't it be the same with exceptions across library boundaries?

Actually no. That's the significant difference.

I can freely change the implementation and if that causes new and different exceptions to be possible, that doesn't affect the implementors. And most of the time such a change makes will make material affect on the implementors so they are broken for nothing.

Re:Errors – Gotta Catch 'Em All by kaoD on Thursday April 04, 2019 @03:13PM (#19576032)
> I explained why the example is too simple.

And I offered a second example with a nested error, and nothing changed. Errors are just enums, there's nothing more complex than this. It's that simple.

> If you coded this in C with an integer error code the code would also be roughly the same size.

But it wouldn't check the error types. It's a zero-cost abstraction.

> I can freely change the implementation and if that causes new and different exceptions to be possible, that doesn't affect the implementors.

Neither does in my case... unless I care about the actual errors, which I did in this case in main() just for completeness.

Re:Errors – Gotta Catch 'Em All by wvenable on Thursday April 04, 2019 @03:57PM (#19576470)
Honestly, that second example is more complex. Now you're had to manually map one error onto another in order to propagate it. How big does MyError get when you have OtherError, AnotherError, FailureNum5, ChokedOnBanana. You're just doing busy work creating types and mapping them together. And this is just a simple toy example! You're quick to hand-wave that wasted effort.

What value is the enum value Other(OtherError) actually provide other than to satisfy the compiler? How far do we take this when there are more levels? OtherFailure(OtherMistake(Other(OtherError)))?

> Neither does in my case...

In each example you changed the implementation of type so that it is no longer compatible. You altered the signature of the method.

> But it wouldn't check the error types. It's a zero-cost abstraction.

It's funny that you say that as error returns have a non-zero runtime cost. Yet exceptions can actually be zero-cost at runtime (if they aren't thrown) as they can be implemented out of band. Only the most naive implementation propagates exceptions with multi-value returns.

Now I do understand why Rust is implemented this way but it's not because error returns are unequivocally better.

Good code with exceptions have very little code actually related to error handling. Throw often, catch infrequently, and use normal resource cleanup for exceptional cleanup as well. You can get far with a 2-3 well placed catch statements and that's it. No extra typing. No error propagation code.

If you think of error handling as happening where the error is raised as opposed to where it is handled it's hard to see the advantage of exceptions. Where the error is raised is not that important.

Re:Errors – Gotta Catch 'Em All by kaoD on Thursday April 04, 2019 @04:55PM (#19577006)
I see your point and I will consider it. Thanks for the discussion.

What's a language that does exceptions just right for you?

Re:Errors – Gotta Catch 'Em All by wvenable on Thursday April 04, 2019 @05:06PM (#19577110)
C#/C++ do exceptions fine. However, it's more useful to point out the language that does exceptions all wrong: Java. I feel like the current anti-exception sentiment is mostly due to programmers first or major experience with exceptions is checked exceptions in Java.

If I had to choose between checked exceptions and well typed error propagation, I'd choose the latter hands down. Checked exceptions have all the disadvantages of error returns and none of the advantages.

This meshes with my point about where the error concerns are; Java requires you to be very concerned about what errors are thrown at every method definition and call. But C#, which is a very similar language, doesn't. In C#, you only have to be concerned about where and what errors you can handle.

Re:Errors – Gotta Catch 'Em All by wyldfire on Thursday April 04, 2019 @10:57AM (#19573058)
> Now how is that any different from raising an exception? (Other than the extra 'if error: return error, result' lines you need.)

I think exceptions can be used well in some contexts but I will completely concede the point that they're super complicated.

"How is that any different?" Well -- we unwound the stack automagically and that's not trivial. Every intervening piece of code should know that a call they make could transitively make lots of interesting calls and they might cause this function we're writing to exit early.