Nix for Development

services-flake provides declarative, composable, and reproducible services for Nix development environment, and is based on flake-parts. Enabling users to have NixOS-like service on macOS and Linux.

direnv (along with nix-direnv) allows one to persist^* nix development shell environments and share them seamlessly with text editors and IDEs. It obviates having to run nix develop manually every time you open a new terminal. The moment you cd into your project directory, the devshell is automatically activated, thanks to direnv.

Why opt for Nix when developping a software project instead of language-specific alternatives (such as Stack or GHCup for Haskell)?

If your project provides a flake.nix along with a development shell, it can be developed on VSCode using one of the two ways (prefer the 2nd way):

There are several ways to provide packaging and development enviornment for Rust projects.

Ever since I first started using Nix for development, I have enjoyed the simplicity of setup: nix develop, make the code change and see it work. That’s all well and good, but when your project keeps growing, you need to depend on external services like databases, message brokers, etc. And then, a quick search will tell you that docker is the way to go. You include it, add one more step in the setup guide, increasing the barrier to entry for new contributors. Not to mention, eating up all the system resources^* on my not so powerful, company-provided MacBook.

Like packages, another predefined flake output is devShells - which is used to provide a development shell aka. a nix shell or devshell. A devshell is a sandboxed environment containing the packages and other shell environment you specify. nixpkgs provides a function called mkShell that can be used to create devshells.

The goal of this mini-tutorial is to introduce you to Nix the language, including flakes, as quickly as possible while also preparing the motivated learner to dive deeper into the whole Nix ecosystem. At the end of this introduction, you will be able to create a flake.nix that builds a package and provides a developer environment shell.

A Haskell devShell can be provided in one of the two ways. The default way is to use the (language-independent) mkShell function (Generic shell). However to get full IDE support, it is best to use the (haskell-specific) shellFor function, which is an abstraction over mkShell geared specifically for Haskell development shells

Welcome to the Nixify Haskell projects series, where we start our journey by integrating a Haskell application, particularly one using a PostgreSQL database, into a single-command deployable package. By the end of this article, you’ll have a flake.nix file that’s set to build the project, establish the development environment, and execute the Haskell application along with all its dependent services like PostgreSQL and PostgREST. We’ll be using todo-app as a running case study throughout the series, demonstrating the process of building a Haskell project and effectively managing runtime dependencies, such as databases and other services, thereby illustrating the streamlined and powerful capabilities Nix introduces to Haskell development.

As a final step, let’s permanently enable Flakes on our system, which is particularly useful if you do a lot of software development. This time, instead of editing configuration.nix again, let’s do it in a separate module (for no particular reasons other than pedagogic purposes). Remember the modules argument to nixosSystem function in our flake.nix? It is a list of modules, so we can add a second module there:

Git is the most commonly used version control system for software development.

Sridhar Ratnakumar will demonstrate the delights of using Nix to develop Rust as well as Haskell projects without needing to do any manual global setup on your system. We’ll start from a pristine macOS machine as well as a pristine Linux machine to get our development environment up and running in no time, all the way up to LSP support in VSCode.

treefmt provides an interface to run multiple code formatters at once, so you don’t have to run them manually for each file type in your development project.