
GNU Guix and GuixSD 0.14.0 released - Ruud-v-A
https://www.gnu.org/software/guix/blog/2017/gnu-guix-and-guixsd-0.14.0-released/
======
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.

~~~
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.

~~~
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...](https://github.com/Gabriel439/slides/blob/master/nix-
internals/slides.md)

~~~
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.

------
shawndellysse
I guess I should use this time to shamelessly plug one of my side projects,
farch:
[https://github.com/shawndellysse/farch](https://github.com/shawndellysse/farch)

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.

------
jancsika
> Hackable. It provides Guile Scheme APIs, including high-level embedded
> domain-specific languages (EDSLs) to define packages and whole-system
> configurations.

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?

~~~
anon90556382956
I'm a complete beginner but, for example, comparing Nix's Firefox and Guix's
IceCat you can see that with Nix you have to fallback to shell scripting for
some tasks while with Guile you can perform those operations with Scheme.

Nix's Firefox:
[https://github.com/NixOS/nixpkgs/blob/master/pkgs/applicatio...](https://github.com/NixOS/nixpkgs/blob/master/pkgs/applications/networking/browsers/firefox-
bin/default.nix)

Guix IceCat:
[https://git.savannah.gnu.org/cgit/guix.git/tree/gnu/packages...](https://git.savannah.gnu.org/cgit/guix.git/tree/gnu/packages/gnuzilla.scm?id=v0.14.0-95-g5a2f019c7#n402)

~~~
bjoli
Are those really the same package definitions? The guix one contains build
instructions and the nix one is for binary packages.

~~~
anon90556382956
No they aren't. I was pointing to the fact that in Guile you don't need shell
scripting where you can use functions like 'mkdir', 'symlink', 'copy-file',
'file-system-tree', etc..., so you can use scheme with all the support Emacs,
Geiser and guix.el give you.

------
hoodoof
Is this Linux?

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"

~~~
girzel
They ought to have said Gnu/Linux, as per their own propaganda!

I'm guessing if the word "Hurd" doesn't appear anywhere on the page, it's
still Linux.

~~~
madez
Linux is just the kernel. GNU as a name for the system is okay, while Linux is
arguably not. GNU/Linux is just a compromise for those who insist on naming
Linux. Also, from the projects website, we have

"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."

[https://www.gnu.org/software/guix/about/](https://www.gnu.org/software/guix/about/)

