I am not sure if these are the projects that are going to drive the innovation, if they are only showing the way for the 2nd-generation functional package managers, or if this will just remain a niche forever.
Nix does not use versions for packages, instead relying on channels and pinning, which can be confusing at best.
There is a manual, but not a good wiki. While you can learn to read the syntax, there isn't any good introduction to write it. Nix derivations are very unique, and difficult to approach without examples and guidance.
It's not the functional nature of Nix that is hard to deal with. Nix's functional nature is actually its saving grace.
My difficulty with Nix is that there are important subjects that aren't taught.
I figured out how to create a usable `default.nix` and `shell.nix`, but that takes a lot of effort, and there really aren't many resources to reference.
Nix expressions use a lot of predefined functions, and I have no idea where their documentation exists, if it does at all.
Even if there is some explanation for all of the functions that I need to use, there isn't documentation for how to fit them together.
Instead of being in dependency hell on the outset (like most package managers), I find myself in dependency hell when I want to do something different. The Nix community has an irrational hatred of version numbers, meaning you have to scour the web for a derivation that gets the right version of a dependency, and "pin" it, or hope that the channel you are using has the correct version. Even when channels do have the version you want, sometimes that channel provides multiple package versions, some with the version in the name.
Names are a mess. Since every package must exist in the same namespace, but its derivation is helpfully sorted into a directory tree, the same packages will often have different names. There isn't a good way to search or browse for them either. I end up digging through github quite often, which is a lot more often than the never that I should find myself doing so.
Nix is wonderful. NixOS is by far my favorite OS, and that is why I deal with all of the rough edges, but they certainly are rough.
Package definitions can often be generated automatically with importers. For example, `guix import cran -r recipes` creates package definitions for the recipes package and all its R dependencies. They usually work with minimal adjustments.
Jumping to package definitions is easy thanks to REPL support (e.g. with Emacs + Geiser), but you can also use `guix edit name` and it will spawn an editor to edit the package "name".
Creating variants of packages is trivial as package definitions can inherit from existing definitions. I maintain a bunch of different versions for bioinformatics tools. I can select them on the command line simply by appending the version string, e.g. "firstname.lastname@example.org".
Guix has a comprehensive manual with a procedure and variable reference and examples.
I really like Guix and GuixSD because of how consistent and hackable it is.
Also, this popped on twitter https://github.com/Gabriel439/slides/blob/master/nix-interna...
The problem with derivations is that they are like a library without a reference
The functions that are to be used in derivations aren't documented clearly, at all, or in an obvious place.
I never really tried guix, but that's how nix works ( https://nixos.org/nixos/manual/index.html ). So how does Apache configuration on upstream (meaning, how it's configured on Windows/Linux/FreeBSD) correlate to how it's configured on nixos/guix?
Or, if it's a service you want to make the configuration totally reproducible, you can use https://www.gnu.org/software/guix/manual/html_node/Services.... interfaces for those packages that have some written for them.
But there's nothing wrong with regular dotfiles.
Both Nix & Guix are past proof-of-concept stage. In particular, I've found Guix very elegant, simple and useful.
It's an attempt to bring the functional system paradigm to Arch linux, giving you the "my system is a function of my configuration" approach combined with not having to relearn how to administer a linux system like GuixSD and NixOS require.
What is the benefit of directly using Scheme for the package declarations over using NixOS's DSL? Specifically, what technical features does Scheme make possible which are not possible in NixOS?
Integration of all stages. We use the same language on the build side as on the host side; the same language to execute builds as to define packages. In Guix there is no mix of languages, so we don't need to glue strings together produce build-side shell scripts. Instead we can use higher-level S-expressions and code staging.
For more on code staging see this paper:
Another result is that all these package definitions form a lazy graph of live Scheme values. In Nix you have a large hash table of identifiers to functions. Think code vs data. In Guix the primary data structure is an emergent lazy graph; it is not merely an inert description of such a graph. Each package definition is just another Scheme value.
Nix's Firefox: https://github.com/NixOS/nixpkgs/blob/master/pkgs/applicatio...
Guix IceCat: https://git.savannah.gnu.org/cgit/guix.git/tree/gnu/packages...
The site should be more direct about whether or not it is Linux.
I don't have time to wade through reams of words to work out what something is. Just tell me.
It's not clear at all why this matters or is better than other operating systems. If this is a competitor to Linux then the first thing they need to address is "why should you care?", if it is Linux, then the first thing it should adress is "Why you should use this over other distros"
I'm guessing if the word "Hurd" doesn't appear anywhere on the page, it's still Linux.
"GuixSD is a distribution of the GNU operating system centered on the GNU Guix package manager. It uses the Linux-libre kernel, and support for the Hurd is being worked on."