From 8e3f3b626b1cb3f89869ff029c0a19b28ea67816 Mon Sep 17 00:00:00 2001 From: andir Date: Wed, 15 Jan 2025 10:31:46 +0100 Subject: [PATCH] =?UTF-8?q?Deploying=20to=20gh-pages=20from=20@=20nixcon/2?= =?UTF-8?q?023.nixcon.org@7ff6272e4b7660ebeb9a20b6d9a1048e271500b9=20?= =?UTF-8?q?=F0=9F=9A=80?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- index.html | 8 ++++---- recordings/index.html | 34 +++++++++++++++++----------------- 2 files changed, 21 insertions(+), 21 deletions(-) diff --git a/index.html b/index.html index fdc4fdbf..4745c3bb 100644 --- a/index.html +++ b/index.html @@ -71,12 +71,12 @@ location data provider of choice

# Sponsors

Gold sponsors -

  • Flox
  • Numtide
  • Determinate Systems
  • Cachix
  • Tweag
  • Flying Circus

+

  • Tweag
  • Flox
  • Numtide
  • Flying Circus
  • Cachix
  • Determinate Systems

Silver sponsors -

  • WorldQuant
  • Hercules CI
  • Helsinki Systems
  • Google
  • garnix
  • WDZ
  • meetwise
  • PDT Partners

+

  • PDT Partners
  • WDZ
  • Google
  • Helsinki Systems
  • WorldQuant
  • meetwise
  • garnix
  • Hercules CI

Bronze sponsors -

  • Open Innovation Network
  • Nixcademy
\ No newline at end of file diff --git a/recordings/index.html b/recordings/index.html index 00c2ad53..0c10943e 100644 --- a/recordings/index.html +++ b/recordings/index.html @@ -1,16 +1,20 @@ NixCon 2023
NixCon 2023 Darmstadt

September 08 – 10 -

AboutLocationTicketsTimelineFAQSponsorsScheduleRecordings
Nix in Space

Nix in Space

.

-

Watch Talk
Flake schemas

Flake schemas

Flakes are a format for distributing Nix-based assets such as Nix packages, development shells, CI jobs and NixOS modules. The flake specification doesn't impose any restrictions on the contents ("outputs") of a flake, and these can be arbitrary Nix values. While this makes flakes very flexible, it means that there is no generic way to find out what a flake provides, or to check its correctness. To work around this, tools such as nix flake show and nix flake check have built-in support for a fixed set of flake output types such as packages and devShells. Unfortunately, this set cannot be extended by users to handle new flake output types.

-

In this talk, I propose flake schemas, which are essentially Nix functions that enumerate the contents of a flake output, including documentation, checks and options. Flake schemas do not impose a type system on flake outputs - it is entirely up to the schema function how it checks the flake output. Flake schemas allow us to remove all output-specific code from commands like nix flake {show, check, search}, making it easier for developers to introduce new output -types.

-

Watch Talk
How to teach Nix in 5 minutes!

How to teach Nix in 5 minutes!

Congratulations, you’ve convinced your friends / peers / coworkers to give Nix a try. Now the hard work starts: you have to actually teach it to them! Nix might be hard to learn, but it sure can be a fun journey! In this talk, Rok Garbas from flox will share the tools and techniques you need to teach Nix to your friends and colleagues…and, most importantly, what NOT to teach.

+

AboutLocationTicketsTimelineFAQSponsorsScheduleRecordings
Daily-driving NixOS on the Librem 5

Daily-driving NixOS on the Librem 5

I've been using a Librem 5 running NixOS for a few months now as my daily driver. Here are the challenges I've faced, what works and what doesn't.

+

Watch Talk
Nix for HPC: the case of cudaPackages

Nix for HPC: the case of cudaPackages

We should briefly see (or recap) what effort it takes today to provision via Nix a typical stack that includes Pytorch and CUDA, see when Nix could still be the better choice, and when Nix may seem to hinder progress. We should try to argue that the obstacles we observe can be eliminated at the nixpkgs level

+

Nixpkgs and NixOS go a long way in stabilising a program's inherently random build and runtime behaviour. Meanwhile the scientific computing software, and the state of the art "AI" research code in particular, heavily rely on dynamic and "impure" deployment techniques. These include e.g. dynamic linkage using "dlopen", unenforced assumptions about paths, distribution of pre-built black-box binaries, largely facilitated by the use of dependency solvers, and more. Sometimes these "impurities" are necessary, as when using driver-aware libraries like OpenGL or CUDA. This seemingly makes it cheaper to relax the requirements to reproducibility set by Nix and embrace tools such as pip, conda, singularity (apptainer) and docker. We should briefly see (or recap) what effort it takes today to provision via Nix a typical stack that includes Pytorch and CUDA, see when Nix could still be the better choice, and when Nix may seem to hinder progress. We should try to argue that the obstacles we observe can be eliminated at the nixpkgs level.

+

P.S. This description is preliminary

+

Watch Talk
How to teach Nix in 5 minutes!

How to teach Nix in 5 minutes!

Congratulations, you’ve convinced your friends / peers / coworkers to give Nix a try. Now the hard work starts: you have to actually teach it to them! Nix might be hard to learn, but it sure can be a fun journey! In this talk, Rok Garbas from flox will share the tools and techniques you need to teach Nix to your friends and colleagues…and, most importantly, what NOT to teach.

Congratulations, you’ve convinced your friends / peers / coworkers to give Nix a try. Now the hard work starts: you have to actually teach it to them! Nix might be hard to learn, but it sure can be a fun journey! In this talk, Rok Garbas from flox will share the tools and techniques you need to teach Nix to your friends and colleagues…and, most importantly, what NOT to teach.

Watch Talk
Impermanence

Impermanence

The Impermanence project aims to make it easy to build systems where the root storage is erased on every boot.

In this talk, I'll go into why and how you would set up a system with ephemeral root storage and how Impermanence can help you manage the state you want to keep between reboots.

Watch Talk
What Flakes needs (technically)

What Flakes needs (technically)

Flakes is seeing widespread and increasing adoption, but some people and projects are still hesitant to move to them because they have requirements that are cumbersome or impossible to address with Nix Flakes in their current incarnation (there are also other reasons, but I will be focusing on the technical ones).

I will talk about the gaps I see in the current design of Flakes, and how these gaps could be filled in the future without compromising the core goals of Flakes. I will also explore the implications that this will have for the broad range of projects already using Flakes as it exists today.

-

Watch Talk
NixCon 2023 Opening Ceremony

NixCon 2023 Opening Ceremony

Opening ceremony for day 2!

+

Watch Talk
Tvix

Tvix

Tvix is a modern design and implementation of the Nix package manager (GPLv3). It brings a modular architecture in which components such as the build environment or package store are replaceable, which enables new use-cases and platforms.

+

This talk will give a status update on the current state of the project, and an outlook on the roadmap.

+

Watch Talk
Nuenv: an experimental derivation builder for Nix

Nuenv: an experimental derivation builder for Nix

Nuenv is an alternative builder for Nix derivations that uses Nushell rather than Bash. It offers enhanced expressiveness and type safety to Nix.

+

While Bash is a tried-and-true and highly well-known quantity, it's not particularly expressive and it has known "footguns" surrounding things like string parsing. Nushell is a recent entry into the world of shells. It's written in Rust and it offers robust data types and safety guarantees that have a lot to potentially offer to Nix. In this talk, I'll teach you not just about Nushell, how I built it, and how it works, but also about the realisation process itself.

+

Watch Talk
NixCon 2023 Opening Ceremony

NixCon 2023 Opening Ceremony

Opening ceremony for day 2!

Watch Talk
Bootstrapping Nix and Linux from TinyCC

Bootstrapping Nix and Linux from TinyCC

Building every operating system starts from something. I'm not as hardcore as the stage0 project folks going from assembly to Guix, but a shorter path from a ~320 KB TinyCC binary to Nix to a proof-of-concept Linux distribution also proved to be a story worth telling.

We'll begin our journey by executing a -nostdlib C program with TinyCC, compile our way out towards a libc and a shell, work through older compilers to modern compilers and build Nix. Then we'll walk the same path again once over, but this time, we'll use Nix. Finally, in a different flake, we'll reimplement some of the founding nixpkgs patterns, work our way from toolchain to Linux and arrive at a bootable .iso. Corners will be cut, hacks will run amock, Nix will be both praised and complained about, reproducibility will be earned hard, and some patches will get upstreamed.

Links: https://github.com/ZilchOS/bootstrap-from-tcc, https://github.com/ZilchOS/core, http://bootstrappable.org

@@ -19,23 +23,19 @@

There are a lot of tools and methods for getting documentation and finding things in Nix but they are often not well publicized and form peoples' private workflows. Substantial progress has been made on this, for instance, with nixd, but there are other methods that still have their place when more advanced tools don't have perfect code context. This talk introduces a novel NixOS-modules ctags implementation allowing finding option definitions nearly instantly. It also presents how to navigate nixpkgs using nix-doc for ctags and to get function documentation in the Nix repl, how to fall back on unsafeGetAttrPos, and how to use the Nix debugger.

I will briefly dive into the internals of NixOS to show the introspection capabilities it provides for where settings come from, and how to load a NixOS configuration into the repl for inspection in the first place.

Watch Talk
Automating testing of NixOS on physical machines

Automating testing of NixOS on physical machines

The NixOS virtual machine testing framework is very powerful, and allows for convenient testing of entire NixOS machines. However, some capabilities can only be tested by booting a physical machine with a given NixOS closure. This talk describes some work done toward the goal of enabling testing NixOS closures on physical machines, with an example of testing NVIDIA Jetson devices using the "jetpack-nixos" project.

-

Watch Talk
Daily-driving NixOS on the Librem 5

Daily-driving NixOS on the Librem 5

I've been using a Librem 5 running NixOS for a few months now as my daily driver. Here are the challenges I've faced, what works and what doesn't.

-

Watch Talk
Nix for HPC: the case of cudaPackages

Nix for HPC: the case of cudaPackages

We should briefly see (or recap) what effort it takes today to provision via Nix a typical stack that includes Pytorch and CUDA, see when Nix could still be the better choice, and when Nix may seem to hinder progress. We should try to argue that the obstacles we observe can be eliminated at the nixpkgs level

-

Nixpkgs and NixOS go a long way in stabilising a program's inherently random build and runtime behaviour. Meanwhile the scientific computing software, and the state of the art "AI" research code in particular, heavily rely on dynamic and "impure" deployment techniques. These include e.g. dynamic linkage using "dlopen", unenforced assumptions about paths, distribution of pre-built black-box binaries, largely facilitated by the use of dependency solvers, and more. Sometimes these "impurities" are necessary, as when using driver-aware libraries like OpenGL or CUDA. This seemingly makes it cheaper to relax the requirements to reproducibility set by Nix and embrace tools such as pip, conda, singularity (apptainer) and docker. We should briefly see (or recap) what effort it takes today to provision via Nix a typical stack that includes Pytorch and CUDA, see when Nix could still be the better choice, and when Nix may seem to hinder progress. We should try to argue that the obstacles we observe can be eliminated at the nixpkgs level.

-

P.S. This description is preliminary

-

Watch Talk
Nix, but with a different frontend

Nix, but with a different frontend

This talk hints at how defining Nix packages (and development shells in particular) with another language than Nix influences the way we think about them, and discuss whether there are lessons to be learned from here for Nixpkgs or Nix itself.

+

Watch Talk
Nix, but with a different frontend

Nix, but with a different frontend

This talk hints at how defining Nix packages (and development shells in particular) with another language than Nix influences the way we think about them, and discuss whether there are lessons to be learned from here for Nixpkgs or Nix itself.

Organist is a Nickel library and tool aimed at serving as the entry point for all the development tools, and featuring in particular a Nickel frontend for Nix as an experiment in changing the surface language. Changing the frontend used was also an occasion of changing the way we declare, compose and override packages, with a framework based on merging records (a la module-system) rather than stacked wrapping functions and explicit fixpoints.

-

Watch Talk
Tvix

Tvix

Tvix is a modern design and implementation of the Nix package manager (GPLv3). It brings a modular architecture in which components such as the build environment or package store are replaceable, which enables new use-cases and platforms.

-

This talk will give a status update on the current state of the project, and an outlook on the roadmap.

-

Watch Talk
Nuenv: an experimental derivation builder for Nix

Nuenv: an experimental derivation builder for Nix

Nuenv is an alternative builder for Nix derivations that uses Nushell rather than Bash. It offers enhanced expressiveness and type safety to Nix.

-

While Bash is a tried-and-true and highly well-known quantity, it's not particularly expressive and it has known "footguns" surrounding things like string parsing. Nushell is a recent entry into the world of shells. It's written in Rust and it offers robust data types and safety guarantees that have a lot to potentially offer to Nix. In this talk, I'll teach you not just about Nushell, how I built it, and how it works, but also about the realisation process itself.

-

Watch Talk
Reinventing the wheel with Zilch

Reinventing the wheel with Zilch

It's been twenty years since Nix was unleashed upon this world, and yet, the only real alternative is Guix‽ Well, not on my watch! I've been working on Zilch for a while now, and it's starting to be ready to be released to the wild. This talk will describe what this fresh new Nix-compatible alternative is, how it came into being, and what the wider Nix community could learn from it.

+

Watch Talk
Reinventing the wheel with Zilch

Reinventing the wheel with Zilch

It's been twenty years since Nix was unleashed upon this world, and yet, the only real alternative is Guix‽ Well, not on my watch! I've been working on Zilch for a while now, and it's starting to be ready to be released to the wild. This talk will describe what this fresh new Nix-compatible alternative is, how it came into being, and what the wider Nix community could learn from it.

Watch Talk
microvm.nix

microvm.nix

microvm.nix builds NixOS for a few virtual machine managers in a few different use-cases

Full virtualization suffers from overhead and performance degradation due to software emulation of real hardware. MicroVMs are optimized by replacing this emulation with interfaces that have been optimized for the virtual machine use-case: VirtIO.

microvm.nix helps you building and running NixOS on different virtual machine managers. You can use it in different use-cases, for example as a more isolated alternative to nixos-container.

Watch Talk
Nix in the Wild

Nix in the Wild

The team at flox has been producing a series of Nix in the Wild articles that showcase users and organizations doing innovative things with Nix. I’d like to take a quick few minutes to share some of these stories and invite others to participate.

-

Watch Talk
NixOS Foundation Board Panel

NixOS Foundation Board Panel

An interactive session with the NixOS Foundation Board, going through the past year and looking into the next.

+

Watch Talk
Nix in Space

Nix in Space

.

+

Watch Talk
Flake schemas

Flake schemas

Flakes are a format for distributing Nix-based assets such as Nix packages, development shells, CI jobs and NixOS modules. The flake specification doesn't impose any restrictions on the contents ("outputs") of a flake, and these can be arbitrary Nix values. While this makes flakes very flexible, it means that there is no generic way to find out what a flake provides, or to check its correctness. To work around this, tools such as nix flake show and nix flake check have built-in support for a fixed set of flake output types such as packages and devShells. Unfortunately, this set cannot be extended by users to handle new flake output types.

+

In this talk, I propose flake schemas, which are essentially Nix functions that enumerate the contents of a flake output, including documentation, checks and options. Flake schemas do not impose a type system on flake outputs - it is entirely up to the schema function how it checks the flake output. Flake schemas allow us to remove all output-specific code from commands like nix flake {show, check, search}, making it easier for developers to introduce new output +types.

+

Watch Talk
NixOS Foundation Board Panel

NixOS Foundation Board Panel

An interactive session with the NixOS Foundation Board, going through the past year and looking into the next.

During this interactive session, board members will share their insights on the current state of Nix, discuss ongoing projects, and foundation plans for the upcoming year.

In addition to sharing the board's roadmap, this panel will also facilitate an open dialogue with the community in the form of Q&A.

Watch Talk
NixCon 2023 Closing Ceremony

NixCon 2023 Closing Ceremony

Closing, thank yous, sponsors, what's next, anything else