Hacker News Reader

Comment by dinofp | Hacker News Reader

Uh huh. Nothing in this article makes me want to go anywhere near Nix again.

Same here. I switched to Guix and never looked back.

Although Guix reads better than Nix (after all, it's Lisp), I found the support and resources available for learning severely lacking.

Plus, you have to jump through hoops to install non-free software, which goes against the ethos of Guix anyway.

IMHO, Nix is clearly "the winner" here and we'll see more and more adoption as it improves. Lots of folks are doing exciting work (see https://determinate.systems/, https://devenv.sh/, https://flakehub.com/). And the scale and organization around nixpkgs is damn impressive.

A distro not wanting to maintain closed source software packages seems reasonable

Anyone can create their packages channel or import existing

Also Interesting that you can now install Guix in Nix, or Nix in Guix, or both in any other distro

So you can easily install any package from Nix

There is a lot of work but flakes are still too confusing

So winning is relative

You found support and documentation lacking? How so? The #guix and #nonguix channels are full of helpful people, and unlike Nix, it has a centralized, comprehensive handbook that covers about everything. Finding Nix documentation was a horrible experience in comparison. Yes, there are more Nix than Guix packages, but that hardly matters to me due to how easy it is to create packages for Guix. Devenv seems more or less like direnv?

Devenv includes direnv integration, but the main feature is organizing development environment configurations using a NixOS-like module system rather than declaring them as packages (simple functions).

Guix (deliberately) doesn't support anything like the NixOS module semantics. 'Services' are its alternative, of course. I don't know if there is a capability for per-project service declaration in Guix atm, but it wouldn't surprise me!

That's your loss, and not our problem.

It's both.

Nix is fantastic. I'm writing this comment on a laptop that has only ever run NixOS.

Nix is also painful to learn. It's painful to use.

That doesn't mean it's impossible, or even that it isn't worth it.

It means that Nix has room to improve.

This mixed bag makes it hard to decide whether one should learn it. How much value do you get out of it? What are its best use cases?

My OS is always a fresh install.

Everything I did to alter and configure my OS is self-contained and self-documented in one file.

I can try anything without ever risking the stability of my system. If it breaks, I just reboot, and pick the second most recent GRUB entry.

If I ever want to change my root filesystem or move to a new disk, I can do the whole reinstall in a few short obvious steps.

I can keep my laptop and my desktop configurations identical. If I want a few things to be different, they can go in a separate config file.

The trickiest part is running software that isn't already packaged. It's usually not too hard, though: there are a few nix features that construct a more traditional/compatible environment, like steam-run and nix-ld. The biggest problem is that their existence isn't obvious to new users. They should really go near the top of the manual.

I wonder lately whether the pain is really the primary issue.

As I've gotten deeper into using Terraform at work, I've found it much, much more painful than Nix— so much so that it has me questioning whether I want to continue to work with cloud infrastructure at all. Yet Terraform is 'industry standard' and widely praised, where Nix is marginal and maligned for its difficulty.

Maybe it's because people think of NixOS more than Nix in all its broad uses, and when they do so they compare NixOS to desktop operating systems where those people don't see themselves as very interested in configuration management.

But I wish that many industry standard tools had comparable iteration times to Nix, or concise languages like Nix, reliable transitions between configurations like Nix, efficient caching like Nix, minimally destructive replacement of old resources like Nix, etc.

Most of the things people call 'immutable infrastructure' today are painfully slow and transparently mutable. I'm much happier when I'm reliably iterating on local Nix stuff than when I'm praying that `terraform plan`'s success isn't a fluke this time, and that the corresponding `terraform apply` will actually succeed. I'd rather spend an hour on the the thorniest Nix issues than spend 30 minutes fucking around trying to 'help' Terraform delete a resource that requires manual intervention to actually delete, for some godforsaken reason.

I was thinking the other day that the power of things like docker or systemd is in recognizing that there is utility in "spawn something in a hermetic environment" for different shades of environment, and Nix would absolutely slot in the hierarchy as an environment with specified build configurations... which is something that absolutely should be a killer, widely used tool like, well, docker files are.

That it's not indicates that there is a reason why it's not, and I don't think it's because of a lack of demand. Rather, I think there's something about Nix that causes people to bounce off it hard, and if people want Nix to be more widely used, then it absolutely is a problem that aficionados of Nix need to look at and address.

I agree. Nix is awesome in a way, but it's also a product of it's time (early/mid 2000s). It definitely solved the problem of reproducible build environments, but it didn't solve isolated environments like docker did. It also has an issue where there are soany ways to do things, it's hard to know what the best way is for your situation (especially between flakes and nonflakes).

But I'd say the biggest issue with Nix in general is it's lack of discoverability. This is evidenced in the number of third-party tools built around helping figure out what even exists (noogle.dev and search.nixos.org for example). The language is so dynamic, trying to figure out where things are coming from becomes difficult. Simply put, there's too much magic.

Nix also has a tendency to drop down into massive bash scripts to actually do stuff. I really like guix as an alternative in theory, but I haven't had much luck using it yet.

"Environment with specified build configurations" is a fractal rabbit hole that unpacks into a myriad of recursive problems.

There is no turnkey solution for this, but there is a way out and a way to (eventually) tame the complexity.

Yes. I switched from Ubuntu to NixOS ~18 months ago. I am so much happier with NixOS than ubuntu. Its the easiest packaging system I've used where you can easily mix and match stable and unstable packages without worrying about a huge mess of dependencies. I also find myself much more empowered to upgrade packages for security patches myself since I know that I can add an overlay to update the package and everything will just build.

And yet... there's so much I just don't understand. Doing simple overlays is relatively easy, but anything of moderate complexity really becomes frustrating.

It makes it quite difficult to recommend NixOS when the chasm between being able to use it vs being able to understand it is so wide.

Reply on news.ycombinator.com