Nix Flakes

Useful script to initialise flakes before running nix

#!/usr/bin/env bash
 
# Ensure Nix has flakes enabled
echo "Setting up Nix Flakes environment..."
 
if ! grep -q 'experimental-features = nix-command flakes' ~/.config/nix/nix.conf; then
  echo "Enabling flakes support in Nix..."
  mkdir -p ~/.config/nix
  echo "experimental-features = nix-command flakes" >> ~/.config/nix/nix.conf
else
  echo "Flakes support is already enabled."
fi
 
# Reload Nix daemon
if command -v nix &> /dev/null; then
  echo "Reloading Nix..."
  nix-env --version
  nix-channel --update
else
  echo "Nix is not installed. Please install it first."
fi
 
echo "Nix environment for flakes is now set up."

Go Dev flake

{
  description = "Professional Go development environment with Nix flakes";
 
  inputs = {
    nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
    flake-utils.url = "github:numtide/flake-utils";
  };
 
  outputs = { self, nixpkgs, flake-utils }: 
    flake-utils.lib.simpleFlake {
      inherit self nixpkgs;
      name = "go-dev-env";
      shell = { pkgs }: pkgs.mkShell {
        buildInputs = with pkgs; [
          # Go compiler and tools
          go
          gopls
          go-tools
          golangci-lint
 
          # Build essentials
          gcc
          pkg-config
 
          # Development tools
          delve # Go debugger
          air # Live reload for Go apps
        ];
 
        # Set up Go environment variables
        shellHook = ''
          export GOPATH=$HOME/go
          export PATH=$GOPATH/bin:$PATH
          export GO111MODULE=on
          export GOFLAGS="-mod=readonly"
 
          # Print versions for verification
          echo "Go Version: $(go version)"
          echo "GCC Version: $(gcc --version | head -n 1)"
          echo "Development environment ready!"
        '';
      };
    };
}

Python Dev flake

{
  description = "Professional Python development environment with Poetry, linting, and testing";
 
  inputs = {
    nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
    flake-utils.url = "github:numtide/flake-utils";
  };
 
  outputs = { self, nixpkgs, flake-utils }:
    flake-utils.lib.simpleFlake {
      inherit self nixpkgs;
      name = "python-dev-env";
      shell = { pkgs }: pkgs.mkShell {
        buildInputs = with pkgs; [
          # Python and package management
          python311
          python311Packages.poetry
          python311Packages.pip
          python311Packages.virtualenv
 
          # GNU Make for task automation
          gnumake
 
          # Linting & Formatting
          python311Packages.black
          python311Packages.isort
          python311Packages.mypy
          python311Packages.ruff
 
          # Testing
          python311Packages.pytest
          python311Packages.pytest-cov
 
          # Debugging
          python311Packages.debugpy
          python311Packages.ipdb
 
          # Pre-commit hooks
          python311Packages.pre-commit
 
          # Utilities
          python311Packages.rich # Rich formatting for debugging/logging
        ];
 
        # Set up the environment
        shellHook = ''
          export VIRTUAL_ENV=$PWD/.venv
          export PATH=$VIRTUAL_ENV/bin:$PATH
          export POETRY_VIRTUALENVS_IN_PROJECT=true
          
          # Ensure virtual environment is activated
          if [ ! -d "$VIRTUAL_ENV" ]; then
            echo "Creating virtual environment..."
            poetry install
          fi
          source $VIRTUAL_ENV/bin/activate
 
          # Display versions for verification
          echo "Python Version: $(python --version)"
          echo "Poetry Version: $(poetry --version)"
          echo "Make Version: $(make --version | head -n 1)"
          echo "Development environment ready!"
        '';
      };
    };
}

Elixir Dev flake

{
  description = "Professional Elixir Phoenix development environment with Nix flakes";
 
  inputs = {
    nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
    flake-utils.url = "github:numtide/flake-utils";
  };
 
  outputs = { self, nixpkgs, flake-utils }:
    flake-utils.lib.simpleFlake {
      inherit self nixpkgs;
      name = "elixir-phoenix-dev-env";
      shell = { pkgs }: pkgs.mkShell {
        buildInputs = with pkgs; [
          # Elixir and Erlang/OTP
          elixir_1_15
          erlang_26
          hex # Elixir package manager
          rebar3 # Erlang build tool
          elixir_ls # Language server for Elixir
 
          # Phoenix Framework
          nodejs_20
          pnpm
          postgresql # Optional, for dev database
 
          # Development & Debugging
          gnumake
          inotify-tools # Required for LiveView & `mix phx.server`
          
          # Linting & Static Analysis
          elixirPackages.credo
          elixirPackages.dialyxir
        ];
 
        # Set up the environment
        shellHook = ''
          export MIX_ENV=dev
          export PATH="$HOME/.mix/escripts:$PATH"
 
          # Ensure Phoenix is installed
          if ! mix phx.new --version &> /dev/null; then
            echo "Installing Phoenix..."
            mix archive.install hex phx_new --force
          fi
 
          # Ensure dependencies are installed
          if [ ! -d "deps" ]; then
            echo "Installing Elixir dependencies..."
            mix deps.get
          fi
 
          # Ensure Node.js dependencies are installed
          if [ -f "assets/package.json" ]; then
            echo "Installing Node.js dependencies..."
            cd assets && pnpm install && cd ..
          fi
 
          # Display versions for verification
          echo "Elixir Version: $(elixir --version)"
          echo "Erlang Version: $(erl -eval 'erlang:display(erlang:system_info(otp_release)), halt().' -noshell)"
          echo "Node Version: $(node --version)"
          echo "Phoenix Version: $(mix phx.new --version)"
          echo "Development environment ready!"
        '';
      };
    };
}
 

Java Dev flake

{
  description = "Professional Java development environment with Maven, GraalVM, and debugging tools";
 
  inputs = {
    nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
    flake-utils.url = "github:numtide/flake-utils";
  };
 
  outputs = { self, nixpkgs, flake-utils }:
    flake-utils.lib.simpleFlake {
      inherit self nixpkgs;
      name = "java-dev-env";
      shell = { pkgs }: pkgs.mkShell {
        buildInputs = with pkgs; [
          # GraalVM 21+ (latest stable)
          graalvm21-ce
          maven # Build system
          gradle # Optional, if you prefer Gradle
          
          # Debugging & Profiling
          jdk11 # Needed for JFR & Java Mission Control
          jdk17 # Needed for modern compatibility
          visualvm
          openjdk21
          jmc # Java Mission Control for profiling
          
          # Linting & Code Quality
          checkstyle
          spotbugs
          pmd
 
          # Testing & Mocking
          junit5
          mockito
 
          # Build & Automation
          gnumake
        ];
 
        # Set up the environment
        shellHook = ''
          export JAVA_HOME=${pkgs.graalvm21-ce}
          export PATH=$JAVA_HOME/bin:$PATH
          export MAVEN_OPTS="-XX:+UseG1GC -Xms512m -Xmx2g"
 
          echo "Java Version: $(java -version)"
          echo "Maven Version: $(mvn -version)"
          echo "GraalVM Version: $(native-image --version)"
          echo "Development environment ready!"
        '';
      };
    };
}