To avoid "this `nix-env -u` is taking a long time, I wonder if it is doing anything", add the -v switch to turn on verbose output. Then turn away and just glance every now and then to see what .nix file it is currently working on.
Still long, but you will have a better sense of "it is working" than before.
Sadly, the latest preliminary release of PureDarwin and the PureDarwin Nano distribution (just drops into a shell) are for macOS 9.
I wonder how much work it would be to bring a nano system up-to-date. There isn't *that much* in there, and Nix/macOS is just a few bits short of an OS as it is.
Wow, styx the SSG is really all implemented in #nix. It runs asciidoctor or multimarkdown for the markup->html conversion, but that data ends up in nix strings and the application of templates and everything is all nix.
The functions and their documentation are handled beautifully, and I learned many perverted usages of nix from browsing for just a few minutes.
It's really nice when developing to have your deps pinned and not have to rebuild the world because you bumped your user profile. Also, you don't want any build errors to be able to come from some package other than what you're developing. So the post describes how to do the equivalent of your lock file in node, ruby or python, but with nix.
But to follow best practice and make your default.nix a function with default parameters, instead of doing everything in local variables with let, just use let for the bootstrap mechanism, like this:
Hallå Kitteh (clacke@social.heldscal.la)'s status on Tuesday, 20-Feb-2018 18:57:12 UTC
Hallå Kittehtfw you look at that s-expression and it's finally just the way you intended it to be, and your eyes water in joy, your shoulders that you didn't know were tense sink back down in relief, and your heart swells with gratitude to the thousands of people who unwittingly made it possibly for you to achieve this.
> I created an overlay which mimic rustup behaviour, and allow you to spawn a nix-shell with the latest nightly, beta, or stable version of rustc & cargo.
> To use this overlay, checkout nixpkgs-mozilla [1], and create a symbolic link to the file rust-overlay.nix [2] in the ~/.config/nixpkgs/overlays
Ok, so whenever you want to use a newer rust, you just git pull this thing and ...
> This overlay should auto-update it-self as if you were running rustup each time you go through the rustChannels attributes. It works by using the fetchurl builtin function to pull the same file as rustup do through https.
One thing that I want to see more of in the future is what e.g. #rust is doing:
Find the things that depend on your thing -- in their case every single crate published -- and treat them all as integration tests for your API.
#nix and #guix make this easier. I just discovered the brilliant #nox tool, where you can do `nox-review wip` on e.g. a bumped dependency and build and test every dependee.
Imagine if every project did this before releasing their point release! (and at the same time imagine that the dependees have decent tests, of course, otherwise you're just detecting whether you broke API signatures, and that's trivial to do without looking at any code except your own)
"Hmm, there seems to be no way for fetchgit to use a subdirectory of a tree. But hey, fetchgit is just a derivation, right? How about I just wrap this in another derivation with an installPhase = 'cp -a thething $out'."
@taiz tfw you're on #nix or #guix so you never truly installed those things and they just go away in the next gc, instead of you having to disentangle what the things were and what things they pulled in with them.
@cwebber @azure Provisionally my ideal is #guix / #nix that is also used for intra-package dependencies, so that the daemon becomes a fine-grained compiler cache, and also that the system is modified to be able to produce non-store-y binaries for general consumption.
Are you aware that the packaging and isolation system you are describing is almost exactly https://gnu.org/s/guix/ and https://nixos.org/nix/ and that they have 13 years of history thinking about and solving adjacent problems?