
Go: building on the shoulders of giants and stepping on a few toes [video] - davecheney
https://www.youtube.com/watch?v=sX8r6zATHGU
======
fpoling
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.

~~~
everdev
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.

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

~~~
steveklabnik
And in cases where you don’t, various combinators let you handle common
patterns more easily too.

You can also write it Go style if you prefer; we started off with exactly
that, then moved to a macro, then turned that macro into ?.

That all being said, none of that feels very Go-like, so it makes sense that
they haven’t followed what we did.

~~~
vram22
>You can also write it Go style if you prefer; we started off with exactly
that, then moved to a macro, then turned that macro into ?.

Interesting. Does the Rust book (you wrote), explain the difference between
the Go style and the current Rust style, and explain how to use the Rust style
(well)?

Asking because I've found this Some / None stuff (also there in other
languages like F#) a little tricky to understand (although I have not spent a
lot of time on it yet).

~~~
steveklabnik
We talk about it a little, but the best resource on this topic by far is
[https://blog.burntsushi.net/rust-error-
handling/](https://blog.burntsushi.net/rust-error-handling/) which works the
whole way from first principles. It was in the first edition of the book but
due to space requirements didn’t really fit in the second edition.

~~~
vram22
Thanks, will check that blog out.

~~~
steveklabnik
No problem! In general, burntsushi’s work is some of the best in Rust. He’s
also very fluent in Go.

~~~
vram22
Good to know, will check out his stuff in both languages, thanks.

------
mseepgood
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](https://www.youtube.com/watch?v=0ReKdcpNyQg)

Slides: [https://talks.golang.org/2015/gophercon-
goevolution.slide](https://talks.golang.org/2015/gophercon-goevolution.slide)

Origins of Go Concurrency (Rob Pike, OSCON 2010)

Video:
[https://www.youtube.com/watch?v=3DtUzH3zoFo](https://www.youtube.com/watch?v=3DtUzH3zoFo)

Slides: [http://go-lang.cat-v.org/talks/slides/emerging-languages-
cam...](http://go-lang.cat-v.org/talks/slides/emerging-languages-
camp-2010.pdf)

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

------
geoka9
Obligatory, the take on generics:
[https://www.youtube.com/watch?v=sX8r6zATHGU&t=50m29s](https://www.youtube.com/watch?v=sX8r6zATHGU&t=50m29s)

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

