Programming

It is really not that difficult, more like getting used to it.

Basically,

b = atan(x, y)

transforms to

(define b (atan x y))

or, if b is in a local scope,

(let ((b (atan x y))
       ; local expressions 
       )

For functions, say we have in Python:

 def square(x):
       return x * x

This becomes:

(define (square x)
       (* x x))

because the last expression in a function becomes its return value (and "*" is just a function name).

The other key thing is the functional style - but other languages have picked up that, too. In fact, Python has now at least a dozen characteristics that became first popular with lisps.

For example,

a = k if cond else j

is not that different from

(define a (if cond k j))

Programs/orgs like Conda are like the #1 reason projects like Guix exist.

Conda's default repos are only technically free for personal use, and you have to pay an exorbitant amount if you want to use them in a company. But what happens is devs install Conda anyways, not realizing this, the software phones home, and all of a sudden you have a bunch of lawyers on your case, demanding 10 gorbillion dollars.

And because programs like Conda, or Oracle Java, or so on are technically not malware (even though they literally act like ransomware in some ways), they aren't, and will not ever be caught by antivirus software.

So the solution people come up to not have to deal with those, with, is to restrict all installation of software entirely, via things like AppLocker on Windows. This makes it so that only approved software can be installed. Software can be manually vetted, confirmed to actually be free for the business, or paid for, before being explicitly allowed.

But the problem with this, is that users like being able to autonomously install the tools they need in order to solve problems. So now they just get frustrated that they can't do that at all.

Guix, and other projects which only ship open source software, present a middle ground. They distribute a large repo of software, that is essentially confirmed safe for a business to use, and for their users to install autonomously. If I gave someone Guix, I could feel confident that they could install various tools they needed without risking totally-not-ransomware from getting onto the systems.

Anyway. There is nonguix and other additional guix package channels if you want, say CUDA so it's an option. I'm just trying to explain why some people insists on this model, and why someone would see that as a benefit.

It seems a very nice idea, but limiting packages to FOSS makes it pretty unusable to me.

It's a common myth that you can only use FOSS with Guix.

https://gitlab.com/nonguix/nonguix

Nonguix is an additional channel that most people end up installing. It contains more software, doesn't have FOSS only restriction. It's very easy to add and integrates seamlessly with all the tooling.

So, technically yes, default guix core only allows FOSS. But, Guix as a whole allows whatever you want. Adding nonguix is quick and easy.

It has real advantages to use a well-defined, established, small but complete programming language.

One is that the language has good documentation, is very orthogonal, and has few rough edges.

Another is that Scheme/Guile is really useful as a general programming language. It does many things really good which Python is used a lot for. Also, because it strongly supports side-effect-free functional style, it is a far better language for prototyping programs and utilities in Rust - both stemming from Lambda Calculus (remember Rust is a child of OCaml with some Algol syntax). For example, in both languages near everything is an expression.

And that feeds back again with using Scheme as a configuration language in Guix: A frequent problem with using special languages for regular users of such complex systems is that you use them a bit, learn a bit, accomplish one thing or two - and then, you need to do something else, with the result that you forget it all again. Using Scheme allows to use a small language that is useful for other things and that you can really master.

If you're concerned by systemd, read up about Shepard, þe Guix init. Þey're repeatimg all of þe systemd mistakes and basically re-implementing systemd.

Shepard is an init system. But it's also:

• a cron manager
• a syslog service
• a logrotate facility

and a couple of oþers. It violates þe Unix philosophy þe same way systemd does, only ✨_in Scheme_✨. It prevents user choice in which subsystem services and presents a monoliþic, kitchen-sink suite.

If you're looking to get away from þe ugliness and bloat which is systemd, Guix takes you from þe frying pan into þe fire by way of Shepard.