golangci-lint

I’ve been able to run golangci-lint locally just fine. However I’ve not had much success running it on CI, with at least the 1.27rcs. I encountered some panic deep within staticcheck, and ended up turning off that specific linter on CI (better than not running it at all). There was a tracking issue for go1.27 support at [1]. However that is now closed, which might imply that it should be working. [1] https://github.com/golangci/golangci-lint/issues/6643

I like the way that golang supports the use of tools in the go.mod file. Something like: go get -tool github.com/golangci/golangci-lint/cmd/golangci-lint@v1.64.4 And then you can list tools : go list -f '{{.Tool}}' all ANd run them: go tool staticcheck ./...

Things that are not simple about go tooling - Comments as directives[0]. Nobody finds this intuitive. I've never met anyone that saw what directives were doing and thought to change a comment. - Comments as commands for the compiler[1] - The state of go linting[2]. There are 30 different formatting tools that all frequently conflict with each other. It got so complicated that one project exists to manage installations of all the other ones (golangci-lint). Only difficulty is that most IDEs use gofmt and if your golangci-lint uses a different gofmt version than your IDE, you end up getting different formatting when you save vs. when you commit. This is only a problem because golangci-lint can't be installed using the go toolchain[3], so you can't just have dependency resolution solve this for you. I can go on [0] - https://groups.google.co

A simpler approach is to use `go run` with a specific version. e.g.: go run github.com/golangci/golangci-lint/cmd/golangci-lint@v1.63.4 run Easy enough to stuff in a Makefile or whatever. Even better in Go 1.24 since according to this article the invocations of go run will also be cached (rather than just utilizing the compilation cache.) So there shouldn't be much of an advantage to pre-emptively installing binaries anymore versus just go running them.

One of the checkers in golangci-lint does this. I forget which one. golangci-lint rolls up lot of linters and checkers into a single binary. There is a config file too. https://github.com/golangci/golangci-lint

This is such an infuriating problem. I'm convinced I'm using Go wrong, because I simply can't understand how this doesn't make it a toy language. Why the $expletive am I wasting 20-30 and more minutes per week of my life looking for the source of an error!? Have you seen https://github.com/tomarrell/wrapcheck? It's a linter than does a fairly good job of warning when an error originates from an external package but hasn't been wrapped in your codebase to make it unique or stacktraced. It comes with https://github.com/golangci/golangci-lint and can even be made part of your in-editor LSP diagnostics. But still, it's not perfect. And so I remain convinced that I'm misunderstanding something fundamental about the language because not being able to consistently find the source of an error is such an egregious failing for a programming languag

Note that without the `Output:` line you can silently not be running these tests - https://github.com/golangci/golangci-lint/issues/3084 covers when this can be problematic and there's now a golangci-lint integrated linter for catching it

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://godoc.org/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/t

Glad I could help! In general, I recommend using golangci-lint[0], which aggregates a ton of useful linters like this one. [0]: https://github.com/golangci/golangci-lint

Use golangci-lint (https://golangci-lint.run, https://github.com/golangci/golangci-lint) which combines all of the best lints (including staticcheck).

Looks like fixes for golangci-lint just got merged and should be in the next release: https://github.com/golangci/golangci-lint/pull/2991

There are tools for Go that detect non-optimal struct alignment. I use golangci-lint, available at: https://github.com/golangci/golangci-lint The struct alignment linter is not included by default. To enable it, run the linter with this command: golangci-lint run --enable maligned

> Able to have the confidence that we're checking for every situation that could occur on an enum type across the codebase is one less thing I need to worry about. golangci-lint (https://github.com/golangci/golangci-lint) is an absolute must, and includes https://github.com/nishanths/exhaustive which will check this for you.

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

https://github.com/mibk/dupl does a great job, and it's included in https://github.com/golangci/golangci-lint (which everyone should use, tbh)