I feel like setting up a new machine is just the easiest to explain.

Personally, I find dotfiles messy, as you often just want to change one or two settings, but you always carry along the whole file with all kinds of irrelevant other settings. This also makes it impractical to diff two versions of those dotfiles, especially when programs write semi-permanent settings into there.

I guess, your mileage will vary depending on what programs or desktop environment you use.
For example, I love KDE, but they really don't do a good job keeping the config files clean. Nix Plasma-Manager generally fixes that, and for example allows defining the contents of the panel in a readable form.

I've used nixos exclusively lately. It's been awesome. No system scatter, clutter. It'd immutable. There's very slight driver hassle (you don't have GUI for drivers so a simple terminal command fetches everything you need.) in cinnamon. I came from mint. I have all basic commands in executable files on desktop for ease of hassle. It's not about rebuilding the system. Its about being hands off. Next to zero maintenance because not much in your system gets altered. I went for a full custom install from terminal. The only thing I personally miss being GUI is a firewall like UFW or GUFW.

Overall its more rock solid and workable than likely every distro I have ever tried. The feature set is nice, easy rollbacks, fucking cake backups. All you have to know is your entire system lives on one small editable file called nix. Configuration. Keep it in a micro SD or USB or any backup and it's as if you never left. Any changes you want you simply tweak in the config then reboot. If it breaks then select your previous gen number on boot and your exactly where you was before.

I diff my edits and keep copies, run auto backups, and more. It's so hands off that I haven't found a better replacement yet. My single biggest concern is long-term viability in the project.

This is a good example of what people consistently overlook/misunderstand, when it comes to Nix.

Obviously you can remount a /home, or just pull the dotfiles from a personal repo, but the strength of Nix is also in that I can re-create my entire config exactly how it is defined. If i were to setup a machine completely from scratch, with a mature enough config, it will get me from 0 to my exact desktop completely unattended.

But there are also many more advantages to it, at least in my eyes. Let's take trying/tweaking new packages as an example. Yesterday I pulled an old repo for an Outer Wilds mod. The thing needs a dev environment, and a mod manager for the actual game. A nix shell got me both, I finished my work, and when I exit out of fish, both are gone, just as I wanted them to be.

Another good example would be partial os updates. I've used Arch for almost 9 years before switching to Nix, and pretty much a top3 Arch rule is not doing partial updates, or partial rollbacks. In case of a breakage, I would have to manually redownload an older version of a tarball, pacman -U the package, and then hope i'm not cooked. In the case of gcc incompatibilities, it can quickly become a massive pain in the ass. My nix flake would never experience this problem, because I already have two different scenarios available - either i build based on an older lockfile from my git repo, or I create an overlay for a specific input I need, so that it still pulls what it needs, and doesn't interfere with the rest of my system

One of my machines i've been just upgrading in place since debian 8. No need for new installation

Debian isn't barbaric at all.

I absolutely hate the language

Check out Guix_System_Distribution, it's just like NixOS but uses a Scheme dialect which is a better language.

But points to Nix for being less awful than JSON (the comma on every line but not the last thingy make me want to build a time machine to go murder the grandparents of whoever thought it was a good idea)

en.wikipedia.org/wiki/Douglas_…

American computer programmer

^{Contributors to Wikimedia projects (Wikimedia Foundation, Inc.)}

Packages are out of date even in the unstable branch (I know it’s unfair since it’s not trying to be a rolling release… but… but…)

Sure, some packages are outdated. But in terms of percentage of up-to-date packages, it's (AFAIK) the best out of any distro repo. And that's perhaps even more impressive of a feat when realizing it also sports the biggest repo. For actual stats: repology.org/repositories/stat…

Where are the source packages?

It's reproducible, so random updates are a no-no. You can however just dump the Git URL in your flake.nix inputs and then override the src of the package with that. The source gets updated when you do nix flake update next time. Something like this:

inputs {
    ...
    mypackage_src.url = "github:myorg/mypackage";
    mypackage_src.flake = false;
    ...
}

pkgs.mypackage.overrideAttrs (oldAttrs: {
              src = mypackage_src;
              version = "nightly-${mypackage_src.shortRev or "src"}";
            })

Finally managed to enable VSCode extensions without doing it imperatively or using home manager I'm so happy I could cry 😭 😭 😭

It actually wasn't even that bad, I'm just terrible at understanding documentation I guess

    (vscode-with-extensions.override {
        vscodeExtensions = with vscode-extensions; [
            bodil.blueprint-gtk          # Gtk Bluprint language support
            ms-vscode.makefile-tools     # Makefile language support
            bbenoist.nix                 # Nix language support
            ms-python.python             # Python language support
            naumovs.color-highlight      # Color Highlight
            ms-azuretools.vscode-docker  # Docker
            donjayamanne.githistory      # Git History
            seatonjiang.gitmoji-vscode   # Gitmoji
        ];
    })

Think about it like this:

• with ansible, you are responsible for making sure that executing the described steps in the described order leads to the desired result
• with nix, you describe what you want your system to look like, and then figuring out how to get there is nix's problem (or rather, is obvious to nix thanks to nixpkgs)

This command will just run an executable file on nix. Normally only executables which are installed from the package manager will work.

appimage-run is another option. Which can be used to run, you guessed it, appimages

There are a few gnarly things about Nix, even for someone who's familiar with Haskell (the most similar language to Nix that's even close to mainstream).

• Dynamic typing (you mention this briefly). Some people like the extra flexibility that dynamic typing gives, but there's a tradeoff: more errors. The thing is, due to NixOS's complicated structure, the traceback for an evaluation error might not give you any information about where the cause is (indeed, the traceback might not include a single line of your own code!). This makes errors unusually costly in NixOS specifically, so any language feature that causes more runtime errors automatically has a worse impact than it would in a more "normal" language.
• The "standard library" (builtins) is extremely sparse. You basically have to depend on at least nixpkgs-lib if you want to get any real work done.
• No real data abstraction mechanisms. No ADTs, no nominal types. The only composite types are attrsets and lists. The usual way to encode a custom type is as an attrset with a _type field or some such.
• While we're at it, very limited pattern-matching.
• Clunky list literal syntax: no commas between list elements. I can't tell you the number of times I've forgotten to surround list elements in parentheses.
• Can anyone remember the rules for escaping ${ or ''? I have to look them up every time.

Using a language server like nixd also helps a lot with auto completing packages and options in your config.

Apparently people are also working on the nickel configuration language to address some of the nix limitations and difficulties.