From 27ae604119b74dceadee26137f34fe0c1a8147f4 Mon Sep 17 00:00:00 2001 From: Philipp Baumann Date: Thu, 19 Sep 2024 20:49:12 +0200 Subject: [PATCH] quickfix readme after wrong header rendering --- README.md | 482 +++++++++++++++++++++++++++++------------------------- 1 file changed, 256 insertions(+), 226 deletions(-) diff --git a/README.md b/README.md index 84ff11fc..888ffd1c 100644 --- a/README.md +++ b/README.md @@ -1,15 +1,15 @@ ---- -output: github_document ---- # rix: Reproducible Environments with Nix -- [Reproducible Environments with Nix](#reproducible-environments-with-nix) +- [Reproducible Environments with + Nix](#reproducible-environments-with-nix) - [Introduction](#introduction) - [Quick start for returning users](#quick-start-for-returning-users) - [Getting started for new users](#getting-started-for-new-users) - [Docker](#docker) - - [How is Nix different from Docker+renv/{groundhog}/{rang}/(Ana/Mini)Conda/Guix? or Why Nix?](#how-is-nix-different-from-dockerrenvgroundhogranganaminicondaguix-or-why-nix) + - [How is Nix different from + Docker+renv/{groundhog}/{rang}/(Ana/Mini)Conda/Guix? or Why + Nix?](#how-is-nix-different-from-dockerrenvgroundhogranganaminicondaguix-or-why-nix) - [Docker and renv](#docker-and-renv) - [Ana/Miniconda and Mamba](#anamini-conda-and-mamba) - [How is Nix different from Guix?](#how-is-nix-different-from-guix) @@ -19,112 +19,124 @@ output: github_document - [Recommended reading](#recommended-reading) -[![R-hub v2](https://github.com/ropensci/rix/actions/workflows/rhub.yaml/badge.svg)](https://github.com/ropensci/rix/actions/workflows/rhub.yaml/) -[![runiverse-package rix](https://ropensci.r-universe.dev/badges/rix?scale=1&color=pink&style=round)](https://ropensci.r-universe.dev/rix) + +[![R-hub +v2](https://github.com/ropensci/rix/actions/workflows/rhub.yaml/badge.svg)](https://github.com/ropensci/rix/actions/workflows/rhub.yaml/badge.svg) +[![runiverse-package +rix](https://ropensci.r-universe.dev/badges/rix?scale=1&color=pink&style=round)](https://ropensci.r-universe.dev/rix) [![Docs](https://img.shields.io/badge/docs-release-blue.svg)](https://docs.ropensci.org/rix) -[![Status at rOpenSci Software Peer Review](https://badges.ropensci.org/625_status.svg)](https://github.com/ropensci/software-review/issues/625) +[![Status at rOpenSci Software Peer +Review](https://badges.ropensci.org/625_status.svg)](https://github.com/ropensci/software-review/issues/625) - - ## Introduction -`{rix}` is an R package that leverages [Nix](https://nixos.org/), a powerful -package manager focusing on reproducible builds. With Nix, it is possible to -create project-specific environments that contain a project-specific version of -R and R packages (as well as other tools or languages, if needed). This -project-specific environment will also include all the required system-level -dependencies that can be difficult to install, such as `GDAL` for packages for -geospatial analysis for example. Nix installs -software as a complete "bundle" that include all of the software's dependencies, and all of -the dependencies' dependencies and so on. Nix is an incredibly useful piece of -software for ensuring reproducibility of projects, in research or otherwise. - -Some other use cases include, for example, running web applications like Shiny apps or `{plumber}` APIs -in a controlled environment, or executing `{targets}` pipelines with the right version -of R and dependencies, or use environments managed by Nix to work interactively using an IDE. - -In essence, this means that you can use `{rix}` and Nix to replace `{renv}` and -Docker with one single tool, but the approach is quite different: `{renv}` -records specific versions of individual packages, while `{rix}` provides a -complete snapshot of the R ecosystem at a specific point in time, but also -snapshots all the required dependencies to make your project-specific R -environment work. In contrast, to ensure complete reproducibility with `{renv}`, it must be -combined with Docker, in order to include system-level dependencies (like `GDAL`, -as per the example above). - -Nix has a fairly steep learning curve though. Nix is a complex piece of software that -comes with its own programming language, which is also called Nix. Its purpose -is to solve a complex problem: defining instructions on how to build software -packages and manage configurations in a declarative way, using functional programming -principles. This makes sure that software gets installed in a fully reproducible manner, -on any operating system or hardware, but with the caveat that users must learn the Nix -programming language and get into the "functional programming approach to software management" -mindset, which is unusual. - -`{rix}` provides functions to help you write Nix expressions (written in the Nix -language). These expressions will be the inputs for the Nix package manager, to -build sets of software packages and provide them in a reproducible development -environment. These environments can be used for interactive data analysis, or -reproduced when running pipelines in CI/CD systems. The [Nixpkgs -collection](https://github.com/nixos/nixpkgs) includes currently more than -100.000 pieces of software available through the Nix package manager. - -With `{rix}`, you can define development environments, or shells, that contain -the required tools needed to analyze data using R. These environments are -isolated from each other and project-specific: this means that a project can use -one version of R and R packages, and another environment another version of R -and R packages. However, extra care is required if you already have R installed -through the usual method for your operating system, as these development -environments are not totally isolated from the rest of your system. Unlike -Docker, where a running container cannot acces anything from the host system, -unless explicitely configured to do so, Nix development shells are nothing but -environments that add more software to the list of already available software -(the so-called `PATH`). As such, it is possible to access anything (files and -software) already present on the system from a running Nix shell. Thus, `{rix}` -also provides a function called `rix_init()` that helps isolate R sessions -running inside Nix environments from the rest of your system. This avoids -clashes between the Nix-specific library of R packages and the user library of R -packages should you already have R installed and managed by the usual method for -your operating system. - -It is also possible to add any other software package available on Nixpkgs to a -Nix environment, for example IDEs such as RStudio or VS Code. The Nix R -ecosystem currently includes almost the entirety of CRAN and Bioconductor -packages (there is around a hundred CRAN or Biocondcuctor packages that are -unavailable through Nix). Like with any other programming language or software, -it is also possible to install older releases of R packages, or install packages -from GitHub at defined states, as well as local packages in the `.tar.gz` -format. - -The Nix package manager is extremely powerful. Not only does it handle all the -dependencies of any package extremely well in a deterministic manner, it is also -possible with it to reproduce environments containing old releases of software. -It is thus possible to build environments containing R version 4.0.0 (for -example) to run an old project that was originally developed on that version of -R. - -If you need other tools or languages like Python or Julia, this can also be done -easily. Nix is available for Linux, macOS and Windows (via WSL2) and `{rix}` -comes with the following features: - -- define complete development environments as code and use them anywhere; -- install project-specific complete R environments, which can be different from each other; +`{rix}` is an R package that leverages [Nix](https://nixos.org/), a +powerful package manager focusing on reproducible builds. With Nix, it +is possible to create project-specific environments that contain a +project-specific version of R and R packages (as well as other tools or +languages, if needed). This project-specific environment will also +include all the required system-level dependencies that can be difficult +to install, such as `GDAL` for packages for geospatial analysis for +example. Nix installs software as a complete “bundle” that include all +of the software’s dependencies, and all of the dependencies’ +dependencies and so on. Nix is an incredibly useful piece of software +for ensuring reproducibility of projects, in research or otherwise. + +Some other use cases include, for example, running web applications like +Shiny apps or `{plumber}` APIs in a controlled environment, or executing +`{targets}` pipelines with the right version of R and dependencies, or +use environments managed by Nix to work interactively using an IDE. + +In essence, this means that you can use `{rix}` and Nix to replace +`{renv}` and Docker with one single tool, but the approach is quite +different: `{renv}` records specific versions of individual packages, +while `{rix}` provides a complete snapshot of the R ecosystem at a +specific point in time, but also snapshots all the required dependencies +to make your project-specific R environment work. In contrast, to ensure +complete reproducibility with `{renv}`, it must be combined with Docker, +in order to include system-level dependencies (like `GDAL`, as per the +example above). + +Nix has a fairly steep learning curve though. Nix is a complex piece of +software that comes with its own programming language, which is also +called Nix. Its purpose is to solve a complex problem: defining +instructions on how to build software packages and manage configurations +in a declarative way, using functional programming principles. This +makes sure that software gets installed in a fully reproducible manner, +on any operating system or hardware, but with the caveat that users must +learn the Nix programming language and get into the “functional +programming approach to software management” mindset, which is unusual. + +`{rix}` provides functions to help you write Nix expressions (written in +the Nix language). These expressions will be the inputs for the Nix +package manager, to build sets of software packages and provide them in +a reproducible development environment. These environments can be used +for interactive data analysis, or reproduced when running pipelines in +CI/CD systems. The [Nixpkgs +collection](https://github.com/nixos/nixpkgs) includes currently more +than 100.000 pieces of software available through the Nix package +manager. + +With `{rix}`, you can define development environments, or shells, that +contain the required tools needed to analyze data using R. These +environments are isolated from each other and project-specific: this +means that a project can use one version of R and R packages, and +another environment another version of R and R packages. However, extra +care is required if you already have R installed through the usual +method for your operating system, as these development environments are +not totally isolated from the rest of your system. Unlike Docker, where +a running container cannot acces anything from the host system, unless +explicitely configured to do so, Nix development shells are nothing but +environments that add more software to the list of already available +software (the so-called `PATH`). As such, it is possible to access +anything (files and software) already present on the system from a +running Nix shell. Thus, `{rix}` also provides a function called +`rix_init()` that helps isolate R sessions running inside Nix +environments from the rest of your system. This avoids clashes between +the Nix-specific library of R packages and the user library of R +packages should you already have R installed and managed by the usual +method for your operating system. + +It is also possible to add any other software package available on +Nixpkgs to a Nix environment, for example IDEs such as RStudio or VS +Code. The Nix R ecosystem currently includes almost the entirety of CRAN +and Bioconductor packages (there is around a hundred CRAN or +Biocondcuctor packages that are unavailable through Nix). Like with any +other programming language or software, it is also possible to install +older releases of R packages, or install packages from GitHub at defined +states, as well as local packages in the `.tar.gz` format. + +The Nix package manager is extremely powerful. Not only does it handle +all the dependencies of any package extremely well in a deterministic +manner, it is also possible with it to reproduce environments containing +old releases of software. It is thus possible to build environments +containing R version 4.0.0 (for example) to run an old project that was +originally developed on that version of R. + +If you need other tools or languages like Python or Julia, this can also +be done easily. Nix is available for Linux, macOS and Windows (via WSL2) +and `{rix}` comes with the following features: + +- define complete development environments as code and use them + anywhere; +- install project-specific complete R environments, which can be + different from each other; - run single R functions (and objects in the call stack) in a different - environment (potentially with a different R version and R packages) for an - interactive R session, and get back the output of that function using + environment (potentially with a different R version and R packages) + for an interactive R session, and get back the output of that function + using [`with_nix()`](https://docs.ropensci.org/rix/reference/with_nix.html); `{rix}` does not require Nix to be installed on your system to generate -expressions. This means that you can generate expressions on a system on which -you cannot easily install software, and then use these expressions on the cloud -or on a CI/CD environment to build the project there. - -If you have R installed, you can start straight away from your R session by -first installing `{rix}`: +expressions. This means that you can generate expressions on a system on +which you cannot easily install software, and then use these expressions +on the cloud or on a CI/CD environment to build the project there. +If you have R installed, you can start straight away from your R session +by first installing `{rix}`: ``` r install.packages("rix", repos = c( @@ -137,7 +149,6 @@ library("rix") Now try to build an expression using `rix()`: - ``` r library(rix) @@ -155,11 +166,12 @@ rix( ) ``` -This generates a file called `default.nix` in the path `path_default_nix` with -the correct expression to build this environment. To build the environment, -the Nix package manager must be installed. If you have Nix installed, you can -build the expression above using the `nix-build` terminal command and then enter -the environment using `nix-shell`. The vignettes included in the package walk you +This generates a file called `default.nix` in the path +`path_default_nix` with the correct expression to build this +environment. To build the environment, the Nix package manager must be +installed. If you have Nix installed, you can build the expression above +using the `nix-build` terminal command and then enter the environment +using `nix-shell`. The vignettes included in the package walk you through the whole workflow. ## Quick start for returning users @@ -167,14 +179,15 @@ through the whole workflow. *If you are not familiar with Nix or `{rix}` skip to the next section.*
+ +Click to expand + -Click to expand -If you are already familiar with Nix and R, and simply want to get started as -quickly as possible, you can start by installing Nix using the installer from -[Determinate -Systems](https://determinate.systems/posts/determinate-nix-installer) a company -that provides services and tools built on Nix: - +If you are already familiar with Nix and R, and simply want to get +started as quickly as possible, you can start by installing Nix using +the installer from [Determinate +Systems](https://determinate.systems/posts/determinate-nix-installer) a +company that provides services and tools built on Nix: ``` sh curl --proto '=https' --tlsv1.2 -sSf \ @@ -182,11 +195,11 @@ curl --proto '=https' --tlsv1.2 -sSf \ sh -s -- install ``` -You can check that everything works well by trying to build the Nix expression -that ships with `{rix}`. Nix expressions are typically saved into files with the -name `default.nix` or `shell.nix`. This expression installs the latest version -of R and `{rix}` in a separate, reproducible environment: - +You can check that everything works well by trying to build the Nix +expression that ships with `{rix}`. Nix expressions are typically saved +into files with the name `default.nix` or `shell.nix`. This expression +installs the latest version of R and `{rix}` in a separate, reproducible +environment: ``` r file.copy( @@ -200,35 +213,32 @@ nix_build(project_path = ".") ``` If everything worked well, you should see a file called `result` next to -`default.nix`. You can now enter this newly built development environment by -opening a terminal in that folder and typing `nix-shell`. You should -be immediately dropped into an interactive R session. +`default.nix`. You can now enter this newly built development +environment by opening a terminal in that folder and typing `nix-shell`. +You should be immediately dropped into an interactive R session. -If you don't have R installed, but have the Nix package manager installed, you -can run a temporary R session with R using this command (it will build the same -environment as the one above): +If you don’t have R installed, but have the Nix package manager +installed, you can run a temporary R session with R using this command +(it will build the same environment as the one above): -``` -nix-shell --expr "$(curl -sl https://raw.githubusercontent.com/ropensci/rix/main/inst/extdata/default.nix)" -``` + nix-shell --expr "$(curl -sl https://raw.githubusercontent.com/ropensci/rix/main/inst/extdata/default.nix)" -You can then create new development environment definitions, build them, and -start using them. +You can then create new development environment definitions, build them, +and start using them.
## Getting started for new users -To get started with `{rix}` and Nix, you should read the following vignette -`vignette("a-getting-started")` -([online documentation](https://docs.ropensci.org/rix/articles/a-getting-started.html)). -The vignettes are numbered to get you to learn -how to use `{rix}` and Nix smoothly. There’s a lot of info, so take your time -reading the vignettes. Don’t hesitate to open an issue if something is not -clear. +To get started with `{rix}` and Nix, you should read the following +vignette `vignette("a-getting-started")` ([online +documentation](https://docs.ropensci.org/rix/articles/a-getting-started.html)). +The vignettes are numbered to get you to learn how to use `{rix}` and +Nix smoothly. There’s a lot of info, so take your time reading the +vignettes. Don’t hesitate to open an issue if something is not clear. ### Docker -You can also try out Nix inside Docker. To know more, read +You can also try out Nix inside Docker. To know more, read `vignette("z-advanced-topic-using-nix-inside-docker")` [link](https://github.com/ropensci/rix/blob/HEAD/vignettes/z-advanced-topic-using-nix-inside-docker.Rmd). @@ -236,96 +246,105 @@ You can also try out Nix inside Docker. To know more, read ### Docker and renv -Let's start with arguably the most popular combo for reproducibility in the R -ecosystem, Docker+`{renv}`. +Let’s start with arguably the most popular combo for reproducibility in +the R ecosystem, Docker+`{renv}`. -{renv} snapshots the state of the library of R packages for a project, nothing -more, nothing less, unless you also use `{rspm}` or `{bspm}` in +{renv} snapshots the state of the library of R packages for a project, +nothing more, nothing less, unless you also use `{rspm}` or `{bspm}` in combination to `{renv}`: this will install the required system-level -dependencies automatically. `{renv}` can then be used to restore the library of packages on -another machine, but it is the user's responsibility to ensure that the right -version of R and system-level dependencies are available on that other machine. -This is why `{renv}` is often coupled with a versioned Docker image, such as the -images from the [Rocker project](https://hub.docker.com/r/rocker/r-ver). -Combining both provides a very robust way to serve applications such as Shiny -apps, but it can be awkward to develop interactively with this setup, which is -why most of the time, people work on their current setup, and *dockerize* the -setup once when they're done. However, you need to make sure to keep updating -the image, as the underlying operating system will eventually reach end of life. -Eventually, you might even have to update the whole stack as it could become -impossible to install the version of R and R packages you used on a recent -Docker image. This can be a good thing actually; it could be the opportunity to -update your app and make sure that it benefits from the latest security patches. -However for reproducibility in research, this is not something that you should -be doing because it could have an impact on historical results. - -What we suggest instead, is to keep using Docker if you are already invested in -the ecosystem, and continue to use it to deploy and serve applications and -archive research. But instead of using `{renv}` to get the right packages, you -combine Docker and Nix. This way, you have a nice separation of concerns: Docker -will only be used as a platter to serve code, while the environment will be -handled by Nix. You could even use an image that gets continuously updated such -as `ubuntu:latest` as a base: it doesn’t matter that the image is always -changing, since the environment that will be doing the heavy lifting inside the -container is completely reproducible thanks to Nix. - -Exactly the same reasoning can be applied to `{groundhog}`, `{rang}` or the CRAN -snapshots of Posit in combination to Docker instead of `{renv}`. +dependencies automatically. `{renv}` can then be used to restore the +library of packages on another machine, but it is the user’s +responsibility to ensure that the right version of R and system-level +dependencies are available on that other machine. This is why `{renv}` +is often coupled with a versioned Docker image, such as the images from +the [Rocker project](https://hub.docker.com/r/rocker/r-ver). Combining +both provides a very robust way to serve applications such as Shiny +apps, but it can be awkward to develop interactively with this setup, +which is why most of the time, people work on their current setup, and +*dockerize* the setup once when they’re done. However, you need to make +sure to keep updating the image, as the underlying operating system will +eventually reach end of life. Eventually, you might even have to update +the whole stack as it could become impossible to install the version of +R and R packages you used on a recent Docker image. This can be a good +thing actually; it could be the opportunity to update your app and make +sure that it benefits from the latest security patches. However for +reproducibility in research, this is not something that you should be +doing because it could have an impact on historical results. + +What we suggest instead, is to keep using Docker if you are already +invested in the ecosystem, and continue to use it to deploy and serve +applications and archive research. But instead of using `{renv}` to get +the right packages, you combine Docker and Nix. This way, you have a +nice separation of concerns: Docker will only be used as a platter to +serve code, while the environment will be handled by Nix. You could even +use an image that gets continuously updated such as `ubuntu:latest` as a +base: it doesn’t matter that the image is always changing, since the +environment that will be doing the heavy lifting inside the container is +completely reproducible thanks to Nix. + +Exactly the same reasoning can be applied to `{groundhog}`, `{rang}` or +the CRAN snapshots of Posit in combination to Docker instead of +`{renv}`. ### Ana/Mini-conda and Mamba -Anaconda, Miniconda, Mamba, Micromamba... (henceforth we'll refer to these as -Conda) and Nix have much in common: they are multiplatform package managers and -both can be used to setup reproducible development environments for many -languages, such as R or Python. Using +Anaconda, Miniconda, Mamba, Micromamba… (henceforth we’ll refer to these +as Conda) and Nix have much in common: they are multiplatform package +managers and both can be used to setup reproducible development +environments for many languages, such as R or Python. Using [conda-lock](https://github.com/conda/conda-lock) one can generate fully -reproducible lock files that can then be used by Conda to build the environment -as defined in the lock file. The main difference between Conda and Nix is -conceptual and might not seem that important for end-users: Conda is a -procedural package manager, while Nix is a functional package manager. In -practice this means that environments managed by Conda are mutable and users are -not prevented from changing their environment interactively, and then -re-generate the lock file. This is quite comfortable when working interactively, -but can lead to issues where dependency management might get borked. - -In the case of Nix however, environments are immutable: you cannot add software -into a running Nix environment. You will need to stop working, re-define the -environment, rebuild it and then use it. While this might sound more tedious (it -is) it forces users to work more "cleanly" and avoids many issues from -dynamically changing an environment. If it is not possible to build that -environment, it fails as early as possible and forces you to deal with the -issue. A mutating environment could lead you into a false sense of security. - -Another major difference is that Conda does not include the entirety of CRAN nor -Bioconductor, which is the case for Nix. According to [Anaconda's +reproducible lock files that can then be used by Conda to build the +environment as defined in the lock file. The main difference between +Conda and Nix is conceptual and might not seem that important for +end-users: Conda is a procedural package manager, while Nix is a +functional package manager. In practice this means that environments +managed by Conda are mutable and users are not prevented from changing +their environment interactively, and then re-generate the lock file. +This is quite comfortable when working interactively, but can lead to +issues where dependency management might get borked. + +In the case of Nix however, environments are immutable: you cannot add +software into a running Nix environment. You will need to stop working, +re-define the environment, rebuild it and then use it. While this might +sound more tedious (it is) it forces users to work more “cleanly” and +avoids many issues from dynamically changing an environment. If it is +not possible to build that environment, it fails as early as possible +and forces you to deal with the issue. A mutating environment could lead +you into a false sense of security. + +Another major difference is that Conda does not include the entirety of +CRAN nor Bioconductor, which is the case for Nix. According to +[Anaconda’s Documentation](https://docs.anaconda.com/working-with-conda/packages/using-r-language/) -6000 CRAN packages are available through Conda (as of writing in July 2024, CRAN -has 21'000+ packages). Nix also includes almost all of Bioconductor packages, -and Conda includes them trough the Bioconda project, however, we were not able -to find if Bioconda contains all of Bioconductor. According to Bioconda's FAQ, -[Bioconductor data packages are not +6000 CRAN packages are available through Conda (as of writing in July +2024, CRAN has 21’000+ packages). Nix also includes almost all of +Bioconductor packages, and Conda includes them trough the Bioconda +project, however, we were not able to find if Bioconda contains all of +Bioconductor. According to Bioconda’s FAQ, [Bioconductor data packages +are not included.](https://bioconda.github.io/faqs.html#why-are-bioconductor-data-packages-failing-to-install) ### How is Nix different from Guix? -Just like Nix, Guix is a functional package manager with a focus on reproducible -builds. We won't go into technical differences/similarities, but only to -pratical ones for end-users of the R programming language. If you want to know -about technical aspects, read this -[https://news.ycombinator.com/item?id=18910683](Hackernews post by one of the -authors of Guix). The main shortcoming of Guix for R users is that not all CRAN -or Bioconductor packages are included, nor is Guix available on Windows or +Just like Nix, Guix is a functional package manager with a focus on +reproducible builds. We won’t go into technical +differences/similarities, but only to pratical ones for end-users of the +R programming language. If you want to know about technical aspects, +read this +[https://news.ycombinator.com/item?id=18910683](Hackernews%20post%20by%20one%20of%20the%20authors%20of%20Guix). +The main shortcoming of Guix for R users is that not all CRAN or +Bioconductor packages are included, nor is Guix available on Windows or macOS. ### Is {rix} all there is? -No, there are other tools that you might want to check out, especially if -you want to set up polyglot environments (even though it is possible to -use `{rix}` to set up an environment with R and Python packages for example). +No, there are other tools that you might want to check out, especially +if you want to set up polyglot environments (even though it is possible +to use `{rix}` to set up an environment with R and Python packages for +example). -Take a look at [https://devenv.sh/](https://devenv.sh/) and -[https://prefix.dev/](https://prefix.dev/) if you want to explore other tools -that make using Nix easier! +Take a look at and if you +want to explore other tools that make using Nix easier! ## Contributing @@ -337,30 +356,41 @@ project, you agree to abide by its terms. ## Thanks -Thanks to the [Nix community](https://nixos.org/community/) for making Nix -possible, and thanks to the community of R users on Nix for their work -packaging R and CRAN/Bioconductor packages for Nix (in particular [Justin -Bedő](https://github.com/jbedo), [Rémi Nicole](https://github.com/minijackson), +Thanks to the [Nix community](https://nixos.org/community/) for making +Nix possible, and thanks to the community of R users on Nix for their +work packaging R and CRAN/Bioconductor packages for Nix (in particular +[Justin Bedő](https://github.com/jbedo), [Rémi +Nicole](https://github.com/minijackson), [nviets](https://github.com/nviets), [Chris Hammill](https://github.com/cfhammill), [László Kupcsik](https://github.com/Kupac), [Simon Lackerbauer](https://github.com/ciil), -[MrTarantoga](https://github.com/MrTarantoga) and every other person from the -[Matrix Nixpkgs R channel](https://matrix.to/#/#r:nixos.org)). +[MrTarantoga](https://github.com/MrTarantoga) and every other person +from the [Matrix Nixpkgs R channel](https://matrix.to/#/#r:nixos.org)). -Finally, thanks to [David Solito](https://x.com/dsolito) for creating `{rix}`'s logo! +Finally, thanks to [David Solito](https://x.com/dsolito) for creating +`{rix}`’s logo! ## Recommended reading - [NixOS’s website](https://nixos.org/) - [Nixpkgs’s GitHub repository](https://github.com/NixOS/nixpkgs) -- [Nix for R series from Bruno's blog](https://www.brodrigues.co/tags/nix/). Or, in case you like video tutorials, watch [this one on Reproducible R development environments with Nix](https://www.youtube.com/watch?v=c1LhgeTTxaI) -- [nix.dev tutorials](https://nix.dev/tutorials/first-steps/towards-reproducibility-pinning-nixpkgs#pinning-nixpkgs) -- [INRIA's Nix tutorial](https://nix-tutorial.gitlabpages.inria.fr/nix-tutorial/installation.html) +- [Nix for R series from Bruno’s + blog](https://www.brodrigues.co/tags/nix/). Or, in case you like video + tutorials, watch [this one on Reproducible R development environments + with Nix](https://www.youtube.com/watch?v=c1LhgeTTxaI) +- [nix.dev + tutorials](https://nix.dev/tutorials/first-steps/towards-reproducibility-pinning-nixpkgs#pinning-nixpkgs) +- [INRIA’s Nix + tutorial](https://nix-tutorial.gitlabpages.inria.fr/nix-tutorial/installation.html) - [Nix pills](https://nixos.org/guides/nix-pills/) -- [Nix for Data Science](https://github.com/nix-community/nix-data-science) -- [NixOS explained](https://christitus.com/nixos-explained/): NixOS is an entire Linux distribution that uses Nix as its package manager. -- [Blog post: Nix with R and devtools](https://rgoswami.me/posts/nix-r-devtools/) -- [Blog post: Statistical Rethinking and Nix](https://rgoswami.me/posts/rethinking-r-nix/) -- [Blog post: Searching and installing old versions of Nix packages](https://lazamar.github.io/download-specific-package-version-with-nix/) - +- [Nix for Data + Science](https://github.com/nix-community/nix-data-science) +- [NixOS explained](https://christitus.com/nixos-explained/): NixOS is + an entire Linux distribution that uses Nix as its package manager. +- [Blog post: Nix with R and + devtools](https://rgoswami.me/posts/nix-r-devtools/) +- [Blog post: Statistical Rethinking and + Nix](https://rgoswami.me/posts/rethinking-r-nix/) +- [Blog post: Searching and installing old versions of Nix + packages](https://lazamar.github.io/download-specific-package-version-with-nix/)