[foopdoopfoop]

I don't know that much about Guix, other than "super-free Nix with scheme" (and the article wasn't particularly illuminating other than boiling down to "Guix isn't really ready for most users right now"), but it's neat that there's momentum in the declarative OS-space. I hope that both Guix and NixOS keep growing and that more people start switching.

After switching to NixOS, I'd find it very frustrating to go back to an OS with imperative-style package/service management. It's clearly the better way.

A frustrating thing about NixOS--coming from Arch Linux and being used to the AUR--is that adding packages/updating packages can be a bit slow due to the sheer volume of PRs/Issues on the nixpkgs repo. There's always the NUR[1] but it hasn't picked up that much momentum yet (probably because it's kind of hard to search the darn thing). Eitherway, the packages are just Nix expressions and repos are just collections of these expressions, so nothing's preventing a real AUR alternative other than momentum.

It's interesting that Guix uses scheme instead of a home-baked configuration language like NixOS. While I don't find Nix particularly offensive, I don't find it particularly great either. And maybe this is naivity/Nix-inexperience on my part speaking, but I really wish that Nix had a proper type system and was strictly typed.

I guess my pipe dream is "HaskellOS" that's basically NixOS configured with Haskell (just think of xmonad-style configuration for your whole OS). That'd be really nice. And my secondary-pipe dream is a baked in, extremely-comprehensive home-manager[2] so we can bid dotfiles goodbye once and for all and have your entire system-state defined in a single file.

Maybe one day :)

[1] https://github.com/nix-community/NUR

[2] https://github.com/rycee/home-manager

[_k9eq]

Hi, I wrote this text.

> and the article wasn't particularly illuminating other than boiling down to "..."

Yeah, I usually don't like writing these kinds of things. When reading about a distribution, especially a new and interesting one, one (or at least I) tend to forget what could go wrong. This text (I intentionally avoid using the word "article") is a reminder to stop, think and consider if one is up for the challenge. As in my case university just started last week, my conclusion was I didn't have the time.

> It's interesting that Guix uses scheme instead of a home-baked configuration language like NixOS.

I consider that to be one of Guix selling points. An established language, with many independent libraries make it a joy to work with (assuming a set up environment). From what I head, that's not really the case with Nix, although I understand the lure of a type system.

[T-R]

I'm hoping that maybe Flakes[1] will help ease the issue/pull request situation by letting some of the namespaces move out of the main repository.

[1] https://github.com/NixOS/rfcs/pull/49

[aseipp]

There are significant advantages to having the entire Nixpkgs package set in a mono repository. While I think Flakes are quite interesting for a number of reasons, I hope it doesn't result in the primary package set getting split up too much. They conceptually act a lot like Git submodules, and going overboard with that is a very easy way to make your life miserable, and significantly increase development turnaround for changes that "cross" package sets. A group of packages just being "conceptually related" isn't a high enough bar to move things out.

As a long time contributor, I'd much, much rather see our bug reporting, triage, and discovery/resolution strategies improve first -- long before going as far as splitting up the mono-repository. That's the part that's frustrating for users (their reports get lost, forgotten, duplicated) -- not the fact the default set merely has a lot of packages.

[adev_]

> There are significant advantages to having the entire Nixpkgs package set in a mono repository.

Yes there is many advantages to nixpkgs being a single repo. In fact, it is one of the main strength of Nix.

It gives you all the advantages of corporate style source monorepo without the inconvenience.

Out of order:

- It avoids the multi-version diamond dependency problem and the necessity of a SAT solver.

- It allows transactional upgrade of multiple packages.

- The detection of any break / problem of an update for any software depending on it automatically.

- A consistent view on the entire dependency tree at each instant. With possibility of rollbacks.

[takeda]

I think at very least (and easy to implement) nix needs a bot that closes old tickets. The number of open issues is ridiculous and basically it makes easier for an issue to be overlooked and further increase the count. The number of open issues also causes some people think nix is very buggy and not suitable in production or even exploring.

[aseipp]

There are probably some people who see a 3k bug report number and think that, but realistically tons of projects have thousands of open tickets for any number of things from legitimate bugs to duplicates to actual user questions. Linux, projects like LLVM, etc. It's natural when you have a project that is in active every-day use by literally thousands and thousands of people. Nixpkgs is simply a big project! But the actual numbers might tell another story.

For reference, the LLVM bug tracker has exactly ten thousand open bugs as of this writing, and I assume that number is only so perfectly rounded because Bugzilla search refuses to return any more results in a single page that already brings scrolling in Chrome to its knees. You won't find any lack of praise for LLVM's high quality and extensible nature, though -- they can all be true at once!

The nixpkgs label tracker isn't highly accurate since auto-labeling only started earlier as of this year, but as of this writing, of the 3k open issues, about 500 of them are directly marked as bugs, while 41 are marked as regressions. There are 200 enhancement requests, and 50 open packaging requests. So of 3,300 bugs, about 800 can be quickly classified, and about half of those are actual bugs. This is a very ballpark number (GitHub search doesn't allow XOR). Considering nixpkgs is literally shipping thousands of other software projects, I think this is pretty good -- even though I wouldn't argue it could be cleanly extrapolated to the whole set of bugs, because of a long tail of old bugs.

In terms of cadence, over the last month there were ~466 new PRs, and ~1,600 merged PRs. ~220 closed issues vs 215 new ones. This is done by nearly 350 contributors. I would think this is also very good and the sign of a healthy project with hundreds of active developers. IMO, if just a raw number of "3,000 open github issues" has to mean anything ("this software is unstable"), then these numbers have to mean something too. It's just that GitHub doesn't "helpfully" post them on every single page concerning your project...

But I do agree we should have better mechanisms for discovery and keeping things clean. Duplicates certainly happen and are annoying, and nobody likes drudging through 1,000 of the oldest open reports to close old stuff, etc. Some of this is also limited by GitHub and other things, unfortunately.

Personally as a developer (not a user!), I think bots that close old tickets are often very annoying (to everyone) and rarely do much other than feed a human desire to hit "inbox zero", but this desire is not (to my knowledge) based on any actual scientific criteria that leads to better software development or happier, better cared for users. It is more a way of externalizing a deep human desire for "cleanliness" and using it as a yardstick for "quality" rather than evaluating the numbers for yourself. You can also find tons of 0-issue repositories on GitHub, but this doesn't mean they're actually good, or they do what you want -- and I doubt most of them have as much momentum as we do.

[takeda]

There are, that was response from one of my colleague after mentioning Nix to him. Having 3k open bugs, don't help with anything there's no way all of them will ever be addressed and important ones could get lost between them.

I don't think closing such bugs is "feed a human desire to hit "inbox zero"" even with that you'll never get there. From my perspective it is all about not losing track of important issues. Having bots close tickets makes sure that only tickets are opened are ones that someone cares about. There are tickets that are from 2013, a lot changed since then, they might no longer be relevant anymore.

[MayeulC]

I personally hate it when a bot closes an issue I wrote. What's the point of closing unresolved issues? Just assign them a label (it could be a "stale" label like some projects do). Otherwise it just feels like hiding your mess under the bed. Other sorting tools can provide the same list as automatically closing bugs would achieve. The opposite isn't true, unless assigning a specific label when manually closing an issue.

[justinsaccount]

It's probably more similar to NixOps, but there is

https://propellor.branchable.com/

http://joeyh.name/blog/entry/unifying_OS_installation_and_co... kinda talks about this sort of thing

[edude03]

Well, there is this https://github.com/dhall-lang/dhall-haskell/tree/master/dhal...

[agumonkey]

In the tradition of name monad suffixing, it shall be called Sysmonad