dotfiles VS goreleaser

NixOS. If you still need Docker you can define and manage that via Nix too. I love it, both for this and managing development environments. Happy to answer any questions.

With Nix we have a shell.nix in the root of our repo describing all of the project's system dependencies. It looks something like this. You can pin nixpkgs with Flakes (think lockfiles) or by hardcoding a specific revision. We do the latter because I didn't want to complicate the Nix install for everyone by requiring they enable experimetnal features.

Nix, for example updating from rls to rust-analyzer.

I agree that the documentation story could be better. I also think it's a great shame that the language isn't statically-typed, so to understand how to use something I have to inspect its source code.

I've found it to be quite flexible though. For example, here's a commit in which I apply a patch to a tool to solve a problem that the derivation hadn't taken into account (and absent a home-manager solution): https://github.com/samhh/dotfiles/commit/867dd3b4d4b3942a0aa...

You may like to look at my newsboat config. It's biased towards FP and Linux.

Sure thing, I manage it in my dotfiles repo here.

I wonder if you'd have better luck if you built your xmonad as a proper Haskell app and didn't use the built-in --recompile stuff. It's not Nix, but see here an example of how I'm doing that.

Here's my config: https://github.com/samhh/dotfiles/blob/master/home/.config/git/config

This is possible for quickfix, see my dotfiles commit here.

> This is a much faster way than setting up Github Actions to build an executable for every possible platform on every release

It's not even that hard. Just use GoReleaser.

https://goreleaser.com/

I also got my eyes on GoReleaser, which I will use in my (Go) projects.

With "xq", I went even further and automated the release process using GoReleaser. To publish a new release, the only thing I need is to create and push the Git tag. The corresponding GitHub Action will trigger a release process, and GoReleaser prepares the binaries and changelog based on declared conventions. The result has a high level of predictability, and no manual work is required.

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

Goreleaser is nice. https://goreleaser.com/

I use goreleaser for packaging my binaries. I'm not currently doing RPM, but it does a lot of services and if you don't hunker down on a single solution, it might help with keeping your releases up to date/in sync.

There's some packaging issues, for example, we've always wanted to publish deb/rpm packages, but never got around to adding it to either promu or completely switching our build tooling over to GoReleaser.