Go subtleties

If you think Go and C are that similar then you don't know either.

Go and C have partially shared origins. Two of the three creators of Go (Ken Thompson and Rob Pike) were involved in the early days of C. Ken Thompson is even the creator of B, the predecessor of C. There are obvious huge differences between the language but in a more subtle way they're actually quite similar: C is an "unergonomically simplistic language", just as the parent commenter describes Go.

They are similar in the sense that there are very few abstractions, relying on the programmer to reimplement common patterns and avoid logical mistakes.

You have to put thought into such things as:

- Did I add explicit checks for all the errors my function calls might return?

- Are all of my resources (e.g. file handles) cleaned up properly in all scenarios? Or did I forget a "defer file.Close()"? (A language like C++ solved this problem with RAII in the 1980s)

- Does my Go channel spaghetti properly implement a worker pool system with the right semaphores and error handling?

> Did I add explicit checks for all the errors my function calls might return?

You can easily check this with a linter.

> Are all of my resources (e.g. file handles) cleaned up properly in all scenarios? Or did I forget a "defer file.Close()"? (A language like C++ solved this problem with RAII in the 1980s)

You can forget to use `with` in Python, I guess that's also C now too eh?

> Does my Go channel spaghetti properly implement a worker pool system with the right semaphores and error handling?

Then stop writing spaghetti and use a higher level abstraction like `x/sync/errgroup.Group`.

Pike was not involved with the design of C. He was involved with Newsqueak and Limbo which inspired Go's concurrency model.

>Did I add explicit checks for all the errors my function calls might return?

You can check anything with a linter, but it's better when the language disallows you from making the mistake in the first place.

>You can forget to use `with` in Python, I guess that's also C now too eh?

When using `with` in Python you don't have to think about what exactly needs to be cleaned up, and it'll happen automatically when there is any kind of error. Consider `http.Get` in Go:

resp, err := http.Get(url)

if err == nil { resp.Body.Close() }

return err

Here you need to specifically remember to call `resp.Body.Close` and in which case to call it. Needlessly complicated.

>Then stop writing spaghetti and use a higher level abstraction like `x/sync/errgroup.Group`.

Why is this not part of the standard library? And why does it not implement basic functionality like collecting results?

This seems like a judiciously designed API to me.

You don't need to check if err was nil before calling resp.Body.Close()

https://pkg.go.dev/net/http#Get

> When err is nil, resp always contains a non-nil resp.Body. Caller should close resp.Body when done reading from it.

https://pkg.go.dev/net/http#Response

> The http Client and Transport guarantee that Body is always non-nil, even on responses without a body or responses with a zero-length body. It is the caller's responsibility to close Body.

Calling http.Get() returns an object that symbolises the response. The response body itself might be multiple terabytes, so http.Get() shouldn't read it for you, but give you a Reader of some sort.

The question then is, when does the Reader get closed? The answer should be "when the caller is done with it". This can't be automatic handled when the resp object goes out of scope, as it would preclude the caller e.g. passing the response to another goroutine for handling, or putting it in an array, or similar.

Go tooling is more than happy to tell you that there's an io.ReadCloser in one of the structs returned to you, and it can see that you didn't Close() it, store it, or pass it to somewhere else, before the struct it was in went out of scope.