Nix – A One Pager

https://github.com/tazjin/nix-1p/blob/master/README.md

67 40 2 years ago

Missing info: Why was this programming language needed in the first place? What is so special about it that the rest of the languages cannot achieve?

hamandcheese• 2 years ago

The thing that is special about Nix the language is everything it doesn't have (no side effects[1], no state, no mutability). It's a very small and simple language.

Those constraints are really important for the rest of the Nix ecosystem to work.

[1]: technically there is one side effect - putting a derivation (i.e. a recipe for how to build a package) into the nix store.

one-punch2• 2 years ago

Quoting https://nix.dev/tutorials/nix-language.html:

    The Nix language is designed for conveniently creating and composing derivations – precise descriptions of how contents of existing files are used to derive new files. It is a domain-specific, purely functional, lazily evaluated, dynamically typed programming language.

So, its key features are:

1. domain-specific: designed for conveniently creating and composing derivations. This reason alone already justifies a new language, or an embedded domain-specific language (embedded in the Guile/Scheme for guix), or a mix of both (Starlark, the build language of Bazel embedded in a restricted Python-variant).

2. purely functional: this underlies the philosophy of the Nix package manager, which aims to be purely functional (also known as hermeticity in other build systems, such as Bazel). Being purely functional in turn underlies the congruence of the NixOS operating system, where you declare what the state the system should be in (as opposed to being convergent, so that you specify how to achieve the desired state).

3. lazily evaluated: similar to other build systems (including Bazel), so that you can build only what you need on demand.

4. dynamically typed: this one is controversial. Being dynamically typed—in other words, not developing a type system—gets Nix out of the door 20 years ago. But users often complain about the lack of proper types and modularity. There are experiments to add a type-and-contract system to Nix, such as Nickel (https://github.com/tweag/nickel).

Most of the above are also listed in the Overview of the One Pager.

orbital-decay2• 2 years ago

Is it that much of a DSL when domain-specific primitives are mostly abstracted away in a standard library written in Nix itself, with underlying machinery written in shell, and when it heavily relies on shell and foreign config snippets to do the job?

Tomis023• 2 years ago

Nix only exists to be the language for Nix, the package manager. While people have occasionally used it for other use-cases, it is explicitly not a general-purpose language.

The next question is why is the Nix package manager needed and why should a software developer care. I don't know the answer.

exe343• 2 years ago

Have you tried Google?

grumbel• 2 years ago

Nix allows you to install packages without naming or version conflicts. It allows you to make source repositories act as first-class packages. It can be installed on any Linux distribution and MacOS. Changing and customizing packages is trivial. All the building and installing happens outside of the source tree, so you don't clutter up your $HOME. It's reproducible. It's simple. And it's build with the needs of Free Software in mind (unlike snap or flatpak which seem mostly concerned with packaging proprietary software). Also Nix is 20 years old at this point.

Simply put, with Nix I can do:

   nix run github:project/name

to run a program. Not many other package managers are capable of that.

one-punch2• 2 years ago

Software developers often want to customize:

1. their home environments: for packages (some reach for brew on MacOS) and configurations (dotfiles, and some reach for stow).

2. their development shells: for build dependencies (compilers, SDKs, libraries), tools (LSP, linters, formatters, debuggers), and services (runtime, database). Some reach for devcontainers here.

3. or even their operating systems: for development, for CI, for deployment, or for personal use.

Nix provision all of the above in the same language, with Nixpkgs, NixOS, home-manager, and devShells such as https://devenv.sh/. What's more, Nix is (https://nixos.org/):

- reproducible: what works on your dev machine also works in CI and in prod,

- declarative: you version control and review your configurations and infrastructure as code, at a reasonable level of abstraction, to specify what the system should be, not how to get there,

- reliable: all changes (switching generations or profiles) are atomic with easy roll back.

Valodim• 2 years ago

It's worth mentioning that Nix is pretty old at this point, it feels a little younger due to its recent surge in popularity. But 20 years ago (that is 8 years before v8!), the programming languages market looked quite different from today.

Guix shows that it's possible to use a different frontend language technically, but switching the nixpkgs repo itself over to anything else at this point would be an enormous community effort where it's hard to say whether it's worth it.

kreetx3• 2 years ago

Yeah. I guess the answer is that there weren't (m)any configuration languages which had functions - even YAML itself (which doesn't have functions) came out a few years before nix. Cue, starlark, dhall are all much later.

otabdeveloper43• 2 years ago

It's not really a programming language. It's a lot like JSON except with lambda functions and variables. Compared to the "template yaml" monstrosity gifted to us by the pointy-haired corporations, the Nix language makes a thousand times more sense.

forgotpwd163• 2 years ago

A one pager regarding the language. Not the entire system.

zufallsheld• 2 years ago

Well, isn't the entire system called nixOS?

forgotpwd163• 2 years ago

Nix can be said is three things. A build system, a package manager, and a language.

dartos• 2 years ago

No, it’s Nix, the package manager.

NixOS is just a barebones Linux distro which uses the nix package manager for system configuration

maxcoder43• 2 years ago

The common joke/fact in the nix community is the nix "triad": nix the language, nix the operating system, and nix the package manager. Sometimes it gets confusing, but usually context is enough.

waldrews3• 2 years ago

A restricted purely functional language for configuration is a great idea. But why not a lisp? The syntax is well thought out, but who needs to remember yet another set of syntax rules. And it's not like lisp syntax would scare off the Nix crow anymore than it scared off the Emacs crowd.

nemoniac• 2 years ago

https://guix.gnu.org/

exe343• 2 years ago

I considered guix, but they seem a bit more religious about non-free. It might be cool to create a lisp->nix transpiler, but nixpkgs is in nix, and you spend a lot of time reading that when doing anything nix.

Y_Y• 2 years ago

Their software freedom policy seems to be similar to Debian. All free by default, allow separate nonfree addon. In the case of Guix you can find that here: https://gitlab.com/nonguix/nonguix .

otabdeveloper43• 2 years ago

Nix-the-language is isomorphic to JSON, which makes a lot more sense than clinging to some outdated 1970's legacy.

waldrews3• 2 years ago

Lisp originated in 1958. We don't need any of that new-fangled 1970's stuff.

aidanhs2• 2 years ago

Can you elaborate on what you're getting at?

Syntax-wise it's about as similar to JSON as Erlang expressions are (i.e. superficially similar in some cases).

Semantics-wise I've personally found any superficial similarity to JSON to be actively unhelpful in understanding because of some important processing differences (e.g. paths, laziness).

agumonkey• 2 years ago

Late 50's please.

maxcoder43• 2 years ago

As a NixOs lover and user, nix-the-language is my least loved feature of the ecosystem. But at a user is not a big problem because I only write configurations for myself, and it's not like my OS configuration is a proper program, it's closer to data.

One upside is that because it's hard to write complex programs in nix, people don't do it (unless really needed). So the nixos tutorials and configuration examples on the internet are usually pretty simple. This is good for beginners, and nixos is already a huge undertaking.

With lisp I'm sure many of us would get crazy with abstractions.

peter_d_sherman• 2 years ago

I should point out that Nix exists as an independent Linux Package Manager (hereafter referred to as "The Nix Package Manager") -- completely separate from NixOS and the Nix Programming Language...

That is, The Nix Package Manager can be used independently of NixOS or The Nix Programming Language to install software on any Linux system (or MacOS) from the Nix Package Repository (search it at: https://search.nixos.org/packages) regardless of any knowledge (or any lack of knowledge!) that a given user has (or doesn't have!) of the Nix Programming Language...

Here's how to install it on a non-NixOS system (top half of page):

https://nixos.org/download/

(Basically just "$ sh <(curl -L https://nixos.org/nix/install) --daemon" for multi-user setup, or "$ sh <(curl -L https://nixos.org/nix/install) --no-daemon" for single-user setup...)

The idea of running another Linux distro's package manager/installer to install things from their repository onto your Linux distro is not a new one -- in fact, it has been done rather successfully on many Linux distros for some time...

This concept invariably brings us to Bedrock Linux, a distribution whose sole purpose is to run package managers/installers -- from other distros!

https://bedrocklinux.org/index.html

...Or at least attempt to!

That's because some distros/package managers/Linux software -- may create conflicts with other installers/package managers/Linux software...

As can be seen here, from these Bedrock compatibility charts/"compatibility matrices":

https://bedrocklinux.org/0.7/distro-compatibility.html

https://bedrocklinux.org/0.7/feature-compatibility.html

Still, if not perfect in the current day, the idea of being able to mix-and-match package managers/installers from multiple Linux distros/repositories -- is a very compelling one!

Both the Nix and the Bedrock teams should be highly lauded for their efforts! Nix to create hermetic software environments, Bedrock to mix-and-match (and sort out compatibility issues!) between multi distro package managers/installers and software repositories...

Both are worth a serious look -- and potentially some of your time!

Nix – A One Pager

Related Stories