Go: building on the shoulders of giants and stepping on a few toes [video] (opens in new tab)

(youtube.com)

87 pointsdavecheney7y ago23 comments

23 comments

It is interesting that neither the talk nor the questions from the audience rise the question of the error handling.

In Go returning an error implies that the caller will need to add 3 lines of the source for each call to propagate the error. This is really ugly. Rust managed to reduce that source overhead down to the single extra ? character while keeping all the benefits of explicit error handling. I wish Go gets something similar.

tomcam7y ago

In my experience creating robust, usable code that responds properly to adverse conditions always requires tons of error handling. The closer to the problem you deal with it the more accurate your diagnostics can be. Otherwise it becomes very difficult to provide meaningful feedback to the user.

stouset7y ago

Nothing in your comment counters the GP’s statement that Rust manages to accomplish this with a single character, simultaneously avoiding needlessly obscuring the happy path and without the downsides of non-local error handling.

everdev7y ago

This is a huge complaint of those new to Go and touted as a benefit from those who still use it.

Being explicit is a double edge sword. It requires more typing, but there's also no don't about what the code is doing.

gregwebs7y ago

The question mark in Rust is equally explicit in the case where it can be used to simply pass the error along.

1 more reply

zephyrfalcon7y ago

"Explicit" doesn't necessarily have to mean "verbose", though.

1 more reply

kybernetikos7y ago

As far as I'm concerned 'explicit' just means that the behaviour under discussion is caused by some piece of source that talks about that behaviour and not something else.

Whether the bit of source is a single character or a paragraph of prose is about verbosity rather than explicitness as long as the behaviour under discussion is caused by a piece of source with precisely that purpose.

sacado27y ago

I don't know, most of the time, I add information to the error before propagating it:

    if f, err := os.Open(path); err != nil {
        return nil, fmt.Errorf("could not open path: %v", err)
    }

This is the vast majority of my error management code in go. Is rust less verbose in this regard? AFAIK, the question mark operator is equivalent to `if err != nil { return nil, err }`.

steveklabnik7y ago

If you want to transform the error on it, you can either:

1. Define a conversion between the two errors that adds the context.

2. Use .map_err() at the callsite to do the transformation there.

1 more reply

mseepgood7y ago

Intersting talk. Here are some other talks about the history and origins of Go:

Evolution of Go (Griesemer, GopherCon 2015)

Video: https://www.youtube.com/watch?v=0ReKdcpNyQg

Slides: https://talks.golang.org/2015/gophercon-goevolution.slide

Origins of Go Concurrency (Rob Pike, OSCON 2010)

Video: https://www.youtube.com/watch?v=3DtUzH3zoFo

Slides: http://go-lang.cat-v.org/talks/slides/emerging-languages-cam...

Davesjoshin7y ago

Presenter has a great sense of humor. For someone who hadn't known much about GO, this was a great overview. Thanks

geoka97y ago

Obligatory, the take on generics: https://www.youtube.com/watch?v=sX8r6zATHGU&t=50m29s

pjmlp7y ago

The usual hand waving answer, "we are thinking about it until the perfect design falls from the sky", nothing new.

j / k navigate · click thread line to collapse

23 comments

_0w8t7y ago

It is interesting that neither the talk nor the questions from the audience rise the question of the error handling.

tomcam7y ago

stouset7y ago

everdev7y ago

This is a huge complaint of those new to Go and touted as a benefit from those who still use it.

Being explicit is a double edge sword. It requires more typing, but there's also no don't about what the code is doing.

gregwebs7y ago

The question mark in Rust is equally explicit in the case where it can be used to simply pass the error along.

1 more reply

zephyrfalcon7y ago

"Explicit" doesn't necessarily have to mean "verbose", though.

1 more reply

kybernetikos7y ago

As far as I'm concerned 'explicit' just means that the behaviour under discussion is caused by some piece of source that talks about that behaviour and not something else.

sacado27y ago

I don't know, most of the time, I add information to the error before propagating it:

    if f, err := os.Open(path); err != nil {
        return nil, fmt.Errorf("could not open path: %v", err)
    }

This is the vast majority of my error management code in go. Is rust less verbose in this regard? AFAIK, the question mark operator is equivalent to `if err != nil { return nil, err }`.

steveklabnik7y ago

If you want to transform the error on it, you can either:

1. Define a conversion between the two errors that adds the context.

2. Use .map_err() at the callsite to do the transformation there.

1 more reply

mseepgood7y ago

Intersting talk. Here are some other talks about the history and origins of Go:

Evolution of Go (Griesemer, GopherCon 2015)

Video: https://www.youtube.com/watch?v=0ReKdcpNyQg

Slides: https://talks.golang.org/2015/gophercon-goevolution.slide

Origins of Go Concurrency (Rob Pike, OSCON 2010)

Video: https://www.youtube.com/watch?v=3DtUzH3zoFo