News for hackers. Stuff that matters.
Re:Isaacs: try/catch is an anti-pattern by dchest on Monday November 14, 2011 @06:17AM (#3233614)
This seems to be exactly the attitude of Go:

"We believe that coupling exceptions to a control structure, as in the try-catch-finally idiom, results in convoluted code. It also tends to encourage programmers to label too many ordinary errors, such as failing to open a file, as exceptional.

Go takes a different approach. For plain error handling, Go's multi-value returns make it easy to report an error without overloading the return value. A canonical error type, coupled with Go's other features, makes error handling pleasant but quite different from that in other languages.

Go also has a couple of built-in functions to signal and recover from truly exceptional conditions. The recovery mechanism is executed only as part of a function's state being torn down after an error, which is sufficient to handle catastrophe but requires no extra control structures and, when used well, can result in clean error-handling code."

http://golang.org/doc/go_faq.html#exceptions

In Go, if there's a programmer error, call panic(); if there's a non-programmer error, return it as a second return value.

[Added] Plus, it's obvious to see where people ignore errors:

   f, _ := os.Open("filename")
"_" is a throw-away variable to indicate that this value won't be used in the code. It's obvious that the programmer decided to ignore the error.

   f, err := os.Open("filename")
If you don't use "err" later, this won't compile.

   f, err := os.Open("filename")
   if err != nil {
      // handle error
   }
This code handles error.
Re:Isaacs: try/catch is an anti-pattern by PaulHoule on Monday November 14, 2011 @08:05AM (#3233799)
This is a bad idea that keeps coming back again and again.

I see nothing wrong with exceptions, I do have a problem with (1) checked exceptions, and (2) catching exceptions prematurely and (3) people not learning how to use "finally" so they do (2) and rethrow.

Languages like Go and Scala roll out various mechanisms that bring us back to the bad old days of C, when we had to check the return/value and or the error code after every function call... if we wanted error handling to work.

The trouble with this approach is that it increases code bulk. For CS class projects, this isn't so bad, but when you're building real systems, the complexity of the error handling can approach or exceed the complexity of the "normal" path and when that happens you're in deep trouble.

Exceptions drastically reduce code bulk by introducing default "abort" behavior, which can itself be aborted at any level of the program and which can invoke cleanup anywhere in between.

Many programmers in many situations would be perfectly happy to catch "failure to open a file" and "failure to open a database connection" and "failure to connect to a network host" with one simple handler that logs the failure and either aborts, retries or ignores.

Re:Isaacs: try/catch is an anti-pattern by scott_s on Monday November 14, 2011 @10:55AM (#3234424)
when you're building real systems, the complexity of the error handling can approach or exceed the complexity of the "normal" path and when that happens you're in deep trouble.

Go is a systems programming language, and a large part of systems programming is dealing with the potential errors. Take a look at, say, how the Linux kernel implements a system call. In fact, this is do_mmap_pgoff(), which does the bulk of the work for a mmap() system call in Linux: http://lxr.linux.no/linux+v3.1.1/mm/mmap.c#L942

It's almost nothing but error checking, and I submit that is as intended. In this circumstance, you want all of the error checking right in front of you, because that error checking is enforcing very important kernel policy. A lot of kernel code is error checking, because it has a lot of policy to enforce.

You're right that this error checking paradigm is a throwback to C, but Go was designed as a better C. Go's means of handling errors is exactly what I wish I could do in C; it allows every function to both return a value and an error code. It avoids passing in pointer to values because the function returns an error code, or having to check a global errno because the function returns a meaningful value. It's kinda like living in a world where C++, Java and Objective-C were never invented. (I like and use C++, so please don't take that as jumping on the C++-is-the-worst-thing-ever bandwagon.) I find that a very interesting direction, one which should be explored.

I use exceptions for higher-level code. When writing, say, a parser, I'd rather throw and catch exceptions. I don't think we need to choose one error-catching paradigm and declare it's best for all levels of code.

Re:Isaacs: try/catch is an anti-pattern by dchest on Monday November 14, 2011 @11:34AM (#3234570)
When writing, say, a parser, I'd rather throw and catch exceptions.

Which is also possible in Go, and template parser from its standard library is, actually, written in this style:

http://golang.org/src/pkg/template/parse/parse.go#L96

Functions call panic() (via t.errorf) to avoid passing errors between multiple levels of functions, but then Parse method catches it with recover(), checks what kind of error it is, and either panics again if it's a runtime error, or returns other kinds of errors.

Re:Isaacs: try/catch is an anti-pattern by gizmo on Monday November 14, 2011 @08:27AM (#3233842)
> when we had to check the return/value and or the error code after every function call... if we wanted error handling to work.

Errors as return values force you to think about every possible error, which is a good thing for code quality. Look at how much rock stable C software we have out there. Software that can be compiled on many different architectures, run in many different environments, and it all just works, even 20 years later.

Writing code with try/catch is much less work. Not because you have to do less typing, but because you simply think less about how errors should be handled.

Re:Isaacs: try/catch is an anti-pattern by eftpotrm on Monday November 14, 2011 @09:06AM (#3233953)
And you know what? In my experience it's not less robust.

So my code hasn't had every possible failure case thought through and explicitly handled in advance. That's good. Firstly some of those errors are so rare they'll almost certainly never occur in my program's lifetime; by not having to handle them explicitly and individually I save time and money. Secondly I can guarantee that, no matter how good I think I am, the program will eventually find a way of crashing I'd not considered; this approach gives me a clean means of handling unforeseen errors as well.

A bad programmer can write bad code in any pattern and with any tools. A bad C programmer using return values can create so many different standards for how to handle errors that you might as well get out the divining rods to read the code. Personally, done right (as with anything) I happen to like try...catch.

Re:Isaacs: try/catch is an anti-pattern by dasil003 on Monday November 14, 2011 @12:16PM (#3234765)
Just because you think a certain error will never happen for the lifetime of a program doesn't mean that not explicitly handling it is equally robust.
Re:Isaacs: try/catch is an anti-pattern by eftpotrm on Monday November 14, 2011 @12:57PM (#3234923)
No, I agree, but there's a cost/benefit calculation to be done. Plus it's not like the try...catch solution that doesn't explicitly handle the error will blow up and destroy everything; if the program is properly designed it should merely degrade onto the path of general handling, log the failure and halt whatever was being done.
Re:Isaacs: try/catch is an anti-pattern by PaulHoule on Monday November 14, 2011 @09:18AM (#3233994)
In a modern programming environment you can't think about every possible error. In particular, code often migrates into distributed systems where a whole new range of problems can happen.

For instance, a system might have plug-ins that get data from a CSV file, a relational database and a web service. One day somebody comes along and adds a plug-in that gets data from a noSQL database.

Add a new component to the system and you introduce not only new failure modes but new ways failure impacts the "system a s a whole."

The more decisions you make, the more you will make wrong decisions. Exceptions provide a reasonable default behavior that is "decision free" and reasonable ways to upgrade it.

20 year old C software lived in a simpler world; only specialized network utilities like telnet and tcpwrappers would have to face the consequences of a failing DNS lookup or the temporarily failure of a network switch in Toledo.

Re:Isaacs: try/catch is an anti-pattern by sparky on Monday November 14, 2011 @07:34PM (#3236369)
It is a more complex world, but I think that's orthogonal to whether you prefer return codes or exceptions.

In fact, I think you can argue that keeping error-handling local to the call site (return codes) encapsulates and abstracts the errors better than letting an exception propagate arbitrarily far up the stack.

Exceptions are decision-free, but not making a decision (propagating an exception without handling it) doesn't make you any more robust to the vagaries of the modern world, it just moves the problem somewhere else.

Now, if multiple children in a call graph can experience the same error, and should be dealt with in exactly the same way, then propagating an exception up to a common ancestor in the call graph makes your code simpler. The fact that the compiler writes that dumb plumbing code for you is a great argument for exceptions, but not all applications fit the use case of:

  * Same error can manifest itself in many places
  * Each instance of the error can be dealt with in a similar-enough way to make a common exception handler simpler than handling errors at each call site.
Edit: Oh, did you mean that if you don't intend to handle an error, exceptions crash your program (good) rather than let it continue silently and do something you don't expect (bad)? If so, good point, and my apologies for the misunderstanding :)
Re:Isaacs: try/catch is an anti-pattern by ufo on Monday November 14, 2011 @08:49AM (#3233897)
At least in languages like Haskell you can use things like Monads that allow you to write the high level code and do the error routing for you behind the scenes. In C manually writing the error handling is a painful and error prone process.
Re:Isaacs: try/catch is an anti-pattern by TylerE on Monday November 14, 2011 @09:09AM (#3233964)
> Look at how much rock stable C software we have out there.

Which would be what exactly. The work of Knuth and djb I'll grant you, but the rest?

Re:Isaacs: try/catch is an anti-pattern by william42 on Monday November 14, 2011 @06:04PM (#3236113)
Didn't Knuth write TeX in a variant of Pascal?
Re:Isaacs: try/catch is an anti-pattern by vog on Monday November 14, 2011 @12:07PM (#3234729)
*BSD kernels, GCC, tar, gzip, ...
Re:Isaacs: try/catch is an anti-pattern by TylerE on Monday November 14, 2011 @01:07PM (#3234978)
BSD kernels have had numerous exploits over the years. GCC is a massive hairball. gzip has had exploits (http://www.kb.cert.org/vuls/id/381508 for one).

Care to try again?

Re:Isaacs: try/catch is an anti-pattern by andrewflnr on Monday November 14, 2011 @08:36PM (#3236544)
Without defending any given piece of software, the job of the exception advocate is not to prove that return values suck, but that using exceptions produces more stable software as fast or faster. This question cannot be resolved by examples/anecdotes alone.
Re:Isaacs: try/catch is an anti-pattern by viraptor on Monday November 14, 2011 @10:50AM (#3234398)
I'm sorry, but this is a very bad example. iptables had an issue for a long time where error code is not carefully preserved in many situations and you end up with messages like:

    iptables: Unknown error 4294967295
This wouldn't happen with exceptions - even if not handled properly, you'd see where is it originating and what's the most probable cause of the issue. And it's not necessarily iptable's fault - in some cases you have to really bend some rules to get the error you want. Also you cannot stack them so if you fail to cleanup after the original error, what do you return? The first or the second error? One has to be ignored.
Re:Isaacs: try/catch is an anti-pattern by angelbob on Monday November 14, 2011 @03:36PM (#3235587)
Return the first one. You always care more about the original error than an explanation of why you failed in cleaning up after it.
Re:Isaacs: try/catch is an anti-pattern by viraptor on Monday November 14, 2011 @06:32PM (#3236185)
Counterexample: you failed parsing some number correctly, but the backend where you log broken transactions is corrupted and cannot be written to. You'd rather drop the second information?
Re:Isaacs: try/catch is an anti-pattern by angelbob on Monday November 14, 2011 @08:26PM (#3236507)
Ah, so you're saying that failing to parse the number breaks the transaction.

Fair enough, you'd rather (as a human being) have the second one. As a matter of building the system, I would still return the first one.

Basically, the second information is important in the sense that you really want an audit trail, but unimportant in that it doesn't tell you why your call failed. Returning it to the caller is useless compared to returning the first error.

But yes, it should certainly be logged and potentially acted on. An application can't do anything useful with the information, but an ops guy can.

So return the first one.

Re:Isaacs: try/catch is an anti-pattern by lemming on Monday November 14, 2011 @04:04PM (#3235687)
This is not my experience at all. Return codes are far too easy to ignore. I would argue that the fact that C software works after 20 years is because it's been debugged for 20 years, everything that can possibly happen to it has probably happened and been handled. It's not because error return codes are a fundamentally better way to do this.

I know it's kind of unhip right now, but I would argue that what you're asking for is better handled using checked exceptions. That really forces you to think about error conditions, and it's enforced by the language. I'm continuously baffled by the argument that this is a bad idea.

Re:Isaacs: try/catch is an anti-pattern by nosequel on Monday November 14, 2011 @08:44AM (#3233887)
How do you feel about Erlang's "let it fail" policy? I personally was afraid of it at first thinking you couldn't write stable code, but the result was quite the opposite. Things fail, and get started back up by supervisors and everything is happy. No error checking and code bulk, no try/catch nonsense littered all over the code.
Re:Isaacs: try/catch is an anti-pattern by jberryman on Monday November 14, 2011 @12:39PM (#3234852)
just curious: what are you using erlang for?
Re:Isaacs: try/catch is an anti-pattern by nosequel on Monday November 14, 2011 @01:16PM (#3235016)
Backend / Server software, build tools, general scripting (using escript).
Re:Isaacs: try/catch is an anti-pattern by eeperson on Monday November 14, 2011 @10:07AM (#3234221)
Languages like Go and Scala roll out various mechanisms that bring us back to the bad old days of C, when we had to check the return/value and or the error code after every function call... if we wanted error handling to work.

I cant speak for Go but Scala's Option type is very different from C error codes since it is a monad. As a result you can use it with Scala's 'for' comprehensions (which are roughly the same as Haskell's arrows) and write code that looks roughly imperative without having to explicitly handle any errors.

http://www.scala-lang.org/api/current/index.html#scala.Optio...

Re:Isaacs: try/catch is an anti-pattern by chollida1 on Monday November 14, 2011 @09:35AM (#3234078)
I think the point is that your specific cases:

> Many programmers in many situations would be perfectly happy to catch "failure to open a file" and "failure to open a database connection" and "failure to connect to a network host" with one simple handler that logs the failure and either aborts, retries or ignores.

aren't exception appropriate a according to a certain portion of developers. The reason they aren't exception appropriate is that you should expect these things to happen from time to time, ie they are not exceptional.

using exceptions to handle them is part of the problem Go attempts to solve by having multiple return values.

Re:Isaacs: try/catch is an anti-pattern by Dylan16807 on Monday November 14, 2011 @10:25AM (#3234301)
As far as I can tell either your point is a circular argument or it's an English-language nomenclature complaint fixable by s/exception/fooglewoo/.

Either way it doesn't address the real argument, about where it is appropriate to use try and catch. What is inherently better about multiple return values at every level, compared to semi-centralized catch blocks?

Re:Isaacs: try/catch is an anti-pattern by msbarnett on Monday November 14, 2011 @03:06PM (#3235460)
It's not really an objection to terminology. "Fooglewoo" handlers would still exist outside the normal flow of control while handling things that many people would consider routine.

Burying that kind of every-day, expected-circumstance logic in a side channel is, at least in some developers opinions, detrimental to the readability and understandability of a program.

Re:Isaacs: try/catch is an anti-pattern by chollida1 on Monday November 14, 2011 @11:12AM (#3234495)
I'm sorry, I can't really parse your argument.

My point was that there is a school of htought that exceptions should only be used in "exceptional" circumstances.

The examples given were not exceptional in that a programmer should expect those types of errors during the normal execution of their program. Therefor exceptions aren't the solution to those types of errors.

Does that make more sense to you?

Re:Isaacs: try/catch is an anti-pattern by Dylan16807 on Monday November 14, 2011 @11:27AM (#3234541)
But using that school of thought to support that school of thought isn't an argument, it's a circle.

PaulHoule is explaining why he likes a specific mechanism compared to another, and you are only replying with the previously-established fact that there exists a disagreement here, not a counterargument.

Re:Isaacs: try/catch is an anti-pattern by chollida1 on Monday November 14, 2011 @11:56AM (#3234672)
I get what your saying, I just disagree.

And I think alot of people take my point of view as evidenced by the votes my initial post received.

No worries, thanks for the point of view:)

Re:Isaacs: try/catch is an anti-pattern by Lagged2Death on Monday November 14, 2011 @09:46AM (#3234124)
I do have a problem with (1) checked exceptions, and (2) catching exceptions prematurely and (3) people not learning how to use "finally" so they do (2) and rethrow.

I am probably one of those people who catches exceptions prematurely and who hasn't learned to use "finally." If you link to some advice on how to use such things, I'll read it. I want to believe that I can learn a better way to use exceptions, but they just haven't clicked for me.

Then again, I've been using exceptions in an environment (C#) that matches the author's JSON.parse() example very well. The .NET library designers already decided what counts as exceptional, and it's often not possible for me, as a .NET user, to decide much of anything about the use or placement of try/catch.

...when you're building real systems, the complexity of the error handling can approach or exceed the complexity of the "normal" path...

I can understand all too well that a complex error handling path is intimidating, tedious, distasteful, and no fun at all. But in every serious project I've been a part of, error and exception handling has been where the bulk of the design, implementation, and testing work was done. That stuff is precisely how serious systems distinguish themselves from toys. Having a catch-all crash-path doesn't change that, because the serious system is not permitted to crash. As the author here points out, that's what assert() has offered for decades anyway.

Re:Isaacs: try/catch is an anti-pattern by dpark on Monday November 14, 2011 @10:43AM (#3234360)
>The .NET library designers already decided what counts as exceptional, and it's often not possible for me, as a .NET user, to decide much of anything about the use or placement of try/catch.

What do you mean? You can certainly decide what's exceptional. You can roll your own exceptions. You can catch and discard or handle exceptions you don't want to bubble up. You can put try-catch everywhere or nowhere (or choose a reasonable place in between). Your hands are not tied by .net exceptions any more than they are tied by any other reasonable error handling model.

Re:Isaacs: try/catch is an anti-pattern by Lagged2Death on Monday November 14, 2011 @12:58PM (#3234930)
You can certainly decide what's exceptional.

I can decide to make something in my code exceptional, sure. I can't decide to make something in the library not-exceptional, though.

You can put try-catch everywhere or nowhere (or choose a reasonable place in between).

This isn't always the case. Sometimes the only way to answer a question ("Can this string be parsed as an integer?") is to try it and catch the exception. And there's just no way to do that coherently without catching it immediately.

Later releases of .NET do include a non-exception-throwing TryParse() call in many places. I'm pretty sure I've run into some cases where that was not available, however, and I'm pretty sure I've run into similar situations in other methods besides Parse(). And TryParse() was a late addition; look back in the 1.1 or 2.0 docs, and it doesn't exist.

In other words, somebody thought it was reasonable to force .NET users to catch some exceptions immediately.

Your hands are not tied by .net exceptions...

No, but there's not much point in using .NET if I'm not using the library that comes with it. And the design of the library does tie my hands in some cases.

I think the author makes a great point about libraries that use exception handling blurring the line between bugs and expected problems. That's exactly how I feel about the C# work I've done.

Re:Isaacs: try/catch is an anti-pattern by dpark on Monday November 14, 2011 @03:14PM (#3235500)
> I can decide to make something in my code exceptional, sure. I can't decide to make something in the library not-exceptional, though.

Making something in the library non-exceptional is equivalent to discarding an error. Catch the exception and discard it. Done. Do this at whatever level you feel is appropriate (or don't, and handle the exception in a more reasonable fashion).

> In other words, somebody thought it was reasonable to force .NET users to catch some exceptions immediately.

What do you suppose should be done? The other option seems to be to continue in a erroneous state. I'm probably not familiar with every possible error-handling methodology, but it seems the main ones are "error codes" (those worked so great in C, right), "exceptions" (annoying, but error handling in general is annoying), and "injected handling" (where the caller can inject error handling code somehow; but this is more complicated and requires deeper knowledge about the callee). Is there a better option?

> No, but there's not much point in using .NET if I'm not using the library that comes with it. And the design of the library does tie my hands in some cases.

My point is that you are not tied by .Net any more than you are tied by any other exception-handling language. You can handle exceptions where and how you feel is appropriate.

> I think the author makes a great point about libraries that use exception handling blurring the line between bugs and expected problems. That's exactly how I feel about the C# work I've done.

I think this is a bit of a red herring. An exceptional condition is simply a special case. A bug in the code is an exceptional condition. A problem parsing a number is an exceptional condition. Modern languages generally have specific exceptions to allow you to handle different situations with custom logic, but it's important to note that the runtime can't reliably distinguish between "bugs" and "expected problems". Did your number parsing fail because the user entered an invalid value or because your code grabbed column 3 instead of 4?

Re:Isaacs: try/catch is an anti-pattern by Lagged2Death on Monday November 14, 2011 @05:12PM (#3235924)
Making something in the library non-exceptional is equivalent to discarding an error ... The other option seems to be to continue in a erroneous state.

I guess this is where we differ. I feel that the designers of the .NET library have chosen to throw exceptions in places where nothing exceptional is actually happening, where no error has occurred, where the programmer may very well be expecting the "exceptional" outcome.

Where my code must handle such conditions, forcing me to handle them as exceptions makes my code longer, less readable, harder to change, and harder to reason about.

...it's important to note that the runtime can't reliably distinguish between "bugs" and "expected problems".

This is exactly what the author of the linked piece points out, this is a part of my complaint, and it's an issue Microsoft has tacitly acknowledged the seriousness of by the addition of alternatives to exception-throwing calls, like TryParse().

The problem from my perspective isn't the runtime or the languages that target it, but choices made when the library was designed.

It does not feel to me, as a user of these massive libraries, that there was any systematic way of deciding what should be and what should not be reported as an exception.

Re:Isaacs: try/catch is an anti-pattern by dpark on Monday November 14, 2011 @07:14PM (#3236304)
> I guess this is where we differ. I feel that the designers of the .NET library have chosen to throw exceptions in places where nothing exceptional is actually happening, where no error has occurred, where the programmer may very well be expecting the "exceptional" outcome.

When does this actually happen? Are you really expecting it to fail when you open a file, or when you parse an integer, or whatever else? Where is .Net throwing exceptions in cases that no error has occurred and that you expect?

This complaint is common, but it feels rather hollow to me. Most of the time it seems to come down to a preference for error codes over exceptions, or an annoyance with the try-catch boilerplate, rather than a legitimate complaint about exceptions being thrown inappropriately.

> Where my code must handle such conditions, forcing me to handle them as exceptions makes my code longer, less readable, harder to change, and harder to reason about.

Are you suggesting that every function should have two versions like Parse and TryParse? Is this really what you'd prefer the .Net team work on, instead of providing new tools and functionality? Or are you wanting something like "ON ERROR RESUME NEXT" so that you can ignore these "expected" errors?

> This is exactly what the author of the linked piece points out, this is a part of my complaint, and it's an issue Microsoft has tacitly acknowledged the seriousness of by the addition of alternatives to exception-throwing calls, like TryParse().

Eh, the linked piece seemed mostly to be pining for the days of error codes. There's no general way to determine if a failure is a "bug" or "expected", not for exceptions and not for anything else. If you want to avoid exceptions for "expected" failures, then you're asking for no exceptions at all, which is fine, but the problem isn't just the definition of "exceptional".

> It does not feel to me, as a user of these massive libraries, that there was any systematic way of deciding what should be and what should not be reported as an exception.

The systematic way was "it's exceptional if it's not the desired or expected outcome". The addition of TryParse was a nice bonus, but is in itself an exception to the exception model.

Re:Isaacs: try/catch is an anti-pattern by Lagged2Death on Monday November 14, 2011 @09:32PM (#3236709)
When does this actually happen?

Oh, for Pete's sake. I'm not learning what I hoped to here, and you've made up your mind.

Re:Isaacs: try/catch is an anti-pattern by dpark on Monday November 14, 2011 @10:09PM (#3236832)
What were you hoping to learn?

Can you give me a practical situation where an exception is thrown despite there not being an error, aside from the canonical Integer.Parse() example? In my experience, that's not the bulk of any practical program, and it's still exceptional from the point of view of the Parse function.

I'd be interested in discussing this, but I'm not really sure what you think would be an improvement. And yes, it's a rather uphill battle if your proposal is to use error codes most of the time. I think that ship already sailed (although there's a strong case for error codes in C++, but that's kind of a special case).

Re:Isaacs: try/catch is an anti-pattern by julianz on Monday November 14, 2011 @11:05PM (#3236969)
An example comes to mind, from the very issue I'm working on at the moment:

System.ComponentModel.Win32Exception: The operation completed successfully at System.Drawing.BufferedGraphicsContext.CreateCompatibleDIB(IntPtr hdc, IntPtr hpal, Int32 ulWidth, Int32 ulHeight, IntPtr& ppvBits)

Re:Isaacs: try/catch is an anti-pattern by dpark on Monday November 14, 2011 @11:51PM (#3237077)
That's really terrible, and I can't defend that.

However, in the interest of trying to be helpful, my guess is that you have a bug in your app that plays poorly with a bug in Win32. A quick search for BufferedGraphicsContext.CreateCompatibleDIB yielded this question on SO (link to top answer) which indicates a resource leak may be at fault:

http://stackoverflow.com/questions/1209769/system-componentm...

Re:Isaacs: try/catch is an anti-pattern by SourPatch on Monday November 14, 2011 @11:59AM (#3234686)
How does Scala contribute to this problem? It does not have checked exceptions.
Re:Isaacs: try/catch is an anti-pattern by pyre on Monday November 14, 2011 @11:37AM (#3234578)
This:

  > We believe that coupling exceptions to a control
  > structure, as in the try-catch-finally idiom,
  > results in convoluted code.
Seems at odds with this:

   f, err := os.Open("filename")
   if err != nil {
      // handle error
   }
You're still using a control structure (if-statement) to handle the error.
Re:Isaacs: try/catch is an anti-pattern by kinghajj on Monday November 14, 2011 @12:14PM (#3234759)
But that control structure isn't specific to handling errors, unlike try/catch. I think that's what they meant.
Re:Isaacs: try/catch is an anti-pattern by sausagefeet on Monday November 14, 2011 @10:15AM (#3234260)
I don't think this style is much better than exceptions. I think Go could have done itself a favor if it has variants + pattern matching. I find those to be, in many cases, superior to exceptions as the compiler checks you are handling everything and you can easily encode success and failure in the variant type.
Re:Isaacs: try/catch is an anti-pattern by vog on Tuesday November 15, 2011 @01:41AM (#3237304)
This is exactly what I observed when using OCaml: Although it provides exceptions, I almost never used them. Most things were a lot simpler to implement via pattern matching (http://caml.inria.fr/pub/docs/oreilly-book/html/book-ora016....).
Re:Isaacs: try/catch is an anti-pattern by 0xABADC0DA on Monday November 14, 2011 @04:14PM (#3235727)
For some context here's another error handler in Google Go:

    defer func() {
        if r := recover(); r != nil {
            if err, ok := r.(runtime.Error); ok {
                if err.String() == "runtime error: index out of range" {
                    // handle bad index
                    return
                }
            }

            panic(r)
        }
    }()
vs

    try {
    }
    catch (IndexOutOfBoundsException ex) {
        // handle bad index
    }
A language where you have to resort to string compare to handle invalid array accesses can't be use as a model for good error handling IMO.

Of course that's just the tip of an iceberg with no way for IDEs/tools to know what return is an error, no way to know at a glance if "_" was an ignored error or ignored other extra return value, plus other fundamental problems caused by implicit types.

Re:Isaacs: try/catch is an anti-pattern by enneff on Monday November 14, 2011 @11:28PM (#3237022)
Whose crazy code is that? NOT idiomatic. If you need to recover from bad slice indexes then your code is broken and you have way more to worry about than a messy recover closure.
Re:Isaacs: try/catch is an anti-pattern by 0xABADC0DA on Tuesday November 15, 2011 @01:44AM (#3237311)
> If you need to recover from bad slice indexes then your [error handler] code is broken

You bring up a good point that when resorting to value comparisons for error handling instead of type comparisons it's easy to make mistakes. The code is as far as I can tell a simplest way to handle an index out of bounds, but to also handle a 'slice out of bounds' it would need to also compare to the string value "runtime error: slice bounds out of range" -- not helping the case for error handling in Google Go.

This code strikingly shows deficiencies in Google Go non-local error handling:

- Tons of boilerplate (defer, recover, re-panic, type check, value check)

- Not scoped so can only handle an error once per function

- Have to do value tests in addition since types are very generic due to implicit interfaces

- Error values are poorly defined

- Result for higher-level caller is buried deep in the function and non-obvious

These problems extend to all non-local error handling in Google Go, not just for this specific case of array and string indexes. That the idiomatic way to 'handle' an error is to abort the program is another separate problem.