golangci-lint VS gopl.io

Things I can't live without in a new Go project in no particular order:

- https://github.com/golangci/golangci-lint - meta-linter

- https://goreleaser.com - automate release workflows

- https://magefile.org - build tool that can version your tools

- https://github.com/ory/dockertest/v3 - run containers for e2e testing

- https://github.com/ecordell/optgen - generate functional options

- https://golang.org/x/tools/cmd/stringer - generate String()

- https://mvdan.cc/gofumpt - stricter gofmt

- https://github.com/stretchr/testify - test assertion library

- https://github.com/rs/zerolog - logging

- https://github.com/spf13/cobra - CLI framework

FWIW, I just lifted all the tools we use for https://github.com/authzed/spicedb

We've also written some custom linters that might be useful for other folks: https://github.com/authzed/spicedb/tree/main/tools/analyzers

Hey, I try to figure out an elegant way to integrate golangci into a Go project.

All of this is nitpicking really, but I would suggest using linters, e.g. https://github.com/golangci/golangci-lint - sometimes annoying, but mostly just helps to avoid discussions like this (and plethora of bugs).

You should always use golangci-lint, which includes errcheck.

golangci lint - https://golangci-lint.run/

Code inspection golangci-lint

I disagree with at least half of your post, tooling in Go is amazing overall and there is one linter that pretty much every one is using: https://github.com/golangci/golangci-lint

What part(s) are you struggling with and how are you learning? The Go Programming Language is slightly outdated but is an excellent intro. You can read the first chapter free. Also the resources on https://go.dev/learn/ are great. If I were you, I would come up with an idea you're excited about and build it.

"Low-level programming" is chapter 13, both in the version I have and on https://www.gopl.io/ -- the rest is all somewhat crucial stuff, except for maybe reflection.

What makes this book amazing is the amount of code you go through. I won't take me as an example as I am only in the middle of the book, but if you check the amount of CLOC in the examples and in the exercises you get 20K Lines of Code (https://github.com/adonovan/gopl.io, https://github.com/torbiak/gopl). That is a lot.

> I don't understand the "spiritual successor" part: Go intentionally broke ABI compatibility with the C world and intentionally does a lot of very un-C-like things: a large standard library, a GC'd runtime, a compiler toolchain that reimplements the "standard" toolchain, etc.

Could you explain "broke ABI compatibility with [...] C"? Do you mean broke compatibility with platforms' de facto C ABIs?

"Go bears a surface similarity to C and, like C, is a tool for professional programmers, achieving maximum effect with minimum means. But it is much more than an updated version of C."

- Preface of "The Go Programming Language"[1][2]

[1]: https://www.gopl.io

[2]: https://www.gopl.io/ch1.pdf

The Go Programming Language has two excellent chapters on concurrency with examples that steadily grow in complexity. It's not free, but it's well worth the price IMO as it contains useful information for all features of the language. I referenced it constantly for the first year I wrote Go.

Hi! You can learn about interfaces in the very nice book The Go Programming Language

I've been picking this up for work while reading "The Go Programming Language" (https://www.gopl.io/). I like using a book over picking small projects and repeatedly googling things because the book gives a lot of context. I know _how_ all the pieces fit together and am given credible recommendations on what to use and why. It's a slow way to learn "how to use X data structure", but a great way to know "how X data structure works under the hood and why/when that's important".

The language itself is neat. Obviously very fast. Ergonomically sort of clunky (as compared to other languages, like TS or Python), but I think that'll smooth over with time. It also makes "hard things" in other languages simple, especially its threading and inter-thread communication.

The Go Programming Language (http://www.gopl.io/), is my favorite book.

https://www.gopl.io/ It was written by one of the developers of the language. Most people recommend this as the first book to read. I'm new to Go too, I'll start with this.