No idea what "making NixOS compatible with other programming languages" is supposed to mean. On the face of it the phrase is, well, baffling. Would you care to elaborate?
This keeps getting asked and it's baffling to me. Any programming language can delay evaluation by wrapping values in thunks where that makes sense, so it seems odd to me to give so much importance to whether values are evaluated strictly or delayed by default.
Guix package definitions declare other package values as inputs, and evaluation of these inputs is in fact delayed.
Verbosity: in Guix we don't generally run shell snippets as part of a build; the build phases are compiled into a Guile builder script, so in the absence of helpful abstractions build phases do not generally have the conciseness of shell scripts. On the other hand abstractions are easily fashioned, so some things are more concise and clearer than the shell equivalent.
Indeed. I was simply asking whether the macros used for programming Guix are lazy, how is that baffling?
> This keeps getting asked and it's baffling to me. Any programming language can delay evaluation by wrapping values in thunks where that makes sense, so it seems odd to me to give so much importance to whether values are evaluated strictly or delayed by default.
At least in Haskell laziness increases composability.
I can't think of any examples in Nix, but maybe it's the same reason?
{ config, ... }:
{
systemd.services.foobar = {
enable = true;
serviceConfig.User = config.users.users.foobar.name;
# etc...
};
}
Of course, this is just a matter of preference. Like most Guix vs. Nix aspects, as far as I can tell.
In Guix System, services extend one another, forming a directed acyclic graph of extensions. When a service extends another service, that connection is explicitly declared, there's no surprise.
To see what it means in practice, check out the Explorer: https://notabug.org/civodul/guix-explorer
The service model in Guix looks pretty neat! I've long been thinking it would be nice to have a configuration system for NixOS that uses isolated components with a defined (type-safe) interface. The current modules are kind of that, except it all gets squashed down into a single nested attribute set, so it's not really isolated and (understandably) can be confusing. How does Guix System handle multiple services competing for the same global resource (port allocation, file in /etc, ...)?
There are other things that are detected statically and prevent you from instantiating a broken system: missing modules in the initrd, invalid file system label/UUID, references to non-existent Shepherd services, etc. All this is possible because there are well-defined data types and semantics for the different components of the system.
That sounds pretty good though, thanks! Maybe I'll try out Guix System some day.
That Nix can't tell what's a package and what's not is a hindrance for its user interface (e.g., it's hard to look up packages by name/version or to iterate over them) and for packagers (e.g., easy to end up with package definitions that don't follow the informal "schema").
(Note that Nix's laziness is not an unalloyed good either, for example it is notoriously difficult to debug. But let's limit ourselves to pure expressiveness for now)
As regards macros, Guile allows you to write your own macros in a pretty straight forward way that is just not the case in Nix
I do note that those Guix people that are feeling competitive towards Nix for whatever reason tend to over-rely on two arguments that just do not work too well when examined closely.
The first is "Nix is obscure the way Guile is not". I would argue both are equally obscure and neither is obscure enough for its quality or UX to suffer for it. And does expertise in Guile (base Scheme is trivial) carry over anywhere interesting?
The second is "Macros!", where the implied idea is that unrestricted syntactic extensibility is Good. Well, I like Lisp (more partial to CL then Scheme, but who cares at this resolution), and I find unrestricted syntactic extensibility to be more of a hazard than a benefit; plus the expressivity of a non-strict FP language really gets you close enough for practical purposes.
Moreover, "macros are good" in the sense that they are powerful and grant the user freedom to construct software in ways that are just not possible with languages that try to herd their users into a specific mode of behavioir. It is the old freedom and responsibility problem. Again, I believe it is a matter of choice and personal preference
> Guile is also the default extension language for the GNU project.
AFAIK Guix is the only project that uses Guile and has any actual users (I'm not counting Shepherd because outside GuixSD it is nothing). Guile is like 30 years old, and has been envisioned as "the default extension language for the GNU project" all that time (I was an active contributor for a while, so I should know). Guile is not even used by Emacs; Guile extensibility support in GDB is not even commonly built by distros. Guile is a nice and very competent Scheme implementation and I'd love for it to be useful outside Guix, but that's just not the case, and repeating that slogan won't change it. Seriously, just stop.
> It is the old freedom and responsibility problem
No, it is not. Software development is a social and technical field, not a branch of philosophy.
For what its worth, here is at least one recent funded project that is using Guile:
https://spritely.institute/goblins/
You also seem to think that I am some kind of Guix/Guile evangelist. No (I actually also prefer CL). I just happen to think that Guix is a better solution than Nix and that it uses a much better language.
> No, it is not. Software development is a social and technical field, not a branch of philosophy.
And I guess you get to say what's good and bad in field? Lol
Your question was basically "is this DSL generally useful outside the domain it's been designed for?", so I thought it was rhetorical. That said, the domain of building, configuring and packaging software is not exactly tiny and is only getting bigger as time goes on (which is more bad than good in itself, but beside the point)!
How useful is the DSL implemented by Guix outside Guix itself? What's the comparative mental footprint of that vs. base Guile? Things get interesting when you think them through honestly and avoid stale slogans.
Anyway, most people that I've come across who've used both nix and guix say that the learning curve for the latter is much less. HOWEVER, they usually stayed with nix because it had easier access to non-gnu stuff
From what I've seen (which matches my expectations going in), Guix relies on macros heavily enough to be considered a DSL on top of Guile (as opposed to "library" or "framework"). I could be wrong, of course.
Any set of non-trivial non-standard macros is a DSL, by definition. You have to know what a macro does and what it is for in order to even understand which of its similar-looking keyword or positional arguments are evaluated and which are not, how they relate to each other, etc, etc. I really don't see what you are arguing about here, or to what end.
thats not entirely correct but even with that definition you should think about the non-standard part. guix uses standard guile syntax and has the whole guile language available to it.
anyway i think you are trying way too hard to equate nix and guile in a way thats simply doesnt click with me. maybe you invested too much time learning nix to concede that there is something better and simpler out there
I feel I'm not getting through here. Let me try again: Guile is base Scheme plus some SRFIs plus some more extensions. None of this is useful outside the Guix bubble, because it is not really used for anything outside that bubble. I suppose pointing at a hundred Texmacs users who picked it up after being exposed to Guix would prove me wrong, but good luck with that.
> maybe you invested too much time learning nix
Maybe armchair psychoanalysis is extremely bad form. Note that I'm not trying to argue against Guix (or Guile, or GNU, or whatever) -- for all I know Guix is just great, and I know Guile is great (shall I rephrase and repeat this disclaimer again until it "clicks"?). I just tend to be triggered by idiotic sloganeering argumentation, especially when it is repeatedly reflexively employed as if it can substitute for a honest technical comparison.
"idiotic sloganeering argumentation"?
> honest technical comparison
let me spell it out for you in another way
nix is developed in cpp (which itself is a huge collection of dsls) and you use its own (poorly documented) dsl to interact with it
guix is developed in guile and you use guile to interact with it
this alone implies that you get far more from just learning guile than nix dsl if all you want to do is package management
as for a one to one technical comparison, it is just a google search away: https://gist.github.com/abcdw/e54807b0a25e61fe2cf1bf8991410f...
>I suppose pointing at a hundred Texmacs users who picked it up after being exposed to Guix would prove me wrong, but good luck with that.
you keep sloganeering that guile is useless outside of guix. i find it pretty funny how willing you are to twist the picture of reality in order for it to fit your world view. i already pointed you to another significant project that uses guile. here is the part in their documentaion spelling out their choice for guile: https://spritely.institute/static/papers/spritely-core.html#...
as for texmacs, i dont know where you are pulling your numbers from, but i for one used texmacs for writing papers before even considering taking on software development professionally. so please don't be triggered if i dont take your claim at face value
That looks like a typical academic project that is overwhelmingly likely to die as soon as the grants run out, what am I missing? Where are the users?
> nix is developed in cpp
Who cares?
> its own (poorly documented) dsl to interact with it
Nix documentation is not by any means ideal and is kind of scattered, but calling it "poor" is a blatant misrepresentation.
> guix is developed in guile and you use guile to interact with it > this alone implies that you get far more from just learning guile than nix dsl > if all you want to do is package management
Argument by repetition, wonderful.
> as for a one to one technical comparison, it is just a google search away
That is... not good. And when a commenter pointed out its biases and misleading generalizations, the author invited them to go listen to a stream, lol, nope.
> you keep sloganeering that guile is useless outside of guix.
That's because it is, no need to get so defensive about it. It does not detract from its technical qualities! In any case, the goalpost got moved way far from the original "Guile iS tHe OfFiCiAl eXtEnSiOn LaNgUaGe Of ThE gNu PrOjEcT", wouldn't you say?
> forgive me if i dont take your claim at face value
"Guile is for all practical purposes useless outside the Guix ecosystem" is my null hypothesis here and so far I stand by it. "Proving" that would be proving a negative, so I don't intend to even attempt that. It should, however, be fairly easy to disprove if you have data. Show us how learning Guile (or any Lisp that is not Elisp really -- sad!) is likely to be worthwhile for a "normal person" apart from using it for Guix.
anyway as i said at the start this whole thing is just heads banging against a wall. i have no problems with you holding your views. it just happens that i disagree with them. if you expect of me to promote the virtues of lisp to you then im sorry but thats not gonna happen. you can do your own discovery. if you dont know then you dont know :)
Yes, and just as well. Modern software is a barely-holding-together tower of abstractions as it is. Do you find yourself looking at the C source of Guile's runtime often? Or Glibc? The Linux kernel? Intel microcode? Aren't you glad you don't have to?
(Nixpkgs, on the other hand, is very accessible and many parts of it make for great reading)
> if you expect of me to promote the virtues of lisp to you then im sorry but thats not gonna happen.
No, I hope (in vain, looks like) that you'll start making some sense and stop using and then desperately defending stupid arguments.
Do you have any more deliberate obtuseness to share, or shall we stop?
huh? nope. looking at guix internals would just mean looking up guile documentation :)
People use software to solve their problems. The way you "sell" (in whatever sense) software to people is by showing them which of their problems it solves (they don't even have to be explicitly aware they have those problems in the first place, BTW) and how.
Nix(OS) is adopted first and foremost because it clearly solves some pressing problems. It allows you to have many development environments that don't stomp on each other, without managing a zoo of containers or VMs. It allows you to specify the operating system (or even just the user environment) you use, over as many machines as you need, deterministically and while ensuring that once you solve a problem it stays solved.
Those are real pain points, and since Nix solves them it would be used by people regardless of those people feel about Nix-the-language, because language appreciation is not the main reason people use it -- pain is.
Some goes for Guix, obviously.
So if your goal (whatever your motivation may be) is to explain to a Nix user how Guix is better, you need to point out something that is relevant to the person you are "selling" to and is fundamentally painful with Nix and painless with Guix. And, well, reaching first thing for "Guile is the official extension language of the GNU Project" does not do your marketing effort any favors.
I never said that that is my goal
TeXmacs (https://texmacs.org) uses Guile, Gimp uses a Scheme, and learning Guile for Guix should be transferable with little changes to other Schemes.
This thread is baffling. cmm is asking a fairly simple question. He's not trying to make a point. If people don't have the answer, they need not respond! There are so many responses to him - none answering his question.
If you're part of the 99% who know little of Lisp languages, he is correct. There's not much of a difference between 0.001% and 0.01%, when you're working in numbers like 20+%.
The discussion wasn't on Lisp, but Guile. They may recognize Lisp syntax, but the majority will not have heard of Guile (let alone Scheme).
And you are referring to recognizing Lisp syntax, which is not what I was referring to when I said "know little of Lisp languages". Sure - most know it exists and has a lot of parentheses.
BTW, many if not most programmers don't have a CS education. And many who do don't encounter Lisp in their curriculum. I just checked my undergrad's required courses - the PL course has Java, SML, Prolog and Python - no Lisp. Anecdotally, in all the teams I've worked in for my career, there was only one team where people had an idea of Lisp. In the other teams, they didn't even know that it's the language with a lot of parentheses (as in they'd look at Lisp code and have no idea which language it was).
still who knows Nix?
Nix is a small and approachable lazy pure-functional language. You can learn a fair bit of functional programming by reading nixpkgs, which is frequently recommended even if you never use it in the real world.
> by learning Guile you learn a lisp which some people find quite enlightening.
By learning nix you learn a FP language which some people find quite enlightening.
Personally I can't find any software which I would want to contribute to or extend which uses guile (except GDB which can also be extended with python), so the "you ain't gonna need it" argument holds for guix too.
It's just such an odd argument for a relatively minor difference between the two ecosystems.
> by learning Guile you learn a lisp which some people find quite enlightening
so learning a lisp is enlightening, but learning a FP language is not
if i wanted to learn pure FP i would probably pick many things over Nix
of course, but that wasn't the question:
> What do you gain from learning Nix, asside from Nix?
If you ever want to embed a dynamic language in a native code program for configuring/scripting the latter, Guile is a great choice.
https://archlinux.org/packages/extra/x86_64/lua/#pkgreqs
https://archlinux.org/packages/core/x86_64/guile/#pkgreqs
(lua at least is under-counted as there is luajit, lua51, and various packages which embed their own version, e.g. pandoc)