News for hackers. Stuff that matters.
Re:Error stack traces in Go with x/xerror by justinclift on Monday August 23, 2021 @07:34PM (#28283413)
Hmmm...

  and (2) a way to cut down on if err != nil { ... }
  boilerplate that pervades all Go code.
Am I weird in liking the explicit error handling? :/
Re:Error stack traces in Go with x/xerror by bccdee on Monday August 23, 2021 @09:39PM (#28284220)
I like explicit error handling, but I wish there were a concise way to handle errors from the same line. A one-line function call `foo()` becomes four times as long once you handle errors.

    result, err := foo()
    if err != nil {
        return nil, fmt.Errorf("Error message: %w", err)
    }
This pattern is just so commonplace, but it's four times as long.

Contrast with Rust, which handles errors as `foo()?` or `foo().context("Error message")?`*. It's still explicit — I like it better than silently-propagating exceptions — but my functions don't wind up being 75% error handling.

* Where the `context` function comes from an error-handling library.

Re:Error stack traces in Go with x/xerror by suresk on Monday August 23, 2021 @08:04PM (#28283630)
I don't think you're weird - I understand that some people like it and I can kind of see some of the arguments as to why - but the error handling in Go is easily my least favorite thing about it. For two reasons:

1) The aforementioned boilerplate code that makes up a significant chunk of many Go projects and adds no value.

2) With explicit error handling, however deep your call stack is, you are relying on everything in that stack to have done the right thing with regards to error handling. With exceptions, you have to go out of your way to screw them up.

I can't tell you how many times I've gotten dumb error messages like "Invalid string" from a 3rd party library that take forever to debug, and accidentally swallowing an error is even worse. A simple (even crappy) exception message + a stack trace is much easier for me to use for debugging than even the best handcrafted error message in 99% of cases.

I write somewhat equivalent amounts of Python, Java, and Go lately, and each one has their good and bad parts, but there are few things I dislike as much as Go's error handling patterns.

Re:Error stack traces in Go with x/xerror by johnmaguire on Monday August 23, 2021 @08:37PM (#28283855)
> With explicit error handling, however deep your call stack is, you are relying on everything in that stack to have done the right thing with regards to error handling. With exceptions, you have to go out of your way to screw them up.

I don't think I agree with this argument. In many languages, there's no obvious indicator that any given function may or may not raise / throw an exception. And even if it doesn't throw an exception today, it might tomorrow, and it's easy to forget to update all callers.

Since Go makes errors a return value you have to actively discard the result (by replacing it with a underscore, e.g. `res, _ := getResults()`) or take the time to handle the error.

And just like an intermediary library in Go can swallow the error, so can an intermediary library in an exception language catch and discard an exception.

It seems to me that the result is more errors are properly handled in Go - because they are explicit - while uncaught exceptions often cause bugs that make it to production.

For context, I recently switched jobs from one where I wrote Python for 4.5 years to a job where I've been writing Go for about 5 months.

Re:Error stack traces in Go with x/xerror by suresk on Monday August 23, 2021 @08:43PM (#28283882)
> With Go making errors a return value you have to actively discard the result (by replacing it with a underscore, e.g. `res, _ := getResults()`) or take the time to handle the error.

Right, but because `err` ends up getting re-used in so many cases, you can re-assign it and forget to do anything about it (which is what I've found in most cases where an error was inappropriately suppressed in Go).

In most cases, simply bubbling up the error to something that will generically handle all errors is the right thing to do, and in the case of exceptions, even if you don't know about one, that is what will happen. I just sampled a handful of the top Golang repos on Github, and found very few cases of anything more than the standard `if err != nil; return nil, err' pattern that just bubbles the error up.

Re:Error stack traces in Go with x/xerror by anonymoushn on Tuesday August 24, 2021 @03:47AM (#28286071)
Last time I wrote go you could write `doThingAndMaybeReturnErr()` without the `_ =`. Has this changed?

The alternative is Zig or Rust's thing, where you still have explicit error handling but you don't repeat the same four lines all the time. This is maybe helpful because in Go one has to read those lines carefully to see if anything unexpected is happening.

Re:Error stack traces in Go with x/xerror by papaf on Tuesday August 24, 2021 @06:55AM (#28287126)
Linters such as golangci[1] which will warn if you ignore the return value. If you ever write Go again I highly recommend you look at golangci -- the security checks have been really helpful to me.

[1] https://golangci-lint.run/

Re:Error stack traces in Go with x/xerror by n_e on Tuesday August 24, 2021 @05:01AM (#28286459)
> Since Go makes errors a return value you have to actively discard the result (by replacing it with a underscore, e.g. `res, _ := getResults()`) or take the time to handle the error.

LoadData(&data)

Does this function return nothing or an error ?

Re:Error stack traces in Go with x/xerror by cy_hauser on Tuesday August 24, 2021 @05:31AM (#28286639)
It returns nothing or the compiler/linter/ide will tell you.
Re:Error stack traces in Go with x/xerror by tsimionescu on Tuesday August 24, 2021 @05:50AM (#28286764)
Which compiler/linter/IDE is that? The Go compiler and linter certainly don't tell you:

https://play.golang.org/p/k-eTs3dC_wK

Note that Go playground also runs go vet, a static analysis tool.

Re:Error stack traces in Go with x/xerror by cy_hauser on Tuesday August 24, 2021 @07:09AM (#28287220)
You're probably right. I use Goland and I just think of it as a natural extension to Go. I shouldn't.
Re:Error stack traces in Go with x/xerror by kortilla on Tuesday August 24, 2021 @03:45AM (#28286065)
> Since Go makes errors a return value you have to actively discard the result (by replacing it with a underscore, e.g. `res, _ := getResults()`) or take the time to handle the error.

This is a bad thing because it’s not narrow. It’s like a language’s “catch” statement not allowing you to catch specific exceptions. Once someone has decided to throw away an error with the underscore assignment, all future errors the underlying might return are swallowed as well.

In other words, it takes even more boilerplate to have narrower error exemptions than to have the generic exemption.

> It seems to me that the result is more errors are properly handled in Go - because they are explicit - while uncaught exceptions often cause bugs that make it to production.

An error in go that is blindly returned all of the way up the stack has no difference with an uncaught exception.

Re:Error stack traces in Go with x/xerror by laumars on Monday August 23, 2021 @08:54PM (#28283949)
There’s two types or reason for a program to error:

- the code has failed and the developer needs to be informed what to fix

- the environment has failed and the user needs to be informed

Exceptions are for the former, which Go still supports via Panic(). Errors are for the latter. Which is why all the boilerplate Err code creeps in.

I don’t like getting stack traces from applications when I’m a user. It always feels to me like the application is only half finished. When the error is environmental (eg file system permissions) a stack trace just muddies the water with unnecessary output.

This is why I like Go’s distinction between errors and exceptions.

Re:Error stack traces in Go with x/xerror by zarzavat on Monday August 23, 2021 @09:47PM (#28284277)
This is great in theory but in reality no such distinction exists. For example, is trying to read a missing file a failure of the code, or a failure of the user? It could easily be either, the developer hardcoded the file path wrong during development, or the user selected a wrong path in a CLI, ... the distinction between errors and exceptions must made by the call site, not the definition site. The code calling readFile() knows whether the error is recoverable or not. readFile() itself does not, so the same mechanism should be used for both errors and exceptions.

All this was figured out decades ago, that's why exception systems were invented, but language designers keep making the same mistake over and over again in an effort to simplify the unsimplifiable.

Re:Error stack traces in Go with x/xerror by laumars on Tuesday August 24, 2021 @03:47AM (#28286076)
In your example, it should be an error because it’s an environmental problem (could be file system permissions). Sure, it could be a developer fail where they hardcoded the wrong path (surely any kind of testing would pick this up?) but it’s still an error in the environment where had the path been correct it could fail due to something the user misconfigured. So it needs to be handled as a user facing error.

Exceptions do exist in Go, it’s called “Panic”. This whole “Go doesn’t have exceptions” meme is completely untrue. It’s just not the preferred way of error handling because, unsurprisingly, most application errors are going to be environmental. But if you select an out of bounds index in a slice or don’t handle a nil pointer correctly you’d get a panic — because those are clearly developer issues that warrant a stack trace rather than environmental problems that need a friendly user facing error message.

Re:Error stack traces in Go with x/xerror by zarzavat on Tuesday August 24, 2021 @04:21AM (#28286278)
If you make it an environmental error then the programmer is likely to write an error handler that ignores the error because it can "never" happen and the compiler is forcing them handle it. You now need a linter to prevent this and a way to signal to the linter that "no I really intended to ignore that error, I promise"

Whereas exceptions fail safe, ignoring the error means not catching it, which means if the error does occur, it will load up the debugger.

This is the whole Java "checked exceptions" misfeature again.

Re:Error stack traces in Go with x/xerror by laumars on Tuesday August 24, 2021 @04:45PM (#28294780)
This makes no sense. Plus naff developers can be just as lazy with exceptions if they wanted. A try/catch block can be abused extremely easily.
Re:Error stack traces in Go with x/xerror by atomicity on Monday August 23, 2021 @11:20PM (#28284753)
Except that people are too lazy to use exceptions that are checked at compile time.

The main benefit of Go is that the people that defined the library ecosystem actually decided to handle errors. It's the bare minimum, but it's better than just forgetting that the error exists and not documenting it either.

The language is ... not the best, but the libraries tend to be more robust.

Re:Error stack traces in Go with x/xerror by tsimionescu on Tuesday August 24, 2021 @05:56AM (#28286791)
Libraries can almost never handle errors - they can only signal them. And Go libraries are particularly bad at this, because they almost always return error strings, instead of meaningful error types, which means you can't easily handle a subset of errors. Even if you did, Go's errors suffer from the same problems as exceptions in many languages: there is no way to document what errors your function can actually return, just that it returns some error.

What language are you thinking of when saying Go libraries do better at error handling?

Re:Error stack traces in Go with x/xerror by erik_seaberg on Tuesday August 24, 2021 @01:59AM (#28285566)
It’s not always laziness, in Java

  stream.map(f)
doesn’t allow f to declare any checked exceptions. We could catch and wrap everything but that obscures the useful code without any improvement in safety.
Re:Error stack traces in Go with x/xerror by simiones on Tuesday August 24, 2021 @06:33AM (#28286974)
Your entire argument rests on the weird assumption that the User is responsible for the environment. In the vast majority of software used today, that is not the case.

In SaaS, mobile, and appliances, the environment is entirely or almost entirely controlled by the programmer - a missing file is the developer's problem, and the user can't do anything about it.

In enterprise software, there is a third entity, the Administrator, that has (almost) full control over the environment, and usually there are layers of 3rd party software that control it directly. A missing file or permission error is useless to the user, most likely it needs to be logged somewhere that Admins check, and the user simply told to contact their Admin.

Finally, even in personal desktop software, the environment is jointly owned by the user and the developer - the developer is normally responsible for setting up the initial environment through some kind of installer (msi, deb, make configure etc.), and many environment issues are bugs in the installer, not user errors.

Of course, the same library may very well be used in all of these vastly disparate deployment scenarios - the library can't decide what is the source of an error, so making it arbitrarily decide between two possible kinds of errors is wrong.

Note that even the reverse is not clear; an index out of bounds error could be a user problem - if they are trying to access the 7th element of a 5 element list. The fact that you'd normally do

  if userSelectedElement > len(arr) {
    return nil, fmt.Errorf("Array index out of bounds")
  }
  return arr[userSelectedElement], nil
Is only because of the convention you were proposing - `return arr[userSelectedElement]` does the same thing alone, if we disregard the convention (in a memory safe language, of course!).
Re:Error stack traces in Go with x/xerror by laumars on Tuesday August 24, 2021 @04:30PM (#28294595)
Your argument is just reinforcing the reason for errors to be concise and to the point rather than displaying a stack track when it’s not the developers who are administering the application.

Trust me, searching through a stack trace on a centralised logging system isn’t fun.

> Finally, even in personal desktop software, the environment is jointly owned by the user and the developer - the developer is normally responsible for setting up the initial environment through some kind of installer (msi, deb, make configure etc.), and many environment issues are bugs in the installer, not user errors.

Desktop Linux, yeah. It’s seldom that simple in servers though. SELinux, custom config, custom iptables rules, network wide UIDs (eg shared storage volumes), there’s so much that can go wrong the moment you do enterprise.

> Note that even the reverse is not clear; an index out of bounds error could be a user problem - if they are trying to access the 7th element of a 5 element list. The fact that you'd normally do

If you’re writing software that doesn’t do input validation and bounds check then you’re a failure of a developer. Sorry but this is the bare minimum I’d expect a developer to do.

Re:Error stack traces in Go with x/xerror by tsimionescu on Wednesday August 25, 2021 @03:52AM (#28299043)
> Trust me, searching through a stack trace on a centralised logging system isn’t fun.

A stack trace is still better than a one line error with no context. It's a kind of 80% solution - it's not ideal (a perfect error includes only the relevant context), but getting it's much better for 0 effort than error codes/values give you for free.

> If you’re writing software that doesn’t do input validation and bounds check then you’re a failure of a developer. Sorry but this is the bare minimum I’d expect a developer to do.

So what is the profound difference between doing input validation in your own code vs letting the array accessor do it?

Re:Error stack traces in Go with x/xerror by laumars on Wednesday August 25, 2021 @04:36AM (#28299242)
> A stack trace is still better than a one line error with no context. It's a kind of 80% solution - it's not ideal (a perfect error includes only the relevant context), but getting it's much better for 0 effort than error codes/values give you for free.

Yeah, a stack trace is better then an “undefined error” type message. But the point of forcing error messages over exceptions is you’re enabling you’re developers to write meaningful error messages. So your point is moot.

> So what is the profound difference between doing input validation in your own code vs letting the array accessor do it?

- Meaningful error messages (eg has the code failed because of a bug or because of invalid user input?),

- security hardening,

- reducing potential undefined behaviours,

- thorough unit testing,

- self documenting code (the code clearly defines what the happy path is and when it’s possible for a user to break out from that)

Etc

Re:Error stack traces in Go with x/xerror by konart on Tuesday August 24, 2021 @03:08AM (#28285907)
>Exceptions are for the former, which Go still supports via Panic().

The panics are there to be used only in cases where the further code execution is impossible. Not to inform the developer about an error.

Errors are a general solution to report an unexpected event during execution. The destination of such report depends on the part of code the program failed.

Re:Error stack traces in Go with x/xerror by laumars on Tuesday August 24, 2021 @03:57AM (#28286125)
I get that what you’ve posted is the official description but it doesn’t really explain the distinction well IMO. Eg there are plenty of environmental reasons you’d need to cease execution but giving the user a stack trace isn’t helpful. So be describing the two as who the target recipient of the error is helps. Or at least I think it does.

Personally my one gripe with Gos errors is that EOF is handled as an error.

Re:Error stack traces in Go with x/xerror by konart on Wednesday August 25, 2021 @10:01AM (#28301816)
> Eg there are plenty of environmental reasons you’d need to cease execution but giving the user a stack trace isn’t helpful.

Not sure I got this part. If you want to stop the program and don't to print the usual panic messages into the console - you can log\print whatever you want and call os.Exit().

At the same time you can log stack trace without panicing.

>Or at least I think it does.

Maybe, it's just that "the code has failed and the developer needs to be informed what to fix" applies to errors just a much as to panics. The only difference is that an error is the situation during the execution where you can continue the job and a panic requires execution to stop (in most cases).

At the same time panic are 'developers only'.

Re:Error stack traces in Go with x/xerror by laumars on Thursday August 26, 2021 @01:41PM (#28318022)
You’re arguing the same points I’m making :)
Re:Error stack traces in Go with x/xerror by ithkuil on Monday August 23, 2021 @08:09PM (#28283665)
> With exceptions, you have to go out of your way to screw them up.

I remember well java codebases littered with:

    try { .. } catch() { // Todo }
Usually cheaply inserted by the IDE.

I'm pretty sure nowadays there are linters that will ensure you have to do some extra work to actually check in such code, but still...

Re:Error stack traces in Go with x/xerror by suresk on Monday August 23, 2021 @08:14PM (#28283694)
I've never had a Java IDE insert something like that?

But either way, you have to go out of your way to do that, which is sort of my point.

The one place where you do see dumb boilerplate and chances to screw up is in dealing with checked exceptions, which have been controversial since the very beginning. I think they are one of those things that seem like a great idea in theory, but end up not working out so well in practice, but (like people who appreciate Go's error handling model) there are people who disagree.

Re:Error stack traces in Go with x/xerror by m45t3r on Monday August 23, 2021 @08:48PM (#28283913)
Exactly. It is kinda obvious that someone is doing something wrong with the code when they're doing a generic catch (sometimes it is fine, but this will at least raise some eyebrows).

However it is very easy to do the wrong thing using Golang. Just one random library doing `fmt.Errorf` without the `%w` verb is sufficient to lost all information from there on. I would much prefer some kinda of annotation that does the correct thing by default (wrapping the error) instead of the "every error should be explicitly" approach of Golang.

Re:Error stack traces in Go with x/xerror by anonymoushn on Tuesday August 24, 2021 @03:51AM (#28286096)
The above code is probably caused by checked exceptions. In particular, the user wants to implement some interface or override some method, but that method wasn't declared to throw a particular type of exception because the people who wrote it hate extensibility and never want their software to be used in a way they didn't anticipate, so the new implementation can't throw it either.
Re:Error stack traces in Go with x/xerror by ithkuil on Tuesday August 24, 2021 @03:42AM (#28286049)
> I've never had a Java IDE insert something like that?

yeah this indeed happens with checked exception and careless developers just wanting to get stuff to compile (we'll handle that property later) and the IDE helpfully providing the boilerplate that resolves the compilation error (and assumes you'll fill the body)

Re:Error stack traces in Go with x/xerror by xpressvideoz on Monday August 23, 2021 @11:02PM (#28284682)
I don't buy the argument that Go makes error handling explicit. It is too easy to forget to check for an error in Go. Did you know that `fmt.Printf` can also fail? Do you explicitly check for `err` when using it? Probably not, because what Go calls explicit error handling is merely a convention, not something supported by the language, e.g. [[nodiscard]] from C++ or #[must_use] from Rust. And who thought reassigning `err` multiple times was a good idea? That again strikes a lack of functionality in Go.

What saddens me is that these kinds of matters will never be fixed in Go. Go has a stubborn anti-feature mentality and while it does help preventing feature creep, it overall harms the language in the long run. For a language created and maintained by Google this is a huge missed opportunity.

Re:Error stack traces in Go with x/xerror by xh-dude on Tuesday August 24, 2021 @04:20AM (#28286272)
I’m not sure the mentality is exactly “oops, oh well, leave it broken forever” [0]; it is intentionally ponderous. As a stop-gap, linters [1] can get excellent insight from ASTs.

The stability of Go is something I value a lot, so I don’t mind stop-gaps like this too much on balance.

[0] https://github.com/golang/go/issues/20148

[1] https://github.com/golangci/golangci-lint

Re:Error stack traces in Go with x/xerror by makapuf on Tuesday August 24, 2021 @02:38AM (#28285759)
There has been a go2 proposal for better error handling, so there is no issue trying to improve things or adding needed features. But things go slowly and must be discussed and vetted before being accepted because the language has few features and they will stick so the filter is quite high. See generics, it took a long time but its coming.
Re:Error stack traces in Go with x/xerror by tsimionescu on Tuesday August 24, 2021 @05:59AM (#28286811)
The proposal for better error handling was rejected, as far as I'm aware. Generics needlessly repeated the mistakes of Java and C# in coming out years too late.
Re:Error stack traces in Go with x/xerror by makapuf on Tuesday August 24, 2021 @07:52AM (#28287572)
I kind of agree, it's better to have generics from the start (we'll see if there are difficulties added), and the error handling was rejected. But the fact that those proposals have been proposed, discussed, studied and for one of them accepted show that the language can evolve.
Re:Error stack traces in Go with x/xerror by thiht on Tuesday August 24, 2021 @02:58AM (#28285854)
> Did you know that `fmt.Printf` can also fail? Do you explicitly check for `err` when using it? Probably not, because what Go calls explicit error handling is merely a convention

I was curious about this and it’s true, I didn’t know these functions could err, TIL.

The Godoc states:

> It is conventional not to worry about any error returned by Printf

Re:Error stack traces in Go with x/xerror by obviouslynotme on Monday August 23, 2021 @11:37PM (#28284820)
I hate it. All it does is add if err != nil { return nil, err } to every other line. I love Go, but I have never understood the obsession with generics over putting try into the language. This is the biggest pain in Go, by far.

The vast majority of errors only stop or rollback the current action. An incredibly small amount of code uses errors to detect stop conditions or to retry.

Re:Error stack traces in Go with x/xerror by simiones on Tuesday August 24, 2021 @06:38AM (#28287009)
To be fair, generics can allow you to get rid of some of this boilerplate, in principle. Though I would still love to get some built-in error handling.
Re:Error stack traces in Go with x/xerror by obviouslynotme on Tuesday August 24, 2021 @03:01PM (#28293345)
Then you just have Railroad Programming without the monadic binding operators and currying of the languages where that is the main mode of dealing with errors. That sounds awful.
Re:Error stack traces in Go with x/xerror by aniforprez on Tuesday August 24, 2021 @04:20AM (#28286274)
I know people on HN hate python to some extent because of performance issues but I love the error handling in python. Trying to learn go on the side this is the biggest thing by far that just halted all of that. No error handling? I was baffled. I hope they add this into the language. There's no way I'm wasting time writing `if err != nil` all over my code. try/catch blocks please
Re:Error stack traces in Go with x/xerror by nightfly on Monday August 23, 2021 @08:08PM (#28283652)
I prefer how Rust wraps it in a type. Makes it seems like "part" of the language, rather than something bolted onto every function.
Re:Error stack traces in Go with x/xerror by masklinn on Tuesday August 24, 2021 @04:14AM (#28286231)
> Am I weird in liking the explicit error handling? :/

The issue is not explicit error handling it’s specifically Go’s, which is verbose and half-assed. Not entirely unlike java’s checked exceptions though unlike checked exceptions we have plenty of other (and I’d argue better) implementations of “explicit error handling”.

Go’s error handling is a relatively minor improvement on C’s, but we’ve gotten quite a ways beyond that since.

Re:Error stack traces in Go with x/xerror by kortex on Monday August 23, 2021 @11:21PM (#28284758)
I just want Result types I can map over. That would cut out a bunch of clutter. Even if I could pair one fallible function with one infallible function, that's 50% less err != nil

   val, err := int_or_err(foo)
   if err != nil { return nil, err}
   return val.add(bar), nil
Vs

   result := int_or_err(foo)
   return val.map(add,bar) 
I'd even take some sort of

   result := int_or_err(foo)
   return val.map(add,bar).tuple()
to return a val,err pair in order to match conventional go.
Re:Error stack traces in Go with x/xerror by Cthulhu_ on Tuesday August 24, 2021 @07:39AM (#28287442)
It looks more concise but if you're like me not into functional programming much, .map() is magic.

Consistency is more important than conciseness. Clear is better than clever. Plus, a function invocation / .map() is heavier than an err != nil check / condition.

Don't get me wrong, I appreciate the Either pattern as an alternative to if err != nil, but I also appreciate the really dumb and straightforward approach of non-clever Go.

Re:Error stack traces in Go with x/xerror by ibraheemdev on Monday August 23, 2021 @08:34PM (#28283839)
I think the main issue is not the boilerplate as is usually the source complaints, but the fact that not handling errors is so easy due to shadowing.
Re:Error stack traces in Go with x/xerror by tsimionescu on Tuesday August 24, 2021 @06:03AM (#28286821)
Both are problematic. Boilerplate does wonders for mistakes hidden in plain sight - especially when you have that one rare piece of code that actually does something with an error, and it completely slips by code review because anyone who works with Go has long learned to glaze over anything that begins with if err!=nil
Re:Error stack traces in Go with x/xerror by beltsazar on Tuesday August 24, 2021 @12:09AM (#28285007)
Exception error handling is implicit because we don't know which line inside a try block can throw an exception.

However, Go's `if err != nil` is not more explicit than, for example, Rust's question mark operator. The former is more verbose than the latter, yes. But both are explicit in that we can know which line can return an error.

The `if err != nil` is probably okay if there are only a few lines that can return an error, but if most lines in a function can return an error, it will result in too much noise. A real world example where panic is abused as an exception-like approach because the "proper" error handling using `if err != nil` is way too verbose: https://pkg.go.dev/github.com/apple/foundationdb/bindings/go... (Actually Go's stdlib too sometimes abuses panic in a similar way.)

Re:Error stack traces in Go with x/xerror by vips7L on Tuesday August 24, 2021 @06:00AM (#28286814)
> Exception error handling is implicit because we don't know which line inside a try block can throw an exception

You just need to have some thought when writing your code:

  let a;
  try {
    a = someFailingFunc();
  } catch (e) {
    // handle
  }

  // use a
  // do work
Re:Error stack traces in Go with x/xerror by simiones on Tuesday August 24, 2021 @06:45AM (#28287050)
The whole point of Exceptions is to avoid writing try/catch all over the place. Let's take an example of idiomatic exception-based code:

  func doRequests(url1, url2 string) resp throws HttpException {
    resp1 := http.DoRequest("POST", url1)
    resp2 := http.DoRequest("GET", url2 + resp1.ID)
    return resp2
  }
vs

  func doRequests(url1, url2 string) (resp, error) {
    resp1, err := http.DoRequest("POST", url1)
    if err != nil {
      return nil, fmt.Errorf("Error in req1: %w", err)
    }
    resp2, err := http.DoRequest("GET", url2 + resp1.ID)
    if err != nil {
      return nil, fmt.Errorf("Error in req2: %w", err)
    }
    return resp2, nil
  }
Of course, we can write the second example with try/catch as well, but the whole point of exceptions is to be able to write the first one when appropriate.
Re:Error stack traces in Go with x/xerror by vips7L on Tuesday August 24, 2021 @11:45AM (#28290374)
> The whole point of Exceptions is to avoid writing try/catch all over the place

Of course. I'm talking about when you actually handle your exceptions you should be specific about the lines you're handling.

Re:Error stack traces in Go with x/xerror by SamWhited on Tuesday August 24, 2021 @08:23AM (#28287864)
I tend to agree, I dispute the premise that this is a problem a bit. I mean, I get not wanting to type the same thing repeatedly, but when reading code later it's really nice to have the logic explicitly in front of me and not hidden behind some other syntax or function. It could possibly be done better, but it doesn't need to be done better, IMO.
Re:Error stack traces in Go with x/xerror by BobbyJo on Monday August 23, 2021 @07:53PM (#28283552)
Explicit error handling and a lack of generics were a pain when I first started with Go, but after a few years I see them as amazing features.
Re:Error stack traces in Go with x/xerror by codegeek on Monday August 23, 2021 @07:36PM (#28283428)
there are arguments against it but I frankly like it being this explicit as a newbie in Go. So you are not alone :)
Re:Error stack traces in Go with x/xerror by throwaway894345 on Monday August 23, 2021 @07:44PM (#28283487)
I’ve been writing Go for a decade and I’ve liked it from the beginning, but stack trace support is welcome.
Re:Error stack traces in Go with x/xerror by dhagz on Monday August 23, 2021 @07:56PM (#28283575)
Yep - my biggest gripe is seeing errors with no context around them - either a stack trace or...well...the context.Context.
Re:Error stack traces in Go with x/xerror by ollien on Monday August 23, 2021 @08:03PM (#28283618)
I've just started writing C++ for work, and I have to say, I miss stack traces so much. Even with Go errors the wrapping usually made it easy enough, but with how long it takes to get gdb to launch from core dumps (~1m30 on our binaries at work), I really do miss that extra context.
Re:Error stack traces in Go with x/xerror by bombela on Tuesday August 24, 2021 @04:35AM (#28286342)
100% Shameless plug. Stack capture and pretty printer for C++: https://github.com/bombela/backward-cpp
Re:Error stack traces in Go with x/xerror by ollien on Tuesday August 24, 2021 @12:41PM (#28291300)
This looks super neat. Thanks!
Re:Error stack traces in Go with x/xerror by gpderetta on Tuesday August 24, 2021 @10:11AM (#28289078)
It is not particularly hard to log stack traces in C++, for example from an abort signal handler or attaching them to exceptions.

There is no standard solution though, so you have to rely on 3rd party libraries or use platform specific solutions.

Re:Error stack traces in Go with x/xerror by jcelerier on Tuesday August 24, 2021 @06:51AM (#28287096)
why not just enable them ? there are plenty of minimally invasive and permissively licensed options... that's like -Werror=return-stack-address it's an entire no-brainer
Re:Error stack traces in Go with x/xerror by ollien on Tuesday August 24, 2021 @12:41PM (#28291297)
Well, namely it's not my decision to enable them for the entire codebase :) but I may very well try to talk some people into enabling this on debug builds.
Re:Error stack traces in Go with x/xerror by IshKebab on Tuesday August 24, 2021 @09:28AM (#28288568)
I don't think so. I like that it strongly encourages you to actually add human readable context to errors too.

I think people's issue is that there's no "I don't care about errors, just show me a stack trace" option like you get with exceptions, or more or less with Rust's `?` if you don't use `.context()`.

Re:Error stack traces in Go with x/xerror by iambvk on Monday August 23, 2021 @08:28PM (#28283798)
It becomes painful to write in unit tests.

I really liked their `check` proposal. I hope they will bring it back to life.

Re:Error stack traces in Go with x/xerror by politician on Monday August 23, 2021 @08:32PM (#28283830)
Do you use stretchr/testify/assert? I find that it makes error handling in tests as natural as assertions on other properties.
Re:Error stack traces in Go with x/xerror by benhoyt on Monday August 23, 2021 @09:21PM (#28284099)
Aside from the "assertion" libraries, which I have mixed feelings about, I often use table-driven tests to avoid this. That way each test is generally one line, like `{"1234", 1234}` for testing an Atoi function. Or, I've seen little test helper functions that "fatal" the test on error -- that way it only takes one line instead of three: https://play.golang.org/p/WIALie5fsgd
Re:Error stack traces in Go with x/xerror by simiones on Tuesday August 24, 2021 @06:48AM (#28287076)
The thing I hate about table-driven tests is that they make it slightly harder to identify where an error has occurred, and much harder to debug the specific test case that triggered the error, especially in Go where dlv lacks value breakpoints (or it did last time I checked - if they've added that in the meantime, this becomes much less of a problem).
Re:Error stack traces in Go with x/xerror by tomohawk on Monday August 23, 2021 @08:37PM (#28283852)
In my experience, the people who complain about this the most are the least likely (in go or other languages) to pay proper attention to handling errors, and are the most likely to pay way too much attention to how code looks. Not just tidy, but a certain style. They're used to not seeing code in places where errors are emitted (exceptions) and putting magic try/catch blocks that often lead to imprecise error handling.
Re:Error stack traces in Go with x/xerror by OJFord on Monday August 23, 2021 @08:04PM (#28283628)
I've learned to consider it an excellent feature, but is Go's implementation/idiom really better than anything that came before it?

I have marginally more experience with Rust (not that much of either) which instead gives Result types, tuples of 'ok' and error values. And, crucially for this thread, they must be explicitly consumed.

That enforced error handling is novel to Rust afaik, and after a bit of getting used to, an excellent feature I think.

But I'm not sure that the idiomatic (because that's all it is really, rather than language feature?) Go is materially different from deciding all your Python functions will return Tuple[TOk, TErr] and sticking to it, or even that different from returning ok types only and raising exceptions, really.

Re:Error stack traces in Go with x/xerror by andrenth on Monday August 23, 2021 @08:31PM (#28283819)
> That enforced error handling is novel to Rust afaik

Hardly, though Rust of course has merit in making it popular, to the point that people think it was introduced by the language.

Re:Error stack traces in Go with x/xerror by OJFord on Monday August 23, 2021 @08:48PM (#28283912)
Well that's why I said as far as I know. What else has something similar?
Re:Error stack traces in Go with x/xerror by monocasa on Monday August 23, 2021 @09:10PM (#28284050)
Anything with ADTs. I know it from the ML family of languages (Ocaml, Standard ML, F#, etc.)
Re:Error stack traces in Go with x/xerror by Zababa on Tuesday August 24, 2021 @03:46AM (#28286068)
I think one difference between Rust and OCaml is that in Rust non exhaustive pattern matches are an error, while in OCaml they are a warning.
Re:Error stack traces in Go with x/xerror by OJFord on Monday August 23, 2021 @09:18PM (#28284085)
> Anything with ADTs.

Well that's not true, that's completely orthogonal?

Re:Error stack traces in Go with x/xerror by monocasa on Monday August 23, 2021 @10:29PM (#28284508)
It's not. "Forced error handling" in Rust (particularly when contrasted with something like Go like we're doing here) is exemplified with the Option and Result types, and how the compiler will maintain type safety around the concepts of success and error. ADTs are what lets it do that, and the MLs do that as well. You can also see this in how Typescript for example uses ADTs for typesafe error/success state space enumeration.
Re:Error stack traces in Go with x/xerror by OJFord on Tuesday August 24, 2021 @04:46AM (#28286389)
But you could have ADTs without using them for 'forced error handling', and you could have 'forced error handling' without using ADTs for it - C could require 'consumption' (for a slightly less strict meaning of it) of return values. That's the bit I think is interesting/was new to me. You can't just call `maybe_works();`, you have to explicitly consume its 'result', even if just to propagate the error as `maybe_works()?;`.
Re:Error stack traces in Go with x/xerror by monocasa on Tuesday August 24, 2021 @11:03AM (#28289765)
Oh, ok. Yeah that in fact does exist in C and C++ the same way as in Rust. Rust doesn't actually by default require you to consume a return value; a lot of functions are just marked as #[must_use]. C and C++ do the same thing with [[nodiscard]] and __attribute__((warn_unused_result)).

There's a go vet pass as well. https://pkg.go.dev/github.com/golangci/govet#hdr-Unused_resu...

Re:Error stack traces in Go with x/xerror by ttymck on Monday August 23, 2021 @10:35PM (#28284552)
No, not really, it's an accurate summation of where the pattern is commonly found. ADTs, like Rust's Enum, enable this kind of error handling, and are made more ergonomic with monad behaviors.

Scala's Either[A, B] is another example.

Re:Error stack traces in Go with x/xerror by scns on Tuesday August 24, 2021 @02:58AM (#28285858)
Yes, but Haskells'/Scalas' Either is abstract while Rusts' Result is specific SFBAP (Sorry For Being A Pedant).
Re:Error stack traces in Go with x/xerror by ttymck on Tuesday August 24, 2021 @01:47PM (#28292446)
Can you clarify the distinction between "abstract" and "specific"?

Is Scala's Try[A] "specific"?

Re:Error stack traces in Go with x/xerror by scns on Wednesday August 25, 2021 @04:17PM (#28306380)
Sure. Result is specific, you get a value or an error. Either can be used the same way, but you don't have to. The convention is use Right for the value and Left for the error but you can use it in other ways too, eg Left for an Int and Right for a Float.
Re:Error stack traces in Go with x/xerror by content_sesh on Monday August 23, 2021 @08:54PM (#28283954)
Haskell's Maybe type (monad?) comes to mind.
Re:Error stack traces in Go with x/xerror by OJFord on Monday August 23, 2021 @09:22PM (#28284102)
That's true, it's a while since I did only a little bit of Haskell, but yes. I suppose I didn't think of it because it feels less like 'having to handle' it in Haskell, since that's the norm anyway.

Whereas if you compare Rust to Python, C(++), or Go as I was - having to consume a returned 'result' is more notable.