[muxator]

I really wish Guix and NixOS had more usage in the industry.

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.

[rekado]

Guix is used as a package manager in HPC environments in order to deploy reproducible software environments. There's a dedicated Guix HPC project: https://guix-hpc.bordeaux.inria.fr/

[thomastjeffery]

There are still, unfortunately, some rough edges with Nix.

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.

[agumonkey]

Out of curiosity, were you already knowledgeable about lisp/scheme/fp before using nix ?

[thomastjeffery]

Yes.

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.

[rekado]

In Guix package definitions are first-class values. They are arranged in Guile modules so they don't pollute a single namespace (though usually packages have unique names anyway). With standard Guile features one can uniquely specify variables that may have the same name.

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. "samtools@0.1".

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.

[agumonkey]

I see, lots of work to be done. My question was mostly about the derivation idea (much like a lambda) that would be confusing for people not used to this style.

Also, this popped on twitter https://github.com/Gabriel439/slides/blob/master/nix-interna...

[thomastjeffery]

The derivation idea isn't too difficult to understand, because it is rather elegant.

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.

[greenhouse_gas]

The problem is that _every_ _single_ _program_ has to have its configuration files rewritten to take nix or guix into account, and every sysadmin has to know how to use the new nix or guix way.

[nextos]

I don't think this is the case. I've packaged several things for Guix, and patches are rare. Stuff that has good configuration (e.g. uses GNU make, and thus accepts --prefix) will be fine.

[greenhouse_gas]

Wait, I thought that guix (like nix) keep their full configuration in flat nix or lisp files (like https://www.gnu.org/software/guix/manual/html_node/Using-the... )?

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?

[nextos]

It depends. You can install it with nix/guix and configure it as in any other Linux distro.

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.

[hd4]

What would boost uptake is for just one of the major distros, especially Ubuntu, to release a spin/variant based off either.

[nextos]

There are some deployments in the industry already. AFAIK, Logicblox employs Nix creator.

Both Nix & Guix are past proof-of-concept stage. In particular, I've found Guix very elegant, simple and useful.