[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
01/02: talks: Add JRES 2022 tutorial.
|
From: |
Tobias Geerinckx-Rice |
|
Subject: |
01/02: talks: Add JRES 2022 tutorial. |
|
Date: |
Wed, 22 Jun 2022 12:45:58 -0400 (EDT) |
nckx pushed a commit to branch master
in repository maintenance.
commit 298f1d5f5305b9c0c8f1de0c7c8d3c8d28ac90bc
Author: zimoun <zimon.toutoune@gmail.com>
AuthorDate: Mon Jun 20 05:51:32 2022 +0200
talks: Add JRES 2022 tutorial.
* talks/jres-2022: New directory.
Signed-off-by: Tobias Geerinckx-Rice <me@tobias.gr>
---
talks/jres-2022/.gitlab-ci.yml | 52 +
talks/jres-2022/README | 110 +
talks/jres-2022/demo/commands.txt | 119 +
.../jres-2022/demo/mp4/01-getting-started-1-2.txt | 4 +
talks/jres-2022/demo/mp4/02-getting-started-3.txt | 6 +
talks/jres-2022/demo/mp4/03-getting-started-4.txt | 5 +
talks/jres-2022/demo/mp4/04-getting-started-5.txt | 5 +
talks/jres-2022/demo/mp4/05-getting-started-6.txt | 5 +
talks/jres-2022/demo/mp4/06-profile.txt | 9 +
talks/jres-2022/demo/mp4/07-generations.txt | 8 +
talks/jres-2022/demo/mp4/08-multi-profiles-1.txt | 7 +
talks/jres-2022/demo/mp4/09-shell-ipython.txt | 14 +
talks/jres-2022/demo/mp4/do-chapters.py | 73 +
talks/jres-2022/demo/mp4/videos.txt | 9 +
talks/jres-2022/do-all.sh | 4 +
talks/jres-2022/do-clean.sh | 6 +
talks/jres-2022/do-pres.sh | 8 +
talks/jres-2022/do-supp.sh | 16 +
talks/jres-2022/src/channels.scm | 6 +
talks/jres-2022/src/contenu.tex | 2413 ++++++++++++++++++++
talks/jres-2022/src/example/config-vm-1.scm | 22 +
talks/jres-2022/src/example/config-vm-2.scm | 13 +
talks/jres-2022/src/example/mock-define-python.scm | 9 +
talks/jres-2022/src/example/some-python-bis.scm | 11 +
.../src/example/some-python-with-gcc7.scm | 13 +
talks/jres-2022/src/example/some-python.scm | 6 +
talks/jres-2022/src/header.tex | 86 +
talks/jres-2022/src/listings-scheme.tex | 97 +
talks/jres-2022/src/manifest.scm | 26 +
talks/jres-2022/src/presentation.tex | 70 +
talks/jres-2022/src/static/Guix-white.pdf | Bin 0 -> 8483 bytes
talks/jres-2022/src/static/LOGO-JRES-2022.png | Bin 0 -> 18956 bytes
talks/jres-2022/src/static/cafe-guix.png | Bin 0 -> 17311 bytes
talks/jres-2022/src/static/forest-symlinks.pdf | Bin 0 -> 16418 bytes
talks/jres-2022/src/static/graph-python.png | Bin 0 -> 479843 bytes
.../src/static/guixhpc-logo-transparent-white.pdf | Bin 0 -> 8808 bytes
talks/jres-2022/src/static/u-paris.png | Bin 0 -> 7104 bytes
talks/jres-2022/src/supplement.tex | 281 +++
.../jres-2022/src/support-notes-additionnelles.tex | 58 +
.../support-notes-additionnelles.20220519.pdf | Bin 0 -> 3948392 bytes
talks/jres-2022/talk.20220519.pdf | Bin 0 -> 1077431 bytes
41 files changed, 3571 insertions(+)
diff --git a/talks/jres-2022/.gitlab-ci.yml b/talks/jres-2022/.gitlab-ci.yml
new file mode 100644
index 0000000..6d7f55c
--- /dev/null
+++ b/talks/jres-2022/.gitlab-ci.yml
@@ -0,0 +1,52 @@
+stages:
+ - tex2pdf
+ - deploy
+
+pdf:
+ image:
+ name: zimoun/jres
+ stage: tex2pdf
+ script:
+ - mkdir public && cd src
+ - rubber --pdf presentation.tex
+ - rubber --pdf support-notes-additionnelles.tex
+ - mv *.pdf ../public/
+ artifacts:
+ paths:
+ - public
+ only:
+ - main
+
+pages:
+ image:
+ name: zimoun/jres
+ stage: deploy
+ script:
+ - |
+ cat > public/index.html <<EOF
+ <?xml version="1.0" encoding="utf-8"?>
+ <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
+ "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd";>
+ <html xmlns="http://www.w3.org/1999/xhtml"; lang="en" xml:lang="en">
+ <head>
+ <title>Reproductibilité des environnements logiciels avec GNU
Guix</title>
+ <meta name="author" content="Simon Tournier" />
+ </head>
+ <body>
+ <div id="content" class="content">
+ <h1 class="title">Reproductibilité des environnements logiciels avec GNU
Guix</h1>
+ <ul class="org-ul">
+ <li><a href="presentation.pdf">presentation.pdf</a></li>
+ <li><a
href="support-notes-additionnelles.pdf">support-notes-additionnelles.pdf</a></li>
+ </ul>
+ </div>
+ <p>Simon Tournier</p>
+ <p>JRES 2022 - Marseille</p>
+ </body>
+ </html>
+ EOF
+ artifacts:
+ paths:
+ - public
+ only:
+ - main
diff --git a/talks/jres-2022/README b/talks/jres-2022/README
new file mode 100644
index 0000000..2785cb2
--- /dev/null
+++ b/talks/jres-2022/README
@@ -0,0 +1,110 @@
+# -*- mode:org -*-
+
+Original Git repo: https://gitlab.com/zimoun/jres22-tuto-guix
+SWH archive:
https://archive.softwareheritage.org/swh:1:rev:8a378f2f833dd28ea71d38e7fc45bac10fe122d5
+
+Visible: https://zimoun.gitlab.io/jres22-tuto-guix/
+Web archive:
https://web.archive.org/web/20220520150253/https://zimoun.gitlab.io/jres22-tuto-guix/
+
+This repository contains the all material to run the tutorial about Guix
+presented at [[https://www.jres.org/][JRES 2022]]. The language of the
conference is French, thus this
+material is initially written in French.
+
+The version of the presentation for the D-day is tagged 'pres-d-day'
+corresponnding to commit 6ff987583173ab5a0bc65708f8bf2482c7390eb0.
+
+* Get PDF from source
+
+#+begin_src bash
+ cd src
+ guix time-machine -C channels.scm \
+ -- shell -C -m manifest.scm \
+ -- rubber --pdf presentation.tex
+#+end_src
+
+* Record Gif
+
+#+begin_src bash
+ export PS1="\[\033[0;34m\]alice@laptop:\w$ \[\033[0;30m\] "
+
+ if [ -n "$GUIX_ENVIRONMENT" ]; then
+ export PS1="\[\033[0;34m\]alice@laptop:\w\[\033[0;30m\] [env]$ "
+ fi
+
+#+end_src
+
+#+begin_src bash
+ # Fix <https://issues.guix.gnu.org/51202#3>
+ # addition of: gtk+ gsettings-desktop-schemas
+ guix time-machine -C channels.scm \
+ -- shell peek ffmpeg gtk+ gsettings-desktop-schemas \
+ -- peek
+#+end_src
+
+* Capture Video
+
+#+begin_src bash
+ guix time-machine -C channels.scm \
+ -- shell obs \
+ -- obs
+#+end_src
+
+** Resolution (screen from desktop)
+ - 1920x1080 Base
+ - 1920x1080 Output
+ - Downscale filter: Bicubic (sharpened scaling, 16 samples)x
+ - Common FPS values 60
+
+** Recording / Streaming
+ - 2500 Kbps / audio bitrate 160
+ - Medium file size
+ - mp4
+ - x264
+
+* Chapters
+
+#+begin_src bash
+ guix time-machine -C channels.scm \
+ -- shell ffmpeg python-minimal
+#+end_src
+
+
+Be careful, the Python help is a quick too simplistic script.
+
+#+begin_src bash
+ ffmpeg -i INPUT.mp4 -f ffmetadata META.txt
+ python3 do-chapters.py CHAPS.txt
+ cat META.txt CHAPS.txt.meta > CHAPS.meta
+ ffmpeg -i INPUT.mp4 -i CHAPS.meta -map_metadata 1 -codec copy OUTPUT.mp4
+#+end_src
+
+For each video, end with a title at video length time.
+
+* Merge videos
+
+#+begin_src bash
+ guix time-machine -C channels.scm \
+ -- shell ffmpeg python-minimal
+#+end_src
+
+
+The file =videos.txt= contains the list of videos
+
+#+begin_src text
+ file 'test.mp4'
+ file 'test2.mp4'
+#+end_src
+
+#+begin_src bash
+ ffmpeg -f concat -safe 0 -i videos.txt -c copy demos.mp4
+#+end_src
+
+#+begin_src bash
+ ffmpeg -i INPUT.mp4 -f ffmetadata META.txt
+ python3 do-chapters.py CHAPS.txt CHAPS2.txt
+ cat META.txt merged.meta > video.meta
+ ffmpeg -i video.mp4 -i video.meta -map_metadata 1 -codec copy
video_chapters.mp4
+#+end_src
+
+The Python script =do-chapters.py= reads, at the finest, seconds when it would
+require a finer scale. Especially, see =08-multi-profiles-1.txt=.
diff --git a/talks/jres-2022/demo/commands.txt
b/talks/jres-2022/demo/commands.txt
new file mode 100644
index 0000000..a2f06a7
--- /dev/null
+++ b/talks/jres-2022/demo/commands.txt
@@ -0,0 +1,119 @@
+# -*- mode:org -*-
+
+* 01
+
+guix search dynamically-typed programming language
+guix show python
+
+* 02
+
+which python3
+python3
+guix install python
+guix package --search-paths
+
+which python3
+
+GUIX_PROFILE=/home/alice/.guix-profile
+. $GUIX_PROFILE/etc/profile
+which python3
+python3
+>> import this
+
+* 03
+
+guix insall python-ipython python-numpy
+guix package --search-paths
+which python3
+python3
+import numpy as np
+x = np.linspace(0,1,20)
+which ipython
+ipython
+import numpy as np
+x = np.linspace(0,1,20)
+
+* 04
+
+which ipython
+guix remove python-ipython
+which ipython
+ipython
+
+* 05
+
+guix install python-matplotlib python-scipy
+guix package --search-paths
+python3 plot.py
+
+* 06
+
+env | grep ^PATH
+GUIX_PROFILE=$HOME/.guix-profile
+cat $GUIX_PROFILE/etc/profile
+guix package --search-paths
+guix package --search-paths=prefix
+guix package --search-paths=suffix
+. GUIX_PROFILE/etc/profile # == eval $(guix package --search-paths=prefix)
+clear
+
+ls $GUIX_PROFILE
+guix install tree
+clear
+
+tree -L 1 $GUIX_PROFILE
+
+* 07
+
+guix package --list-generations
+CLICK
+
+which tree
+guix package --roll-back
+which tree
+tree
+
+guix package --list-generations
+CLICK
+
+which ipython
+guix package --switch-generations=2
+ipython
+guix package --list-generations
+
+guix package --switch-generation=5
+ipython
+
+* 08
+
+guix install python-ipython --profile=outils
+guix package --search-paths --profile=outils
+env | grep ^PATH
+eval $(guix package --search-paths=suffix --profile-outils)
+env | grep ^PATH
+CLICK
+which ipython
+tree -L 1 outils
+ls -l
+
+* 09
+
+ls -d */
+cd project-foo && ls
+python3 some-fun.py
+guix shell --manifest=some-python-pkgs.scm
+python3 some-fun.py
+^D
+guix shell -m some-python-pkgs.scm --pure
+ls
+cd ../project-bar
+^D
+guix shell -m some-python-pkgs.scm --container
+ls
+cd ../project-bar
+python3 some-fun.py
+^D
+guix shell -m some-python-pkgs.scm --container python-ipython
+ipython
+^D
+python3 some-fun.py
diff --git a/talks/jres-2022/demo/mp4/01-getting-started-1-2.txt
b/talks/jres-2022/demo/mp4/01-getting-started-1-2.txt
new file mode 100644
index 0000000..2ffb66a
--- /dev/null
+++ b/talks/jres-2022/demo/mp4/01-getting-started-1-2.txt
@@ -0,0 +1,4 @@
+00:00 -
+00:05 guix search
+00:32 guix show
+00:36 done 01
diff --git a/talks/jres-2022/demo/mp4/02-getting-started-3.txt
b/talks/jres-2022/demo/mp4/02-getting-started-3.txt
new file mode 100644
index 0000000..7706020
--- /dev/null
+++ b/talks/jres-2022/demo/mp4/02-getting-started-3.txt
@@ -0,0 +1,6 @@
+00:00 -
+00:22 guix install python
+00:38 guix package --search-paths #1
+00:57 GUIX_PROFILE
+01:10 python3 (from Guix)
+01:22 done 02
diff --git a/talks/jres-2022/demo/mp4/03-getting-started-4.txt
b/talks/jres-2022/demo/mp4/03-getting-started-4.txt
new file mode 100644
index 0000000..366ff4f
--- /dev/null
+++ b/talks/jres-2022/demo/mp4/03-getting-started-4.txt
@@ -0,0 +1,5 @@
+00:00 -
+00:12 guix install python-ipython python-numpy
+02:10 guix package --search-paths #2
+02:15 python3 with numpy
+03:14 done 03
diff --git a/talks/jres-2022/demo/mp4/04-getting-started-5.txt
b/talks/jres-2022/demo/mp4/04-getting-started-5.txt
new file mode 100644
index 0000000..8a0e0b8
--- /dev/null
+++ b/talks/jres-2022/demo/mp4/04-getting-started-5.txt
@@ -0,0 +1,5 @@
+00:00 -
+00:06 ipython
+00:13 guix remove python-ipython
+00:24 ipython (removed)
+00:30 done 04
diff --git a/talks/jres-2022/demo/mp4/05-getting-started-6.txt
b/talks/jres-2022/demo/mp4/05-getting-started-6.txt
new file mode 100644
index 0000000..bb4dbee
--- /dev/null
+++ b/talks/jres-2022/demo/mp4/05-getting-started-6.txt
@@ -0,0 +1,5 @@
+00:00 -
+00:12 guix install python-matplotlib python-scipy
+02:04 guix package --search-paths #3
+02:11 python3 plot.py
+02:18 done 05
diff --git a/talks/jres-2022/demo/mp4/06-profile.txt
b/talks/jres-2022/demo/mp4/06-profile.txt
new file mode 100644
index 0000000..1994571
--- /dev/null
+++ b/talks/jres-2022/demo/mp4/06-profile.txt
@@ -0,0 +1,9 @@
+00:00 -
+00:24 cat $GUIX_PROFILE
+00:34 breath
+00:42 guix package --search-paths=prefix
+00:47 guix package --search-paths=suffix
+01:11 eval $(guix package --search-paths=prefix)
+01:21 ls $GUIX_PROFILE
+01:35 tree $GUIX_PROFILE
+01:38 done 06
diff --git a/talks/jres-2022/demo/mp4/07-generations.txt
b/talks/jres-2022/demo/mp4/07-generations.txt
new file mode 100644
index 0000000..eff2daf
--- /dev/null
+++ b/talks/jres-2022/demo/mp4/07-generations.txt
@@ -0,0 +1,8 @@
+00:00 -
+00:07 guix package --list-generations #1
+00:20 guix package --roll-back
+00:31 guix package --list-generations (4) #2
+00:54 guix package --switch-generation=2
+01:10 guix package --list-generations (2) #3
+01:20 guix package --switch-generation=5
+01:31 done 07
diff --git a/talks/jres-2022/demo/mp4/08-multi-profiles-1.txt
b/talks/jres-2022/demo/mp4/08-multi-profiles-1.txt
new file mode 100644
index 0000000..0479e88
--- /dev/null
+++ b/talks/jres-2022/demo/mp4/08-multi-profiles-1.txt
@@ -0,0 +1,7 @@
+00:00 -
+00:13 guix install --profile
+00:26 guix package --search-paths --profile
+00:54 eval $(guix package --search-paths=suffix --profile)
+01:23 tree profile
+01:27 ls -l profile
+01:29 done 08
diff --git a/talks/jres-2022/demo/mp4/09-shell-ipython.txt
b/talks/jres-2022/demo/mp4/09-shell-ipython.txt
new file mode 100644
index 0000000..9846760
--- /dev/null
+++ b/talks/jres-2022/demo/mp4/09-shell-ipython.txt
@@ -0,0 +1,14 @@
+00:00 -
+00:05 ls -d
+00:17 python3 some-fun.py (fail)
+00:29 guix shell --manifest
+00:37 python3 some-fun.py (success)
+00:41 guix shell --pure
+00:54 exit pure shell
+00:59 guix shell --container
+01:20 exit containerized shell
+01:26 guix shell python-ipython
+01:36 ipython in container
+01:47 exit
+01:55 python3 some-fun.py (fail again)
+01:59 done 09
diff --git a/talks/jres-2022/demo/mp4/do-chapters.py
b/talks/jres-2022/demo/mp4/do-chapters.py
new file mode 100644
index 0000000..9a6a73b
--- /dev/null
+++ b/talks/jres-2022/demo/mp4/do-chapters.py
@@ -0,0 +1,73 @@
+#!/bin/env python3
+
+import re
+
+def read_chapters(filename):
+ print("Read chapters from {}...".format(filename), sep=" ", end="")
+
+ with open(filename, 'r') as f:
+ chapters = list()
+ for line in f:
+ try:
+ x = re.match(r"(\d{2}):(\d{2}) (.*)", line)
+ except:
+ print("Error: excepted format 'XY:uv The title'")
+ return
+
+ mins = int(x.group(1))
+ secs = int(x.group(2))
+ title = x.group(3)
+
+ minutes = mins
+ seconds = secs + (minutes * 60)
+ timestamp = (seconds * 1000)
+ chap = {
+ "title": title,
+ "time": timestamp
+ }
+ chapters.append(chap)
+
+ print("done.")
+ return chapters
+
+
+def generate_meta(chapters, offset=0):
+ print("Generate meta...", sep=" ", end="")
+
+ text = ""
+ for i in range(len(chapters)-1): # Require unnecessary mm:ss Stop
+ chap = chapters[i]
+ title = chap['title']
+ start = chap['time'] + offset
+ end = chapters[i+1]['time']-1 + offset
+ text += f"""
+[CHAPTER]
+TIMEBASE=1/1000
+START={start}
+END={end}
+title={title}
+"""
+
+ print("done.")
+ return text, end
+
+if __name__ == "__main__":
+ import sys
+ try:
+ offset = 0
+ for i, filename in enumerate(sys.argv[1:]):
+ chapters= read_chapters(filename)
+ text, offset = generate_meta(chapters, offset)
+ if len(sys.argv) > 2:
+ out, perm = "merged.meta", 'a'
+ if i == 0:
+ with open(out, 'w') as f:
+ f.write('')
+ else:
+ out, perm = filename + '.meta', 'w'
+ with open(out, perm) as f:
+ f.write(text)
+ print("Wrote {}".format(out))
+ except:
+ print("Error.")
+ sys.exit(1)
diff --git a/talks/jres-2022/demo/mp4/videos.txt
b/talks/jres-2022/demo/mp4/videos.txt
new file mode 100644
index 0000000..521a4e8
--- /dev/null
+++ b/talks/jres-2022/demo/mp4/videos.txt
@@ -0,0 +1,9 @@
+file '01-getting-started-1-2_raw.mp4'
+file '02-getting-started-3_raw.mp4'
+file '03-getting-started-4_raw.mp4'
+file '04-getting-started-5_raw.mp4'
+file '05-getting-started-6_raw.mp4'
+file '06-profile_raw.mp4'
+file '07-generations_raw.mp4'
+file '08-multi-profiles-1_raw.mp4'
+file '09-shell-ipython_raw.mp4'
diff --git a/talks/jres-2022/do-all.sh b/talks/jres-2022/do-all.sh
new file mode 100755
index 0000000..96a9d51
--- /dev/null
+++ b/talks/jres-2022/do-all.sh
@@ -0,0 +1,4 @@
+#!/usr/bin/env bash
+
+./do-pres.sh
+./do-supp.sh
diff --git a/talks/jres-2022/do-clean.sh b/talks/jres-2022/do-clean.sh
new file mode 100755
index 0000000..5121cbb
--- /dev/null
+++ b/talks/jres-2022/do-clean.sh
@@ -0,0 +1,6 @@
+#!/usr/bin/env bash
+
+for ext in vrb aux log nav out snm toc;
+do
+ find src/ -name "*.${ext}" -type f -print -exec rm {} \;
+done
diff --git a/talks/jres-2022/do-pres.sh b/talks/jres-2022/do-pres.sh
new file mode 100755
index 0000000..2e01d14
--- /dev/null
+++ b/talks/jres-2022/do-pres.sh
@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+
+here=$(pwd)
+cd src
+guix time-machine -C channels.scm \
+ -- shell -C -m manifest.scm \
+ -- rubber --pdf presentation.tex
+cd $here
diff --git a/talks/jres-2022/do-supp.sh b/talks/jres-2022/do-supp.sh
new file mode 100755
index 0000000..08dacef
--- /dev/null
+++ b/talks/jres-2022/do-supp.sh
@@ -0,0 +1,16 @@
+#!/usr/bin/env bash
+
+here=$(pwd)
+cd src
+if [ -f presentation.snm ]
+then
+ guix time-machine -C channels.scm \
+ -- shell -C -m manifest.scm \
+ -- rubber --pdf support-notes-additionnelles.tex
+fi
+cd $here
+
+if [ ! -f src/presentation.snm ]
+then
+ ./do-all.sh
+fi
diff --git a/talks/jres-2022/src/channels.scm b/talks/jres-2022/src/channels.scm
new file mode 100644
index 0000000..7df15c6
--- /dev/null
+++ b/talks/jres-2022/src/channels.scm
@@ -0,0 +1,6 @@
+(list (channel
+ (name 'guix)
+ (url "https://git.savannah.gnu.org/git/guix.git";)
+ (branch "master")
+ (commit
+ "791069737c8c51582cc021438dae32eb0fb7b8e0")))
diff --git a/talks/jres-2022/src/contenu.tex b/talks/jres-2022/src/contenu.tex
new file mode 100644
index 0000000..c95066a
--- /dev/null
+++ b/talks/jres-2022/src/contenu.tex
@@ -0,0 +1,2413 @@
+\mode* %Follow up of Beamer configuration when using ignorenonframetext.
+
+\begin{abstract}
+ Ce document s'attache à montrer quelques fonctionnalités de l'outil
\href{https://guix.gnu.org}{GNU Guix}.
+ Il correspond à un tutoriel court d'une durée de 1 heure, cependant les
+ informations données ici peuvent prendre plus de temps.
+\end{abstract}
+
+\indent
+
+GNU Guix est un gestionnaire de paquets transactionnel et déclaratif. Il
+implémente une discipline de gestion de paquet fonctionnelle. Autrement dit,
+le processus de construction et d’installation des paquets est vu comme une
+fonction dans le sens mathématique du terme : cette fonction a des entrées
+(comme des scripts de construction, un compilateur, des bibliothèques ou
+dépendances) et renvoie une construction (comme un programme compilé). En
+tant que fonction pure, son résultat ne dépend que de ses entrées ; par
+exemple, il ne peut pas faire référence à des logiciels ou des scripts qui
+n’ont pas été explicitement passés en entrée. Par conséquent, une fonction de
+construction produit toujours le même résultat quand on lui donne le même
+ensemble d’entrée. Les constructions sont dites reproductibles.
+
+\indent
+
+Basé sur ces fondations, Guix est un gestionnaire d'environnements logiciels :
+il peut utiliser les paquets qu’il connaît pour créer des environnements sous
+différentes formes, temporaires ou «~permanentes~». Un environnement
+(collection de paquets) peut être déclaré par un manifeste pour générer un «
+profil~», chaque profil ayant son propre historique permettant de revenir en
+arrière ou en avant. Un environnement temporaire peut aussi être créé à la
+volée, et optionnellement isolé (conteneur Linux), ou n'autorisant lecture,
+écriture ou réseau que spécifiquement. Aussi, ces environnements peuvent être
+empaquetés dans des images Docker, Singularity ou simplement des archives
+repositionnables. Pour finir, Guix permet, sur le même principe, la
+génération de «~machines virtuelles~» à partir d'une déclaration pouvant
+contenir un système d'exploitation. Une fois installé, Guix ne nécessite pas
+de droits spécifiques pour manipuler ses différents environnements.
+
+\indent
+
+Dans ce tutoriel, nous nous proposons d'illustrer quelques spécificités de
+Guix. Ce tutoriel fait echo à la présentation «~Administration système
+reproductible avec GNU Guix~» par Julien Lepiller au JRES 2019
+(\hrefsf{https://replay.jres.org/videos/watch/c77b3a44-b75f-4c10-9f39-8fb55ae096d7}{vidéo}
+et
+\hrefsf{https://conf-ng.jres.org/2019/document_revision_5343.html?download}{article}).
+
+\begin{center}
+ (Les termes en police \textsf{sans serif} sont des hyperliens.)
+\end{center}
+
+Ce tutoriel n'est qu'une introduction à l'outil Guix. Nous avons pris le
+parti d'une approche aussi didactique que possible. Ce document se veut une
+invitation et non pas un menu exhaustif.
+
+
+
+\thisslide{why}
+\begin{frame}<presentation>[label=why, fragile, plain,
noframenumbering]{Pourquoi j'en suis venu à GNU Guix}
+ \begin{alertblock}{\(\approx\) 2010 \textbf{Thésard}}
+ Développement d'1-2 outils utilisant un gestionnaire de paquets
+ \uline{classique}
+
+ \hfill (Simulation numérique \texttt{C} et \texttt{Fortran} avec Debian /
Ubuntu /
+ \texttt{apt})
+ \end{alertblock}
+
+ \begin{exampleblock}{\(\approx\) 2014 \textbf{Post-doc}}
+ Développement de 2-3 outils utilisant un gestionnaire de paquets sans
+ droit administrateur
+
+ \hfill (Simulation numérique \texttt{Python} et \texttt{C++} avec
\texttt{conda})
+ \end{exampleblock}
+
+ \begin{block}{2016 \textbf{Ingénieur. de Recherche}}
+ \begin{itemize}
+ \item Administration d'un \emph{cluster} (\texttt{modulefiles})
+ \item Utilisation de 10+ outils pour un même projet
+ \end{itemize}
+
+ \hfill (Analyse «~bioinformatique~»)
+ \end{block}
+
+ \begin{center}
+ \textbf{Question : \alert{pourquoi cela fonctionne-t-il pour Alice et pas
pour Bob ? Et vice-versa.}}
+ \end{center}
+\end{frame}
+
+De cette expérience, la question qui se dégage est la continuité du
+déploiement de l'environnement computationnel : comment développer sur son
+ordinateur portable, faire la mise au point sur son ordinateur de bureau et
+calculer massivement sur la grappe de calcul (\emph{cluster}) mutualisée sans
+perdre trop de temps sur des problèmes d'administration ?
+
+Notre motivation dans l'utilisation de Guix est d'apporter une réponse aux
+questions :
+
+\begin{itemize}
+\item Comment refaire demain là-bas ce que l'on a fait hier ici ?
+\item Quelle granularité sur la transparence ?
+\end{itemize}
+
+
+\paragraph{Pour information :}
+\begin{itemize}
+\item \hrefsf{https://docs.conda.io/en/latest/}{Conda} est un gestionnaire
+ d'environnement issu de la communauté Python et visant particulièrement
+ le contexte de logiciels scientifiques.
+\item La
+ \hrefsf{https://modules.readthedocs.io/en/latest/modulefile.html}%
+ {commande \texttt{module}}
+ est un outil largement répandu sur les grappes de calcul qui permet, en
+ jouant sur les variables d'environnement, de charger des outils spécifiques.
+\end{itemize}
+Nous précisons plus loin pourquoi nous ne les considérons pas satisfaisants.
+
+
+
+\begin{frame}<presentation>[plain, noframenumbering]{Ce que nous allons
aborder}
+ \begin{center}
+ \begin{minipage}{0.7\textwidth}
+ \begin{itemize}
+ \item Comment refaire demain là-bas ce que l'on a fait hier ici ?
+ \item Quelle granularité sur la transparence ?
+ \end{itemize}
+ \end{minipage}
+ \end{center}
+
+ \setcounter{tocdepth}{2}
+ \tableofcontents
+\end{frame}
+
+
+\clearpage
+\section{Introduction}
+
+Dans cette section, nous cherchons à souligner le cadre des problèmes et des
+solutions existantes, ce qui permet, nous l'espérons d'avoir une idée où se
+positionne l'outil Guix.
+
+\subsection{Pourquoi seriez-vous intéressé par Guix ?}
+
+Comme nous allons parler de \emph{logiciels}, de \emph{paquets},
+\emph{dépendances}, puis de ce que fait un \emph{gestionnaire de paquets} pour
+créer des environnements computationnels, voici quelques définitions (dans des
+sens très larges) qui permettent de fixer les idées.
+
+
+\thisslide{start}
+\begin{frame}<presentation>[label=start, fragile]{Pour fixer les idées}
+ \begin{tabular}{rl}
+ \rule[-0.3cm]{0cm}{0.3cm} Logiciel
+ & code source ou programme \emph{binaire} associé
+ \\
+ \rule[-0.3cm]{0cm}{0.3cm} Paquet
+ & recette pour configurer, construire, installer un logiciel
+ \\
+ \rule[-0.3cm]{0cm}{0.3cm} Dépendance
+ & autre paquet nécessaire
+ \\
+ \rule[-0.6cm]{0cm}{0.6cm} Gestionnaire de paquets
+ &
+ \begin{minipage}{0.6\linewidth}
+ automatisation du processus traitant la
+ recette du paquet (et ses dépendances)
+ \end{minipage}
+ \\
+ Environnement computationnel
+ &
+ \begin{minipage}{0.6\linewidth}
+ pile de tous les logiciels nécessaires
+ pour la configuration, construction et
+ installation d'une collection de logiciels
+ \end{minipage}
+ \end{tabular}
+
+ \begin{exampleblock}{}
+ \begin{center}
+ Comment Alice et ses collaborateurs peuvent-ils obtenir le même
environnement \\
+ pour \emph{calculer} avec Python et Numpy ?
+ \end{center}
+ \end{exampleblock}
+
+ \begin{alertblock}{}
+ \begin{center}
+ Tuto avec un biais issu d’un environnement plus «~scientifique~» et
moins «~ASR~»
+
+ \textbf{\uline{mais} \red{Guix s’adapte à tous les cas d’usage}}
+ \scriptsize{(ou presque)}
+ \end{center}
+ \end{alertblock}
+\end{frame}
+
+
+Les collaborateurs d'Alice sont Carole, Charlie et Bob. Tous travaillent sur
+des machines différentes avec des distributions GNU/Linux différentes. Dan
+n'a pas d'interaction avec Alice et a sous la main uniquement un document
+(article de recherche ou fichier de configuration).
+
+
+\thisslide{scenarii}
+\begin{frame}<presentation>[label=scenarii, fragile]{Scenarii}
+ \begin{itemize}
+ \item Alice utilise \texttt{python@3.9} et \texttt{numpy@1.20.3}
+ \vspace{-0.25cm}
+ \begin{center}
+ \begin{minipage}{0.75\linewidth}
+ \begin{exampleblock}{}
+\begin{verbatim}
+$ sudo apt install python python-numpy
+\end{verbatim}
+ \end{exampleblock}
+ \end{minipage}
+ \end{center}
+ \item Carole \textbf{collabore} avec Alice\ldots{}
+ mais utilise \texttt{python3.8} et \texttt{numpy@1.16.5} pour un autre
+ projet
+ \vspace{-0.6cm}
+ \begin{center}
+ \begin{minipage}{0.75\linewidth}
+ \begin{exampleblock}{}
+\begin{verbatim}
+$ apt-cache madison python-numpy
+python-numpy | 1:1.16.5-2ubuntu7 | ...
+\end{verbatim}
+ \end{exampleblock}
+ \end{minipage}
+ \end{center}
+ \item Charlie \textbf{mets à jour} son système et \textbf{tout est cassé}
+ \vspace{-0.25cm}
+ \begin{center}
+ \begin{minipage}{0.75\linewidth}
+ \begin{exampleblock}{}
+\begin{verbatim}
+$ sudo apt upgrade
+The following packages have unmet dependencies:
+E: Broken packages
+\end{verbatim}
+ \end{exampleblock}
+ \end{minipage}
+ \end{center}
+ \item Bob utilise les \textbf{\alert{mêmes} versions} qu'Alice mais n'a
+ \textbf{pas le \alert{même} résultat}
+ \item Dan essaie de \textbf{rejouer plus tard} le scénario d'Alice
+ mais rencontre l'\alert{enfer des dépendances}
+ \begin{center}
+ \begin{minipage}{0.75\linewidth}
+ \href{http://repeatability.cs.arizona.edu}%
+ {Repeatability in Computer Science (lien)}
+ \end{minipage}
+ \end{center}
+ \end{itemize}
+\end{frame}
+
+\begin{itemize}
+\item Qui n’a pas été dans la situation de Carole qui devait installer
+ plusieurs versions d'un même logiciel ? Et ces versions peuvent
+ entrer en conflit. En général, par défaut, une distribution Linux
+ installe uniquement une seule version d'un logiciel avec toutes ses
+ dépendances. Le problème est l'endroit où résident ces logiciels, par
+ défaut le dossier nommé \texttt{/usr/}, et il ne peut pas y
+ avoir deux exécutables, par exemple \texttt{python3}, à deux versions
+ différentes, par exemple \texttt{3.9} et \texttt{3.10}. Il faut donc un
logiciel
+ externe qui s'occupe de la gestion de \uline{différentes versions} (et leurs
+ dépendances).
+\item Qui n'a pas été dans la situation de Charlie la veille d'un évènement
+ important et plus rien ne fonctionnait ? À ma connaissance, cette
+ difficulté de \uline{mise à jour} est une difficulté des administrateurs
+ systèmes de machine partagée : une fois la mise à jour faite, s'il y a
+ de la casse, pas de possibilités de \uline{revenir en arrière}.
+\item Qui n'a pas été dans la situation de Bob «~pourquoi cela ne fonctionne
+ pas pour moi, et pourtant tout est pareil~» ? Car peut-être que les
+ versions \texttt{python} et \texttt{numpy} de Bob sont bien les mêmes que
+ celles d’Alice, mais le problème est : est-ce bien le cas pour toutes les
+ dépendances et toutes les dépendances de dépendances ?
+\item Qui n’a pas été dans la situation de Dan en lisant un article
+ scientifique ou un tutoriel ou une documentation ? Le problème est qu’il
+ est difficile de s’assurer que la liste des logiciels requis (ainsi que
+ toutes les dépendances et leurs dépendances) sont à la bonne version sur
+ deux systèmes différents à deux moments différents.
+\end{itemize}
+
+Pour résumer, les problèmes sont :
+
+\begin{enumerate}
+\item installer le logiciel ainsi que toutes les dépendances,
+\item installer plusieurs versions d’un même logiciel,
+\item capturer l’état complet du système.
+\end{enumerate}
+
+
+
+\thisslide{solutions}
+\begin{frame}<presentation>[label=solutions, fragile]{Solution(s)}
+ \begin{enumerate}
+ \item gestionnaire de paquets : APT (Debian/Ubuntu), YUM (RedHat), etc.
+ \item gestionnaire d'environnements : Modulefiles, Conda, etc.
+ \item conteneur : Docker, Singularity
+ \end{enumerate}
+
+ \begin{alertblock}{}
+ \begin{center}
+ Guix = \#1 + \#2 + \#3
+ \end{center}
+ \end{alertblock}
+
+ \begin{description}
+ \item[APT, Yum] Difficile de faire coexister plusieurs versions ou
+ revenir en arrière ?
+ \item[Modulefiles] Comment sont-ils maintenus ? (qui les utilise sur son
+ \emph{laptop} ?)
+ \item[Conda] Quelle granularité sur la transparence ? (qui sait comment a
+ été produit PyTorch dans \texttt{pip install torch} ?
+ \href{http://hpc.guix.info/blog/2021/09/whats-in-a-package/}%
+ {\scriptsize{(lien)}})
+ \item[Docker] Dockerfile basé sur APT, YUM etc.
+ \begin{minipage}{1.0\linewidth}
+ \begin{exampleblock}{}
+\begin{verbatim}
+RUN apt-get update && apt-get install
+\end{verbatim}
+ \end{exampleblock}
+ \end{minipage}
+ \end{description}
+\end{frame}
+
+Rappelons brièvement les termes des solutions :
+\begin{itemize}
+\item un gestionnaire de paquets automatise le processus pour configurer,
+ construire et installer le logiciel ainsi que toutes les dépendances,
+\item un gestionnaire d'environnements autorise la coexistence de plusieurs
+ versions d'un même logiciel, le plus souvent en jouant sur les variables
+ d’environnement,
+\item un conteneur fournit tous les binaires pour être transporté d’une
+ machine à l’autre et donc fonctionne indépendamment de la configuration de
+ la machine hôte.
+\end{itemize}
+
+\bigskip
+
+La double difficulté majeure est :
+\begin{itemize}
+\item d’une part, un contrôle fin dans la production du binaire,
+\item d’autre part, la reproductibilité, au sens «~refaire ailleurs~» (autre
+ configuration, autre moment).
+\end{itemize}
+
+\medskip
+
+Guix, en étant un gestionnaire d’environnements sous \emph{stéroïde}, tente de
+répondre à cette double difficulté.
+
+
+
+\thisslide{interet}
+\begin{frame}<presentation>[label=interet]{Concrètement}
+ Soit
+ \begin{itemize}
+ \item vous vous reconnaissez dans un scénario,
+ \item vous n'êtes pas satisfait par une des solutions,
+ \item vous êtes curieux d'un nouveau outil.
+ \end{itemize}
+
+ \bigskip
+
+ Dans les 3 cas, ce tutoriel illustre :
+
+ \begin{itemize}
+ \item Comment faire en pratique avec GNU Guix.
+ \item Quel est le problème à traiter ? Et pourquoi c'est compliqué.
+ \end{itemize}
+
+ \begin{alertblock}{}
+ \begin{center}
+ Guix est un gestionnaire d'environnements sous \emph{stéroïde}
+ \end{center}
+ \end{alertblock}
+
+ Ce tutoriel est complémentaire de la présentation de Julien Lepiller en
+ 2019
+
(\href{https://replay.jres.org/videos/watch/c77b3a44-b75f-4c10-9f39-8fb55ae096d7}{vidéo}
+ et
+
\href{https://conf-ng.jres.org/2019/document_revision_5343.html?download}{article})
+\end{frame}
+
+
+
+\thisslide{steroide}
+\begin{frame}<presentation>[label=steroide]{\emph{Stéroïde} signifie\dots}
+ \begin{tabular}{lr}
+ un \uline{\textbf{gestionnaire de paquets}}
+ & (comme APT, Yum, etc.)
+ \\
+ \ \ transactionnel et déclaratif
+ & (revenir en arrière, versions concurrentes)
+ \\
+ \ \ \ \ qui produit des \uline{\textbf{\emph{packs} distribuables}}
+ & (conteneur Docker ou Singularity)
+ \\
+ \ \ \ \ \ \ qui génèrent des \textbf{\uline{\emph{machines virtuelles}}
isolées}
+ & (\emph{à la} Ansible ou Packer)
+ \\
+ \ \ \ \ \ \ \ \ sur lequel on construit une distribution Linux
+ & (nous n'en parlerons pas)
+ \\
+ \ \ \ \ \ \ \ \ \ \ \dots et aussi une bibliothèque Scheme\dots
+ & (nous n'en parlerons pas, non plus)
+ \end{tabular}
+
+ \begin{alertblock}{}
+ Ce tuto court est un coup de projecteur sur :
+ \begin{itemize}
+ \item la gestion de paquets \emph{fonctionnelle}
+ \item création de \emph{machines virtuelles}
+ \end{itemize}
+ \begin{center}
+ \textbf{\alert{Ce que nous présentons fonctionne sur n'importe quelle
+ distribution Linux}}
+ \end{center}
+ \end{alertblock}
+ \begin{flushright}
+ \small{%
+ (Facile à essayer\dots)
+ }
+ \end{flushright}
+\end{frame}
+
+\paragraph{Convention.} Nous notons \texttt{foo@1.2} pour le logiciel
+\texttt{foo} à la version \texttt{1.2}. Usuellement, une ligne commençant par
+\texttt{\$} (dollar) représente une commande \emph{shell}, ainsi que par la
suite
+toutes les lignes commençant par \texttt{guix}. La commande \texttt{sudo}
+signifie des droits administrateur.
+
+
+\clearpage
+\subsection{Installation de GNU Guix}
+
+Il est important de noter en tout premier lieu le
+\hrefsf{https://guix.gnu.org/en/manual/devel/fr/}{manuel} (traduit en français)
+qui fournit le point d’entrée pour l’installation et la configuration. La
+version de référence est la \hrefsf{https://guix.gnu.org/en/manual/devel/en/}%
+{version anglaise}.
+
+\subsubsection{Installation recommandée}
+
+Nous recommandons d’installer Guix sur une distribution Linux, voir la section
+\href{https://guix.gnu.org/en/manual/devel/fr/guix.fr.html#Installation-binaire}%
+{\textsf{Installation binaire}} du manuel. En tant que \texttt{root} (avec
+les droits administrateur), il faut exécuter les commandes :
+
+\begin{verbatim}
+cd /tmp
+wget https://git.savannah.gnu.org/cgit/guix.git/plain/etc/guix-install.sh
+chmod +x guix-install.sh
+./guix-install.sh
+\end{verbatim}
+
+\paragraph{Attention.} Nous vous recommandons de parcourir le script
\emph{shell}
+\texttt{guix-install.sh} et de ne pas l’exécuter aveuglément. Ce script fait
+principalement 2 choses :
+\begin{enumerate}
+\item télécharge, installe et configure le démon \texttt{guix-daemon},
+\item crée les différents dossiers nécessaires au bon fonctionnement.
+\end{enumerate}
+
+\paragraph{Cette installation n'interfère en rien avec la distribution hôte.}
+Pour «~désinstaller~» Guix, il suffit de supprimer les dossiers \texttt{/gnu},
+\texttt{/var/guix}, \texttt{\$HOME/\{.cache,.config\}/guix},
+\texttt{/root/.config/guix} et les mécanismes de complétion de \emph{shell}
+(p. ex. \texttt{/etc/bash\_completion.d}).
+
+\paragraph{Remarques.} Pour une utilisation plus agréable, nous recommandons
+d’au\-to\-ri\-ser les substituts binaires (voir la section
+\href{https://guix.gnu.org/manual/devel/fr/guix.fr.html#Substituts}{\textsf{Substituts}})
+lors de l’installation via le script. Nous recommandons aussi de configurer
+\emph{Name Service Switch} (\texttt{nscd}) sur la distribution hôte (voir la
+\href{https://guix.gnu.org/manual/devel/fr/guix.fr.html#Name-Service-Switch-1}{\textsf{section}}
+du manuel pour une explication du pourquoi).
+
+\medskip
+
+Pour des constructions locales, il est aussi possible d’utiliser un mécanisme
+de déchargement (\emph{offload}) sur une machine tierce. Nous renvoyons à la
+section du manuel
+\href{https://guix.gnu.org/manual/devel/fr/guix.fr.html#R_00e9glages-du-d_00e9chargement-du-d_00e9mon}%
+{\textsf{Utiliser le dispositif de déchargement}}.
+
+\medskip
+
+Pour finir, nous recommandons d’installer le paquet \texttt{glibc-locales},
+dans le \emph{profil} \texttt{root} ainsi que dans le \emph{profil}
+utilisateurs (voir la section
+\href{https://guix.gnu.org/manual/devel/fr/guix.fr.html#Regionalisation}%
+{\textsf{Régionalisation}}).
+\begin{center}
+ \texttt{sudo guix install glibc-locales}
+
+ \texttt{guix install glibc-locales}
+\end{center}
+et d’exporter la variable d’environnement
+\begin{center}
+ \texttt{export GUIX\_LOCPATH=\$HOME/.guix-profile/lib/locale}
+\end{center}
+ ce qui évite des messages de \emph{warning}.
+
+
+
+\begin{frame}<presentation>[fragile]{\emph{distro externe}}
+ \begin{alertblock}{}
+ \begin{center}
+ Guix s’installe sur \textbf{\uline{n’importe quelle distribution}} Linux
récente.
+ \end{center}
+ \end{alertblock}
+ Il faut les droits administrateur (\texttt{root}) pour l’installation.
+
+ \begin{exampleblock}{}
+\begin{verbatim}
+$ cd /tmp
+$ wget https://git.savannah.gnu.org/cgit/guix.git/plain/etc/guix-install.sh
+$ chmod +x guix-install.sh
+$ sudo ./guix-install.sh
+\end{verbatim}
+ \end{exampleblock}
+
+ \begin{center}
+ (Quelques réglages supplémentaires sont expliqués dans les notes
+ additionnelles)
+ \end{center}
+
+ Pour commencer :
+ \begin{center}
+ \begin{minipage}{0.75\linewidth}
+\begin{verbatim}
+$ guix help
+\end{verbatim}
+ \end{minipage}
+ \end{center}
+
+\end{frame}
+
+\subsubsection{Autres méthodes d'installation}
+
+\paragraph{Guix System, Guix dans une VM.}
+
+Il nous apparaît plus aisé de commencer par installer Guix sur une
+distribution Linux et d’utiliser l’outil comme gestionnaire de paquets sous
+\emph{stéroïde}. Mais les plus téméraires d’entre vous peuvent vouloir
+installer Guix comme système d’exploitation complet ou dans une machine
+virtuelle. Dans ce cas, le manuel fournit une
+\hrefsf{https://guix.gnu.org/en/manual/devel/fr/guix.fr.html\#Installation-du-syst\_00e8me}%
+{section} dédiée. Nous recommandons d’utiliser
+l’\hrefsf{https://guix.gnu.org/en/manual/devel/fr/guix.fr.html\#Installation-graphique-guid\_00e9e}%
+{installateur graphique}.
+
+\medskip
+
+Par ailleurs, il est à noter que Guix n’a pas un modèle stable versus
+expérimental mais des révisions considérées comme \emph{release},
+intensivement testées mais ne recevant pas de correctifs. Actuellement, c’est
+l’étiquette
+\hrefsf{https://guix.gnu.org/en/blog/2021/gnu-guix-1.3.0-released/}{v1.3.0}
+sortie au mois de mai 2021. Il est possible de télécharger des images soit
+de la version dite «~\hrefsf{https://guix.gnu.org/fr/download/}{standard}~»
+(v1.3.0), soit des images générées à partir des derniers
+\hrefsf{https://guix.gnu.org/fr/download/latest/}{développements}. Chacun a
ses
+avantages et inconvénients :
+\begin{description}
+\item[avantage «~standard~» :] bien testé,
+\item[inconvénient «~standard~» :] potentiel manque de substituts binaires,
+\item[avantage «~derniers développements~» :] inclus les correctifs depuis le
+ dernier étiquetage,
+\item[inconvénient «~derniers développements~» :] potentiellement instable ;
+ ça peut fonctionner parfaitement comme cela peut être cassé.
+\end{description}
+
+\paragraph{Installation via le paquet Debian.} Nous n’avons pas intensivement
+testé cette méthode d’installation, c’est pourquoi nous la ne recommanderions
+pas. Mais elle est peut-être d’intérêt pour certains d’entre vous. La
+version Debian \hrefsf{https://packages.debian.org/bullseye/guix}{Bullseye}
+fournit le paquet Guix :
+\begin{verbatim}
+$ sudo apt install guix
+\end{verbatim}
+
+\paragraph{Installation sur une grappe de calcul.} Les grappes de calcul
+(\emph{cluster}) ont souvent des configurations très spécifiques, nous
+renvoyons à cette
+\hrefsf{https://hpc.guix.info/blog/2017/11/installing-guix-on-a-cluster/}{explications}
+pour les points essentiels. Sinon, nous recommandons de prendre contact avec
+la communauté via p. ex. \texttt{guix-science@gnu.org}.
+
+\subsubsection{Révision de Guix pour ce tutoriel}
+
+Ce tutoriel devrait être pouvoir être joué quelque soit la révision.
+Cependant, il est possible que les exemples fournis évoluent ; comme les
+versions des paquets Python ou autres. La commande, en tant qu’utilisateur
+sans privilège particulier,
+
+\begin{center}
+ \texttt{\$ guix pull -{}-commit=eb34ff1}
+\end{center}
+
+permet de se placer dans l’exact même révision que celle utilisée lors de
+l’écriture de ce document.
+
+\paragraph{Remarques.} Les
+\href{https://guix.gnu.org/manual/devel/fr/guix.fr.html#Serveur-de-substituts-officiel}%
+{\textsf{fermes de substituts officielles}} n’étant pas des ressources
illimitées, il
+est possible que les substituts ne soient plus disponibles dans quelques mois
+ou années après mai 2022. Le projet Guix s’efforce autant que possible
+d’assurer la conservation des substituts binaires qu’il produit et nous
+espérons que cette remarque soit caduque.
+
+\medskip
+
+Dans le cas d’absence de substituts binaires, cela signifie que la commande
+précédente (\texttt{pull}) risque de prendre plus de temps, mais surtout que
+les exemples utilisant les piles logicielles risquent de compiler depuis les
+sources toutes les dépendances (binaires) manquantes de la dite pile. D’un
+côté, c’est pour cela que Guix est un outil puissant pour la reproductibilité.
+
+\medskip
+
+D’un autre côté, si les substituts ne sont plus disponibles, alors il sera
+difficile de suivre ce tutoriel avec votre ordinateur portable et nous
+conseillons donc d’utiliser un
+\href{https://guix.gnu.org/manual/devel/fr/guix.fr.html#R_00e9glages-du-d_00e9chargement-du-d_00e9mon}%
+{\textsf{déchargement (\emph{offload})}}. Ou de saisir l’esprit général et
+d’utiliser vos propres exemples avec substituts.
+
+
+\begin{frame}<presentation>[plain,fragile,noframenumbering]{}
+
+ \vfill{}
+ \begin{center}
+ \textbf{Comment faire la gestion de paquets ?}
+ \end{center}
+
+ \vfill{}
+ \begin{flushright}
+ (Exemple : Alice sans privilège particulier)
+ \end{flushright}
+
+ \vfill{}
+ \begin{minipage}{0.57\linewidth}
+ \begin{alertblock}{}
+ \begin{itemize}
+ \item Démos avec des outils du «~\emph{monde scientifique}~»
+ \item Guix représente 20k+ paquets
+ \scriptsize{(constante progression)}\normalsize{}
+ \item Cela serait identique pour d'autres outils\\
+ \hfill{} comme Nginx, LDAP, SSH, etc.
+ \end{itemize}
+ \end{alertblock}
+ \end{minipage}
+\end{frame}
+
+
+\clearpage
+\section{Gestion de paquets}
+
+À partir de cette section, nous considérons une installation fonctionnelle de
+l’outil Guix sur une distribution Linux récente. Toutes les commandes seront
+exécutées dans un terminal en tant qu’utilisateur régulier (sans droit
+d’administration particulier). La révision de Guix utilisée est
+\texttt{eb34ff1}.
+
+\medskip
+
+Nous recommandons la lecture de la section
+«~\href{https://guix.gnu.org/en/manual/devel/fr/guix.fr.html\#Pour-d\_00e9marrer}{Pour
+ démarrer}~» du manuel.
+
+\subsection{Utilisation de \texttt{guix package}}
+
+Guix est avant tout un gestionnaire de paquets, c.-à-d. que Guix automatise le
+processus pour configurer, construire et installer le logiciel ainsi que
+toutes les dépendances. Les fonctionnalités de gestion de paquets sont
+données par la commande \texttt{guix package}.
+
+
+\begin{frame}<presentation>[fragile]{Commandes basiques}
+ \begin{center}
+ Exemple : outils scientifiques classiques en Python
+ \end{center}
+
+ \bigskip
+
+ \begin{center}
+ (\texttt{demo/getting-started})
+ \end{center}
+\end{frame}
+
+
+
+\thisslide{cli-basic}
+\begin{frame}<presentation>[label=cli-basic, fragile]{Commandes basiques :
Résumé}
+ \begin{exampleblock}{}
+ \begin{verbatim}
+guix search dynamically-typed programming language # 1.
+guix show python # 2.
+guix install python # 3.
+guix install python-ipython python-numpy # 4.
+guix remove python-ipython # 5.
+guix install python-matplotlib python-scipy # 6.
+\end{verbatim}
+ \end{exampleblock}
+
+ \begin{center}
+ alias de \texttt{guix package}, p. ex. \verb+guix package --install+
+ \end{center}
+
+ \begin{alertblock}{Transactionnel}
+\begin{verbatim}
+guix package --install python # 3.
+guix package --install python-ipython python-numpy # 4.
+guix package -r python-ipython -i python-matplotlib python-scipy # 5. & 6.
+\end{verbatim}
+ \end{alertblock}
+\end{frame}
+
+Les commandes précédentes sont des alias de la commande \texttt{guix package}.
+
+\begin{center}
+ \begin{tabular}{clcl}
+ $1.$ & \texttt{guix search} & $\leftrightarrow$ & \texttt{guix package
-{}-search=}\\
+ $2.$& \texttt{guix show} & $\leftrightarrow$ & \texttt{guix package
-{}-show=}\\
+ $3.$& \texttt{guix install} & $\leftrightarrow$ & \texttt{guix package
-{}-install=}\\
+ $4.$& \texttt{guix remove} & $\leftrightarrow$ & \texttt{guix package
-{}-remove=}\\
+ \end{tabular}
+\end{center}
+
+Pour de plus amples informations sur chacune des commandes, se référer au
+manuel (section
+\hrefsf{https://guix.gnu.org/en/manual/devel/fr/guix.fr.html\#Invoquer-guix-package}%
+{Invoquer \texttt{guix package}}). En quelques mots :
+
+\begin{enumerate}
+\item \texttt{guix search} : Recherche dans tous les paquets disponibles les
+ termes \texttt{dynamically-typed programming language} dans les noms,
+ synopsis et descriptions des paquets.
+\item \texttt{guix show} : Affiche les informations relatives au paquet : nom,
version,
+ dépendances, synopsis, description, etc. Par convention si aucune
+ version n’est donnée, il choisit la dernière.
+\item \texttt{guix install} : Installe le paquet \texttt{python}, par
+ convention si aucune version n’est donnée, il choisit la dernière.
+\item Installe les paquets \texttt{python-ipython python-numpy}.
+\item \texttt{guix remove} : Supprime l’installation du paquet
\texttt{python-ipython}.
+\item Installe les deux autres paquets \texttt{python-matplotlib python-scipy}.
+\end{enumerate}
+
+Il est important de noter que les opérations d'installation / suppression
+sont transactionnelles. D'une part, une action (transaction) peut comporter
+plusieurs opérations. D'autre part, cette action (transaction) transforme un
+état dans un autre et ces états sont sauvegardés (voir \emph{génération} et
+la {Gestion de \emph{profil}}, section \textsf{\ref{sec:profil}}) ; en
+d'autres termes il est toujours possible de défaire une action (transaction).
+
+
+
+\thisslide{pkg-man}
+\begin{frame}<presentation>[label=pkg-man]{Guix, un gestionnaire de paquets
comme les autres ?}
+ \begin{alertblock}{}
+ \begin{itemize}
+ \item Interface \emph{ligne de commande} comme les autres gestionnaires de
+ paquets
+ \item Installation/suppression sans privilège particulier
+ \item Transactionnel (= pas d'état «~\emph{cassé}~»)
+ \item \emph{Substituts} binaires (téléchargement d'éléments pré-construits)
+ \end{itemize}
+ \end{alertblock}
+ \begin{center}
+ \textbf{Trois fonctionnalités puissantes :}
+ \end{center}
+
+ \begin{exampleblock}{}
+ \begin{itemize}
+ \item Les \emph{profils} et leur composition
+ \item Gestion déclarative
+ \item Environnement isolé à la volée
+ \end{itemize}
+ \end{exampleblock}
+\end{frame}
+
+Toutes ces commandes ressemblent très fortement à toutes celles d’autres
+gestionnaires de paquets, comme \texttt{apt} (Debian/Ubuntu) ou \texttt{yum}
+(RedHat). À la différence qu'il ne faut pas de droits d'administration
+particuliers pour installer des paquets.
+
+\medskip
+
+Nous allons maintenant illustrer trois fonctionnalités qui font de Guix le
+couteau suisse des gestionnaires d'environnement. Les \emph{profils}
+permettent de garder sous contrôle l'installation d'outils (paquets)
+potentiellement en conflit. La \emph{gestion déclarative} permet de
+configurer les \emph{profils} dans un style de programmation fonctionnelle.
+Pour finir, nous verrons la création à la volée d'un environnement
+computationnel et optionnellement isolé.
+
+\clearpage
+\subsection{Gestion de \emph{profil}}
+\label{sec:profil}
+
+Un notion essentielle dans l’utilisation de Guix est la notion de
+\emph{profil} : un répertoire contenant les paquets installés.
+
+
+\thisslide{profil-default}
+\begin{frame}<presentation>[label=profil-default, fragile]{Le \emph{profil}
par défaut}
+ Les commandes d’installation précédentes finissent avec le conseil :
+ \begin{exampleblock}{}
+\begin{verbatim}
+hint: Consider setting the necessary environment variables by running:
+
+ GUIX_PROFILE="/home/alice/.guix-profile"
+ . "$GUIX_PROFILE/etc/profile"
+
+Alternately, see `guix package --search-paths -p "$HOME/.guix-profile"'.
+\end{verbatim}
+ \end{exampleblock}
+
+ \begin{alertblock}{}
+ \begin{center}
+ \texttt{\$HOME/.guix-profile} est le \emph{profil} par défaut
+ \end{center}
+ \end{alertblock}
+\end{frame}
+
+Il n'est pas nécessaire d'entrer dans ces détails pour utiliser Guix mais ce
+tutoriel nous apparaît opportun pour décortiquer.
+
+\medskip
+
+Le profil par défaut est \texttt{\$HOME/.guix-profile} et nous pouvons
+afficher les variables d'environnements de ce profil avec la commande
+\begin{verbatim}
+$ guix package --search-paths -p $HOME/.guix-profile
+export PATH="/home/alice/.guix-profile/bin"
+export GUIX_PYTHONPATH="/home/alice/.guix-profile/lib/python3.9/site-packages"
+export GI_TYPELIB_PATH="/home/alice/.guix-profile/lib/girepository-1.0"
+export XDG_DATA_DIRS="/home/alice/.guix-profile/share"
+\end{verbatim}
+et ce profil est un lien symbolique
+\begin{verbatim}
+$ file $HOME/.guix-profile
+/home/alice/.guix-profile: symbolic link to
+ /var/guix/profiles/per-user/alice/guix-profile
+\end{verbatim}
+et vers quoi pointe le lien ?
+\begin{verbatim}
+$ readlink -f $HOME/.guix-profile
+/gnu/store/jy24qk0vdgqvysnryldqn52b3fg03z10-profile
+\end{verbatim}
+où \texttt{jy24qk...} ressemble à un condensat (\emph{hash}) -- il condense
+toutes les entrées (dépendances) pour la construction dudit profil. Le type
+du lien pointé est un dossier
+\begin{verbatim}
+$ file $(readlink -f ~/.guix-profile)
+/gnu/store/jy24qk0vdgqvysnryldqn52b3fg03z10-profile: directory
+\end{verbatim}
+et ce dossier contient
+\begin{verbatim}
+$ tree -L 1 $(readlink -f ~/.guix-profile)
+/gnu/store/jy24qk0vdgqvysnryldqn52b3fg03z10-profile
+|-- bin
+|-- etc
+|-- include
+|-- lib
+|-- manifest
+`-- share
+\end{verbatim}
+
+
+
+\thisslide{profil}
+\begin{frame}<presentation>[label=profil, fragile]{Mais qu'est-ce un
\emph{profil} ?}
+ \begin{center}
+ Filesystem Hierarchy Standard (FHS) = norme de la hiérarchie des systèmes
+ de fichiers
+
+ \medskip
+
+ (définit l'arborescence et contenu des répertoires systèmes pour les
systèmes Unix)
+ \end{center}
+
+ \begin{exampleblock}{}
+ \begin{Verbatim}
+ usr
+ |-- bin Binaires exécutables
+ |-- etc Fichiers de configuration
+ |-- include Entêtes des bibliothèques partagées
+ |-- lib Bibliothèques partagées
+ |-- share Documentation entre autres
+ \end{Verbatim}
+ \end{exampleblock}
+
+ \begin{center} % XXXX: demo ?
+ \verb+ls $HOME/.guix-profile+
+ \end{center}
+
+ \begin{alertblock}{}
+ \begin{center}
+ Un \emph{profil} est un répertoire contenant les paquets installés
+ \end{center}
+ \end{alertblock}
+\end{frame}
+
+\textbf{Conclusion}
+\begin{itemize}
+\item Un \emph{profil} contient les variables d’environnements ajustées.
+\item Un \emph{profil} est un lien symbolique.
+\item Un \emph{profil} pointe vers un dossier du dépôt (\emph{store}).
+\item Un \emph{profil} a la structure hiérarchique de FHS (comme
\texttt{/usr/}).
+\end{itemize}
+
+Sans entrer dans les détails, le dépôt (\emph{store}) est monté à
+\texttt{/gnu/store} et il est dédupliqué, c.-à-d. qu'il pourrait être vu comme
+une forêt de liens symboliques (voir \textsf{Fig. \ref{fig:symlinks}}).
+\begin{figure}[!htb]
+ \centering
+ \includegraphics[width=0.7\textwidth]{static/forest-symlinks.pdf}
+ \caption{Forêt de liens symboliques \label{fig:symlinks}}
+\end{figure}
+L'exemple \textsf{Fig. \ref{fig:symlinks}} utilise des paquets qui sont
classiques
+dans le contexte bioinformatique. Cependant, on peut se poser la question des
+nombres 42 et 43. Examinons ceci.
+\begin{verbatim}
+$ ls -l /var/guix/profiles/per-user/alice/guix-profile*
+/var/guix/profiles/per-user/alice/guix-profile -> guix-profile-5-link
+/var/guix/profiles/per-user/alice/guix-profile-0-link ->
/gnu/store/0fv...-profile
+/var/guix/profiles/per-user/alice/guix-profile-1-link ->
/gnu/store/vsr...-profile
+/var/guix/profiles/per-user/alice/guix-profile-2-link ->
/gnu/store/k3c...-profile
+/var/guix/profiles/per-user/alice/guix-profile-3-link ->
/gnu/store/dks...-profile
+/var/guix/profiles/per-user/alice/guix-profile-4-link ->
/gnu/store/33d...-profile
+/var/guix/profiles/per-user/alice/guix-profile-5-link ->
/gnu/store/jy2...-profile
+\end{verbatim}
+Par conséquent, l'historique est en quelque sorte conservé et Guix donne la
+possibilité de changer vers quoi les liens pointent. Le profil lui-même est
+donc immutable.
+
+
+
+\thisslide{profil2}
+\begin{frame}<presentation>[label=profil2, fragile]{Exemples de
fonctionnalités des \emph{profils}}
+
+ \begin{alertblock}{}
+ \begin{itemize}
+ \item Historique des paquets installés / supprimés
(\verb+--list-generations+)
+ \item Retour en arrière (\verb+--roll-back+ or \verb+--switch-generations+)
+ \end{itemize}
+ \end{alertblock}
+
+ \begin{center}
+ (\texttt{demo/generations})
+ \end{center}
+
+ \begin{alertblock}{}
+ \begin{itemize}
+ \item Profils indépendants
+ \item Contrôle fin des variables d'environnement (\verb+--search-paths+)
+ \item Composition
+ \end{itemize}
+ \end{alertblock}
+
+ \begin{center}
+ (\texttt{demo/multi-profiles})
+ \end{center}
+\end{frame}
+
+Une première fonctionnalité est la conservation des actions (installation ou
+suppression) sur un profil. Chaque action complète va créer une
+\emph{génération} (état) -- c'est en ce sens que Guix est transactionnel. Il
+est donc possible de revenir en arrière (\texttt{roll-back}) ou de basculer
+vers une autre génération (\texttt{switch-generation}). Par exemple,
+\begin{verbatim}
+$ guix package --list-generations
+Generation 1 avril 21 2022 20:22:28
+ + python 3.9.9 out /gnu/store/sz7...-python-3.9.9
+
+Generation 2 avril 21 2022 20:38:30
+ + python-numpy 1.20.3 out /gnu/store/s89...-python-numpy-1.20.3
+ + python-ipython 7.27.0 out /gnu/store/rj0...-python-ipython-7.27.0
+
+Generation 3 avril 21 2022 20:41:38
+ - python-ipython 7.27.0 out /gnu/store/rj0...-python-ipython-7.27.0
+
+Generation 4 avril 21 2022 21:05:14
+ + python-scipy 1.7.3 out /gnu/store/x3x...-python-scipy-1.7.3
+ + python-matplotlib 3.5.1 out /gnu/store/inl...-python-matplotlib-3.5.1
+
+Generation 5 avril 21 2022 21:19:34 (current)
+ + tree 2.0.2 out /gnu/store/b9z..-tree-2.0.2
+\end{verbatim}
+où le symbole \texttt{+} représente un ajout de paquet, le symbole \texttt{-}
+une suppression pour chaque génération et \texttt{guix package
+ -{}-list-installed} fournit la liste complète des paquets de l'état courant.
+
+\medskip
+
+Il est possible de supprimer une (ou plusieurs) génération avec l'option
+\texttt{-{}-delete-generations}. Nous renvoyons à la section du manuel sur le
+\href{https://guix.gnu.org/manual/devel/fr/guix.fr.html#Invoquer-guix-gc}%
+{\textsf{ramasse-miette}} qui permet une gestion de ce que contient le dépôt
+(\emph{store}).
+
+\bigskip
+
+Pour finir, autant de profils que l'on souhaite peuvent être créés. D'une
+part, chaque profil est indépendant et d'autre part, ils peuvent être
+composés. En d'autres termes
+\begin{verbatim}
+guix install python --profile=interpreteur
+guix install python-numpy --profile=bibliotheque
+eval $(guix package --search-paths=prefix -p interpreteur -p bibliotheque)
+\end{verbatim}
+et l'environnement résultant contiendra \texttt{python} et
+\texttt{python-numpy}. D'autre part, l'ajout des variables d'environnement
+(\texttt{search-paths}) est contrôlable avec la valeur de l'argument
+\texttt{prefix}, \texttt{suffix} ou \texttt{exact} ; les variables
+d'en\-vi\-ron\-nement peuvent être, respectivement, placées avant ou après
+les valeurs actuelles, ou remplacer les valeurs actuelles.
+
+\bigskip
+
+Nous recommandons
+\href{https://guix.gnu.org/en/cookbook/fr/guix-cookbook.fr.html#Gestion-avanc_00e9e-des-paquets}%
+{\textsf{Les profils en pratique}} du livre de cuisine.
+
+
+\thisslide{profil3}
+\begin{frame}<presentation>[label=profil3, fragile]{\emph{Profil}, en résumé}
+ Les paquets sont installés dans un \emph{profil} qui est :
+ $\left. \text{\parbox{0.55\linewidth}{
+ \begin{itemize}
+ \item un lien symbolique,
+ \item pointant vers un élément du dépôt (\emph{store}),
+ \end{itemize}
+ }} \only<1|article:1>{\right.}\only<2-|article:0>{\right\}} $
+ \only<2-|article:0>{%
+ \hfill
+ \begin{minipage}{0.3\linewidth}
+ \begin{alertblock}{Dépôt (\emph{store})}
+ \begin{itemize}
+ \item Monté à \texttt{/gnu/store}
+ \item Dédupliqué
+ \end{itemize}
+ \end{alertblock}
+ \end{minipage}
+ }
+ $\left. \text{\parbox{1.0\linewidth}{
+ \begin{itemize}
+ \item et les éléments ont une structure hiérarchique type FHS (comme
\texttt{/usr/}).
+ \end{itemize}
+ }} \right.$
+
+ \begin{exampleblock}{}
+ \begin{center}
+ On peut créer autant de profils que l’on souhaite
+ \end{center}
+ \end{exampleblock}
+
+ \vfill
+
+ \begin{alertblock}{}
+ \begin{center}
+ \textbf{Toutes les options de \texttt{guix package} s’appliquent à
n’importe quel profil}
+ \end{center}
+ \end{alertblock}
+
+ \vfill
+
+ \begin{center}
+ \texttt{guix install python python-numpy -{}-profile=outils-python}
+ \end{center}
+
+\end{frame}
+
+
+\clearpage
+\subsection{Gestion déclarative}
+
+Il devient vite fastidieux de saisir à l'invite du \emph{shell} la liste des
+paquets et il apparaît naturel de vouloir sauvegarder cette liste dans un
+fichier. Par exemple, il n'est pas rare de versionner cette liste. Guix
+permet ceci, et un peu plus, au travers d'une gestion déclarative.
+
+
+\thisslide{declarative}
+\begin{frame}<presentation>[label=declarative, fragile]{Gestion déclarative}
+ \vspace{-0.3cm}
+ \begin{center}
+ déclaratif = fichier de configuration
+ \end{center}
+
+ \begin{exampleblock}{%
+ Un fichier \texttt{some-python.scm} peut contenir cette déclaration :%
+ }
+
\lstinputlisting[language=Scheme,columns=space-flexible]{example/some-python.scm}
+ \end{exampleblock}
+
+ \begin{center}
+ \verb+guix package --manifest=some-python.scm+
+ \end{center}
+ équivalent à
+ \begin{center}
+ \verb+guix install python python-matplotlib python-numpy python-scipy+
+ \end{center}
+\end{frame}
+
+Le fichier de configuration est usuellement appelé \texttt{manifest}. Il
+contient la liste des paquets comme saisi à l'invite du \emph{shell}. Cette
liste
+est une spécification du manifeste à instancier dans le profil.
+
+
+\thisslide{declarative2}
+\begin{frame}<presentation>[label=declarative2, fragile]{Gestion
\emph{déclarative} : remarques}
+ \begin{description}
+ \item[Version ?] Nous le verrons dans la suite
+ \medskip
+ \item[Langage ?] \emph{Domain-Specific Language} (DSL) basé sur
+ \href{https://fr.wikipedia.org/wiki/Scheme}%
+ {Scheme}
+ \href{https://fr.wikipedia.org/wiki/Lisp}%
+ {(«~langage fonctionnel Lisp~»)}%
+ \medskip
+ \begin{itemize}
+ \item \verb+(Oui (quand (= Lisp parenthèses) (baroque)))+
+ \medskip
+ \item Mais \uline{\textbf{continuum}} :
+ \begin{enumerate}
+ \item configuration (\texttt{manifest})
+ \item définition des paquets (ou services)
+ \item extension
+ \item le c\oe ur est écrit aussi en Scheme
+ \end{enumerate}
+ \end{itemize}
+ \end{description}
+ \begin{alertblock}{}
+ \begin{center}
+ Guix est \textbf{adaptable} à ses besoins
+ \end{center}
+ \end{alertblock}
+
+ \vfill
+
+ \footnotesize{%
+ \href{https://fr.wikipedia.org/wiki/Programmation_déclarative}{Déclaratif}
+ vs
+ \href{https://fr.wikipedia.org/wiki/Programmation_impérative}{Impératif}
+ } \hfill \scriptsize{%
+ (%
+ et non pas
+ % \hfill
+ Donnée inerte vs Programme%
+ )
+ }
+
+ \footnotesize{%
+ Programmation déclarative = programmation fonctionnelle ou descriptive
(\LaTeX) ou logique (Prolog)
+ }
+\end{frame}
+
+Tout d'abord, il est important de noter que \emph{déclaratif} ne signifie pas
+donnée inerte, comme l'on pourrait retrouver avec un format comme
+\hrefsf{https://fr.wikipedia.org/wiki/Comma-separated_values}{CSV} ou
+\hrefsf{https://fr.wikipedia.org/wiki/YAML}{YAML}. Le terme
+\hrefsf{https://fr.wikipedia.org/wiki/Programmation_déclarative}{déclaratif}
+(«~on décrit le \emph{quoi}, c'est-à-dire le problème~») s'oppose à
+\hrefsf{https://fr.wikipedia.org/wiki/Programmation_impérative}{impératif}
+(«~on décrit le \emph{comment}, c'est-à-dire la structure de contrôle
+correspondant à la solution~»).
+
+Avec le \textsf{Tableau \ref{tab:cloc}}, nous espérons illustrer ce
+\emph{continuum} dans Guix.
+
+\begin{table}[!htb]
+ \centering
+ \begin{tabular}{l|rrrr}
+ Language &files &blank &comment &code\\
+ \hline
+ Scheme &1105 &47761 &63485 &804643\\
+ ~\texttt{\textasciigrave-{}-~packages} &538 &26787 &37972 &642152\\
+ ~\texttt{\textasciigrave-{}-~guix} &272 &9699 &13346 &75577\\
+ ~\texttt{\textasciigrave-{}-~services} &53 &3232 &2764 &26723\\
+ C++ & 50 &3425 &2198 &10635\\
+ make & 4 &213 &292 &3087\\
+ Bourne Shell & 29 &850 &1213 &2891
+ \end{tabular}
+ \caption{\texttt{cloc -{}-exclude-ext=patch -{}-exclude-dir=po .}}
+ \label{tab:cloc}
+\end{table}
+
+Les paquets, les services et Guix lui-même sont écrits dans le même langage
+\hrefsf{https://fr.wikipedia.org/wiki/Scheme}{Scheme} (pour être précis
+\hrefsf{https://www.gnu.org/software/guile/}{GNU Guile}). Ce langage est
+dérivé du langage fonctionnel Lisp et il facilite la définition de langages
+dédiés (DSL, \emph{domain-specific language}).
+
+
+
+\thisslide{trans-declarative}
+\begin{frame}<presentation>[label=trans-declarative, fragile]{Gestion
déclarative : exemple de transformation
+ \small{%
+ (\href{https://fr.wikipedia.org/wiki/Machine_de_Rube_Goldberg}%
+ {machine de \smiley{Goldberg} \tiny{(lien)}})}} % \ddot\smile
+ \vspace{-0.3cm}
+ \begin{exampleblock}{}
+
\lstinputlisting[language=Scheme,columns=space-flexible]{example/some-python-bis.scm}
+ \end{exampleblock}
+ Guix DSL, \somevariable{\emph{variables}}, \someguile{Scheme} et
\somestring{chaîne de caractères}.
+\end{frame}
+
+Par exemple, nous illustrons la capacité de manipuler
+\emph{programmatiquement} les paquets. Avec le mots-clé \texttt{append}, deux
+listes sont concaténées. Le mot-clé \texttt{map} applique une fonction aux
+éléments d’une liste et retourne une liste. Le mot-clé \texttt{lambda}
+définit une fonction (anonyme).
+
+\medskip
+
+Ainsi, il est possible de déclarer des transformations à appliquer aux
+paquets.
+
+
+\clearpage
+\paragraph{Transformation de paquets.}
+Les
+\href{https://guix.gnu.org/manual/devel/fr/guix.fr.html#Options-de-transformation-de-paquets}%
+{\textsf{transformations de paquets}} sont des options qui rendent possible la
+définition de variantes de paquets -- par exemple, des paquets construit en
+utilisant une
+\href{https://guix.gnu.org/manual/devel/fr/guix.fr.html#La-cha_00eene-d_0027outils-GCC}%
+{\textsf{chaîne d’outils}} différente que celle par défaut.
+
+
+\thisslide{transformation}
+\begin{frame}<presentation>[label=transformation, fragile]{Transformations de
paquet : survol}
+ \begin{exampleblock}{}
+ \begin{center}
+ Comment utiliser GCC@7 pour compiler le paquet \texttt{python} ?
+ \end{center}
+ \end{exampleblock}
+
+ \begin{center}
+ Un paquet = recette pour configurer, construire, installer un logiciel
+
+ \medskip
+
+ (\texttt{./configure \&\& make \&\& make install})
+ \end{center}
+ La recette définit :
+ \begin{itemize}
+ \item un \blue{code source} et potentiellement des modifications
\emph{ad-hoc} (\verb+patch+)
+ \item des \magenta{outils de construction} (compilateurs, moteur de
+ production etc., p. ex. \verb+gcc+, \verb+cmake+)
+ \item des \violet{dépendances}
+ \end{itemize}
+
+ \begin{alertblock}{}
+ \begin{center}
+ Une transformation permet de les réécrire
+ \end{center}
+ \end{alertblock}
+\end{frame}
+
+
+
+\thisslide{cli-trans}
+\begin{frame}<presentation>[label=cli-trans, fragile]{Transformations : ligne
de commande}
+ \begin{exampleblock}{}
+ \begin{center}
+ \verb+guix package --help-transformations+
+ \end{center}
+ \end{exampleblock}
+\begin{Verbatim}[commandchars=\\\{\}]
+\blue{--with-source use SOURCE when building the corresponding package}
+\blue{--with-branch build PACKAGE from the latest commit of BRANCH}
+\blue{--with-commit build PACKAGE from COMMIT}
+\blue{--with-git--url build PACKAGE from the repository at URL}
+\blue{--with-patch add FILE to the list of patches of PACKAGE}
+\blue{--with-latest use the latest upstream release of PACKAGE}
+\magenta{--with-c-toolchain build PACKAGE and its dependents with TOOLCHAIN}
+\magenta{--with-debug-info build PACKAGE and preserve its debug info}
+\magenta{--without-tests build PACKAGE without running its tests}
+\violet{--with-input replace dependency PACKAGE by REPLACEMENT}
+\violet{--with-graft graft REPLACEMENT on packages that refer to PACKAGE}
+\end{Verbatim}
+\end{frame}
+
+Les transformations sont appliquées récursivement, donc elles s’appliquent
+aussi aux dépendances de dépendances. Par exemple, la ligne de commande pour
+recompiler le paquet \texttt{python} et toutes ses dépendances avec le
+compilateur GCC à la version 7 à la place de la version 10 (par défaut) est
+\begin{verbatim}
+guix install python --with-c-toolchain=python=gcc-toolchain@7
+\end{verbatim}
+et ceci se traduit naturellement dans un fichier de configuration
+\emph{manifest}.
+
+
+\thisslide{trans-manif}
+\begin{frame}<presentation>[label=trans-manif, fragile]{Transformations via
fichier manifeste}
+ \vspace{-0.3cm}
+ \begin{exampleblock}{}
+
\lstinputlisting[language=Scheme,columns=space-flexible]{example/some-python-with-gcc7.scm}
+ \end{exampleblock}
+\end{frame}
+
+Ici, nous utilisons le module définissant les transformations et nous
+définissions la transformation \texttt{transform} via
+\href{https://guix.gnu.org/manual/devel/fr/guix.fr.html#index-options_002d_003etransformation}{la
+procédure \texttt{options->transformation}} ; autrement dit \texttt{transform}
+est une fonction prenant en argument un paquet et retournant un nouveau paquet
+dans lequel la chaîne de compilation a été remplacée. Pour finir,
+\texttt{compose} permet de composer deux fonctions et nous aurions pu écrire à
+la place
+\begin{center}
+ \texttt{(lambda (pkg) (transform (specification->package pkg)))}
+\end{center}
+Le manuel fournit un
+\href{https://guix.gnu.org/manual/devel/fr/guix.fr.html#Index-de-programmation}%
+{\textsf{index de programmation}} qui aide à se familiariser avec le langage
+dédié.
+
+
+\clearpage
+\subsection{Environnement isolé à la volée}
+
+À ce stade, nous sommes capables de créer des profils. Par exemple, la
+commande \texttt{guix package -{}-list-profiles} liste tous les profils de
+l'utilisateur. Tant qu'il y a un élément qui pointe dans un profil, le
+\href{https://guix.gnu.org/manual/devel/fr/guix.fr.html#Invoquer-guix-gc}{ramasse-miettes}
+ne peut pas \emph{glaner} les paquets non utilisés. Dans certains cas, nous
+voulons temporairement tester un outil sans se préoccuper de la gestion du
+profil. C'est la fonctionnalité de \texttt{guix shell}.
+
+
+
+\begin{frame}<presentation>[fragile]{Profils temporaires}
+ \begin{center}
+ Exemple : ajouter temporairement \texttt{IPython}
+ \end{center}
+
+ \bigskip
+
+ \begin{center}
+ (\texttt{demo/shell-ipython})
+ \end{center}
+\end{frame}
+
+
+\thisslide{shell}
+\begin{frame}<presentation>[label=shell,fragile]{Étendre temporairement un
\emph{profil}}
+ \begin{exampleblock}{}
+\begin{verbatim}
+guix shell -m manifest.scm
+guix shell -m manifest.scm python-ipython -- ipython3
+\end{verbatim}
+ \end{exampleblock}
+
+ \begin{alertblock}{}
+ \begin{tabular}{lcl}
+ \red{$\blacktriangleright$} \verb+--pure+ &:& réinitialise des variables
+ d’environnement existantes
+ \\
+ \red{$\blacktriangleright$} \verb+--container+ &:& lance un conteneur
isolé
+ \\
+ \red{$\blacktriangleright$} \verb+--development+ &:& inclus les
dépendances du paquet
+ \end{tabular}
+ \end{alertblock}
+
+ \begin{exampleblock}{}
+\begin{verbatim}
+guix shell -m some-python.scm python-ipython # 1.
+guix shell -m some-python.scm python-ipython --pure # 2.
+guix shell -m some-python.scm python-ipython --container # 3.
+\end{verbatim}
+ \end{exampleblock}
+
+ \begin{center}
+ Bonus : \verb+guix shell emacs git git:send-email --development guix+
+ \end{center}
+\end{frame}
+
+La commande \texttt{guix shell} permet de créer ou étendre temporairement un
+profil. Par exemple, dans la section précédente, le programme \texttt{cloc}
+est utilisé pour compter les lignes de code. La commande \texttt{guix shell
+ cloc} a permis de lancer un \emph{shell} temporaire contenant le programme.
+
+\medskip
+
+Les options \texttt{pure} et \texttt{container} permettent de vérifier que
+toutes les dépendances de l'application sur laquelle on travaille sont bien
+capturées. En particulier, l'option \texttt{container} permet de lancer un
+\emph{shell} temporaire totalement isolé.
+
+\bigskip
+
+\paragraph{Nota bene~:} La commande \texttt{guix shell} a été introduite
récemment pour
+remplacer \texttt{guix environment}. Cette dernière est encore conservée pour
+assurer une rétro-compatibilité. Toutefois, nous recommandons d'utiliser
+\texttt{guix shell}, en particulier si vous n'avez jamais utilisé Guix
+auparavant.
+
+
+
+\begin{frame}<presentation>[plain,fragile,noframenumbering]{}
+ À ce stade, il semble naturel de vouloir \uline{partager ou construire des
conteneurs isolés}.
+
+ \vfill{}
+ \begin{center}
+ \textbf{Comment créer des images ?}
+ \end{center}
+ \vfill{}
+ \begin{flushright}
+ (Exemple : Alice sans privilège particulier)
+ \end{flushright}
+\end{frame}
+
+
+\clearpage
+\section{Création d'images}
+
+Dans la section précédente, nous avons vu comment créer des environnements
+«~isolés~». Il semble naturel de vouloir les partager ou les distribuer.
+
+\subsection{Création d’un \emph{pack}}
+
+La technologie usuelle pour transporter du matériel est celle d’un
+\textbf{conteneur}. Cependant, il ne faut \uline{\textbf{pas perdre de vue}}
+la \uline{\textbf{transparence}} et la
+\textbf{\uline{re\-pro\-duc\-ti\-bi\-li\-té}}.
+
+
+\thisslide{conteneur}
+\begin{frame}<presentation>[label=conteneur,fragile]{Comment capturer un
environnement ? Conteneur}
+ \begin{center}
+ Conteneur = \smiley{smoothie}
+ \end{center}
+
+ \begin{itemize}
+ \item Comment est construit le conteneur ? Dockerfile ?
+ \item Comment sont construits les binaires inclus dans le conteneur ?
+ \end{itemize}
+
+ \begin{exampleblock}{}
+\begin{verbatim}
+FROM amd64/debian:stretch
+RUN apt-get update && apt-get install git make curl gcc g++ ...
+RUN curl -L -O https://... && ... && make -j 4 && ...
+RUN git clone https://... && ... && make ... /usr/local/lib/libopenblas.a ...
+\end{verbatim}
+ \begin{center}
+
\href{https://gitlab.onelab.info/gmsh/gmsh/-/blob/c7544ec812982dbe15e105059983f1b0c3896536/utils/docker/Dockerfile.debian.stretch.64bit}%
+ {source (lien) : Gmsh~}%
+ \href{http://gmsh.info/}%
+ {A three-dimensional finite element mesh generator (lien)}
+ \end{center}
+ \end{exampleblock}
+
+ \begin{alertblock}{}
+ \begin{center}
+ Avec un Dockerfile au temps t, comment regénérer l'image au temps t’ ?
+ \end{center}
+ \end{alertblock}
+\end{frame}
+
+\bigskip % workaround
+
+Un conteneur est comme un «~smoothie~» dans le sens où nous pouvons
+immédiatement dire si nous l’aimons ou non, mais il est difficile, si ce n’est
+impossible, de donner précisément la liste exhaustive des ingrédients. Par
+conséquent, comment, à deux moments différents, reproduire exactement le même
+conteneur sur deux machines différentes ?
+
+\bigskip
+
+
+\thisslide{pack}
+\begin{frame}<presentation>[label=pack, fragile]{Qu’est-ce qu’un \emph{pack} ?}
+ \begin{center}
+ \emph{pack} = collection de paquets dans un format d’archive
+ \end{center}
+
+ Quel est le but d’un \emph{pack} ?
+ \begin{itemize}
+ \item Alice distribue «~tout~» à Carole,
+ \item Carole n’a pas installé Guix mais aura l’exact même environnement.
+ \end{itemize}
+
+ \begin{exampleblock}{Qu’est-ce qu’un format d’archive ?}
+ \begin{itemize}
+ \item \texttt{tar} (\emph{tarballs})
+ \item Docker
+ \item Singularity
+ \item paquet binaire Debian \texttt{.deb}
+ \end{itemize}
+ \end{exampleblock}
+\end{frame}
+
+Un \emph{pack} est un \emph{lot de logiciels} enregistrés sous leur forme
+binaire dans un format spécifique. Le format d’archivage \texttt{tar} est
+probablement le plus connu, historiquement. Aujourd’hui,
+\hrefsf{https://www.docker.com/}{Docker} ou
+\hrefsf{https://sylabs.io/guides/3.4/user-guide/quick_start.html}{Singularity}
+sont très largement utilisés comme format de conteneur.
+
+
+
+\thisslide{tout}
+\begin{frame}<presentation>[label=tout, fragile]{Qu'est-ce que «~tout~» ?}
+ \begin{center}
+ Carole a besoin de la \emph{clôture transitive} (= toutes les dépendances)
+ \end{center}
+ \begin{exampleblock}{}
+\begin{verbatim}
+$ guix size python-numpy --sort=closure
+store item total self
+python-numpy-1.20.3 301.5 23.6 7.8%
+...
+python-3.9.9 155.3 63.7 21.1%
+openblas-0.3.18 152.8 40.0 13.3%
+...
+total: 301.5 MiB
+\end{verbatim}
+ \end{exampleblock}
+
+ \begin{alertblock}{}
+ \begin{center}
+ \texttt{guix pack} permet de créer cette archive contenant «~tout~»
+ \end{center}
+ \end{alertblock}
+\end{frame}
+
+\clearpage % workaround
+
+Le but d’un conteneur est de capturer l’intégralité de la pile logicielle pour
+fonctionner indépendamment du système hôte. Guix fournit une commande
+(\texttt{guix size}) pour examiner la taille des éléments à inclure. Par
+exemple, le paquet \texttt{python-numpy} ne représente que moins de 8\% des
+301,5Mo totaux nécessaires à son bon fonctionnement. Nous voyons que le paquet
+\texttt{python-numpy} a aussi besoin du paquet \texttt{python} ainsi que de la
+bibliothèque d’algèbre linéaire \texttt{openblas}, entre autres.
+
+
+\thisslide{pack2}
+\begin{frame}<presentation>[label=pack2, fragile]{Création d’un \emph{pack}
+ pour le distribuer}
+
+ \begin{itemize}
+ \item Alice construit un \emph{pack} au format Docker
+ \begin{exampleblock}{}
+ \begin{center}
+ \verb+guix pack --format=docker -m manifest.scm+
+ \end{center}
+ \end{exampleblock}
+ puis distribue ce conteneur Docker (via un \emph{registry} ou autre).
+
+ \item Carole n'utilise pas \small{(encore?)}\normalsize{} Guix
+ \begin{exampleblock}{}
+\begin{verbatim}
+$ docker run -ti projet-alice python3
+Python 3.9.9 (main, Jan 1 1970, 00:00:01)
+[GCC 10.3.0] on linux
+Type "help", "copyright", "credits" or "license" for more information.
+>>>
+\end{verbatim}
+ \end{exampleblock}
+ et utilise l'exact même environnement computationnel qu'Alice.
+ \end{itemize}
+\end{frame}
+
+\paragraph{Prenons un exemple :} Construire et déployer cette présentation.
+Les deux commandes suivantes sur une machine ayant Guix permettent de
+récupérer les sources (\LaTeX) puis de construire la présentation au format
+PDF.
+
+\begin{verbatim}
+guix shell git nss-certs \
+ -- git clone https://gitlab.com/zimoun/jres22-tuto-guix
+
+guix shell -m manifest.scm \
+ -- rubber --pdf presentation.tex
+\end{verbatim}
+
+Alice souhaite pouvoir générer cette présentation sur une infrastructure ne
+possédant pas Guix. À la place, l’infrastructure utilise des conteneurs
+Docker. Par conséquent, Alice empaquette au format Docker
+\begin{verbatim}
+guix pack \
+ --format=docker \
+ -C none \
+ -S /bin=bin -S /lib=lib -S /share=share -S /etc=etc \
+ -m manifest.scm \
+ --save-provenance
+\end{verbatim}
+qui produit l’élément dans le dépôt (\emph{store})
+\texttt{/gnu/store/n92...-rubber-...-docker-pack.tar}. Nous renvoyons à la
+\href{https://guix.gnu.org/manual/devel/fr/guix.fr.html#Invoquer-guix-pack}%
+{\textsf{section du manuel}} pour une description exhaustive des options de la
+commande \texttt{guix pack}. Notons que \texttt{-{}-symlink / -S} ajoute les
+liens symboliques spécifiés dans le \emph{pack} ; par exemple, \texttt{-S
+ /bin=bin} crée un lien symbolique \texttt{/bin} qui pointe vers le
+sous-répertoire \texttt{bin} du profil.
+
+\bigskip
+
+Ce \emph{pack} une fois créé peut être chargé en local comme image Docker
+pour, par exemple, ajouter une étiquette (\emph{tag}) et pousser cette image
sur un
+dépôt (\emph{registry})
+\begin{verbatim}
+$ docker load < $(guix pack ...)
+$ docker images
+REPOSITORY TAG IMAGE ID CREATED SIZE
+rubber-texlive-base-texlive-fonts-ec latest 6f08ec6e1f4c 52 years ago 1.03GB
+$ docker tag 6f08ec6e1f4c zimoun/jres
+$ docker push zimoun/jres
+\end{verbatim}
+où les points \dots~ sont par exemple les options précédentes.
+
+\medskip
+
+Il faut noter la date qui correspond au 1\ier{} janvier 1970, c.-à-d. qui
+donne les conditions pour reproduire l'image bit-à-bit. D'autre part, il faut
+aussi noter que Guix vérifie si l'élément est déjà présent dans le dépôt
+(\emph{store}).
+
+\bigskip
+
+Maintenant, il suffit pour Carole de télécharger depuis le dépôt
+(\emph{registry}) le conteneur Docker. Par exemple, ce conteneur pourrait
+être utilisé pour de l'intégration continue à travers GitLab~CI (voir l'%
+\hrefsf{https://gitlab.com/zimoun/jres22-tuto-guix/-/blob/main/.gitlab-ci.yml}%
+{exemple dédié} pour construire cette présentation).
+
+
+
+\thisslide{pack3}
+\begin{frame}<presentation>[label=pack3, fragile]{Au final, \texttt{guix
pack}, c’est\dots}
+
+ \begin{center}
+ \emph{Agnostique} sur le format du «~conteneur~»
+ \end{center}
+
+ \begin{tabular}{cc}
+ \begin{minipage}{0.4\linewidth}
+ \begin{exampleblock}{}
+ \begin{itemize}
+ \item \texttt{tar} (\emph{tarballs})
+ \item Docker
+ \item Singularity
+ \item paquet binaire Debian \texttt{.deb}
+ \end{itemize}
+ \end{exampleblock}
+ \end{minipage}
+ &
+ \begin{minipage}{0.5\linewidth}
+ \begin{alertblock}{}
+ \begin{itemize}
+ \item archives repositionnables
+ \item sans \texttt{Dockerfile}
+ \item via \texttt{squashfs}
+ \item sans \texttt{debian/rule} (expérimental)
+ \end{itemize}
+ \end{alertblock}
+ \end{minipage}
+ \end{tabular}
+
+ \bigskip
+
+ \begin{center}
+ \textbf{Adaptable aux cas d’usage}
+ \end{center}
+\end{frame}
+
+\paragraph{Pour aller plus loin :} Peut-on extraire le manifeste Guix d’un
+\emph{pack} au format Docker ?
+\begin{center}
+
\hrefsf{https://hpc.guix.info/blog/2021/10/when-docker-images-become-fixed-point/}%
+ {Reproductibilité d'un conteneur Docker généré par Guix}
+\end{center}
+
+\bigskip
+
+Internet étant fait de serveurs qui vont et viennent, les URL risquent de
+ne plus pointer vers le contenu. Par conséquent, nous donnons ici des liens
+vers des archives (meilleure pérennité) pour le contenu de ce tutoriel :
+
+\begin{itemize}
+\item
+
\hrefsf{https://archive.softwareheritage.org/browse/origin/directory/?origin_url=https://gitlab.com/zimoun/jres22-tuto-guix}%
+ {Source} sur \hrefsf{https://www.softwareheritage.org/}{Software Heritage}
+\item
+
\hrefsf{https://web.archive.org/web/*/https://zimoun.gitlab.io/jres22-tuto-guix}%
+ {Déploiement} sur \hrefsf{https://web.archive.org/}{Web Archive}
+\end{itemize}
+
+en plus, évidemment, des JRES.
+
+
+\clearpage
+\subsection{Création d'une machine virtuelle}
+
+Dans la section précédente, nous avons vu comme créer des \emph{pack}
+contenant un déploiement de paquets. Cependant, nous souhaiterions aussi
+pouvoir déployer des services.
+
+
+\thisslide{image}
+\begin{frame}<presentation>[label=image, fragile]{Création d’une image avec
+ \texttt{guix system} : un monde de services}
+
+ \begin{alertblock}{}
+ \begin{center}
+ \texttt{guix system} permet une
+ \uline{\textbf{configuration déclarative} d'un \emph{système}}
+ \end{center}
+ \end{alertblock}
+
+ \begin{itemize}
+ \item \texttt{guix system search} pour trouver les services disponibles
+ \item \texttt{guix system image} pour construire une image de type :
+ \begin{itemize}
+ \item qcow2
+ \item docker
+ \item iso9660, uncompressed-iso9660, efi-raw, raw-with-offset
+ \item rock64-raw, pinebook-pro-raw, pine64-raw, novena-raw
+ \item hurd-raw, hurd-qcow2
+ \end{itemize}
+ \item
+ \begin{minipage}{1.0\linewidth}
+ \begin{exampleblock}{}
+ \texttt{guix system vm} pour construire une machine virtuelle (VM)
+ \begin{center}
+ (la VM partage son dépôt avec le système hôte)
+ \end{center}
+ \end{exampleblock}
+ \end{minipage}
+ \end{itemize}
+\end{frame}
+
+Sur le même principe que la commande \texttt{guix package}, il est possible de
+chercher les services disponibles avec \texttt{guix system search}. De plus,
+la commande \texttt{guix system} permet de générer une image suivant
+différents formats. Par exemple, ceci permet d’obtenir une image
+\emph{bootable} qui donne une distribution complète – appelée Guix System.
+
+\bigskip
+
+La commande qui nous intéresse particulièrement est \texttt{guix system vm}.
+Elle permet de générer une machine virtuelle (VM) qui partage son dépôt avec
+son hôte (n’importe quelle distribution Linux avec Guix installé). L’avantage
+principal est une isolation complète qui, par exemple, permet de fournir des
+services. Le déploiement de services avec Guix mériterait un tutoriel en soi,
+nous donnons ici un point d’entrée.
+
+
+
+\thisslide{image2}
+\begin{frame}<presentation>[label=image2, fragile]{Configuration déclarative
+ d'une machine virtuelle}
+ \vspace{-0.3cm}
+ \begin{exampleblock}{}
+
\lstinputlisting[language=Scheme,columns=space-flexible]{example/config-vm-1.scm}
+ \end{exampleblock}
+\end{frame}
+
+Comme pour la gestion de paquets, la configuration de la machine virtuelle se
+fait dans un langage déclaratif. Le point d’entrée est le mot-clé
+\texttt{operating-system}
+(\href{https://guix.gnu.org/manual/devel/fr/guix.fr.html#r_00e9f_00e9rence-de-operating_002dsystem}%
+{\textsf{décrit dans le manuel}}) qui spécifie les options. En particulier,
+un champ liste les paquets à provisionner et un autre champ liste les services
+avec éventuellement leurs caractéristiques.
+
+
+\thisslide{image3}
+\begin{frame}<presentation>[label=image3, fragile]{Configuration déclarative
+ d'une machine virtuelle (2)}
+ \vspace{-0.3cm}
+ \begin{exampleblock}{}
+
\lstinputlisting[language=Scheme,columns=space-flexible]{example/config-vm-2.scm}
+ \end{exampleblock}
+\end{frame}
+
+
+\thisslide{image4}
+\begin{frame}<presentation>[label=image4, fragile]{Machines virtuelles avec
Guix}
+
+ % \begin{center}
+ % (\texttt{demo/vm})
+ % \end{center}
+
+ \begin{alertblock}{}
+ \begin{itemize}
+ \item Gestion déclarative
+ \item Réutilisation via des patrons (\emph{template})
+ \end{itemize}
+ \end{alertblock}
+
+\end{frame}
+
+Par exemple, la commande
+\begin{center}
+ \texttt{guix system vm src/example/vm-image.scm}
+\end{center}
+produit le script \texttt{/gnu/store/0n5...-run-vm.sh} qui lance QEMU avec les
+éléments du dépôt (\emph{store}) adéquats, c.-à-d.
+\begin{verbatim}
+$ /gnu/store/0n5...-run-vm.sh -nic user
+\end{verbatim}
+démarre la machine virtuelle avec, ici, le réseau. Ces machines virtuelles
+peuvent être administrées avec le paquet \texttt{virt-manager}.
+
+
+
+\begin{frame}<presentation>[plain,fragile,noframenumbering]{}
+ Très bien tout cela, mais en quoi est-ce \uline{reproductible} ?
+
+ \vfill{}
+ \begin{center}
+ \textbf{Parlons de versions !}
+ \end{center}
+ \vfill{}
+ \begin{flushright}
+ (Exemple : Carole collabore avec Alice)
+ \end{flushright}
+\end{frame}
+
+
+\clearpage
+\section{Une histoire de versions}
+
+Le but de cette section est double, d'une part montrer par l'exemple la
+capacité de Guix de s'affranchir de l'état externe et d'autre part en quoi
+Guix est dit \emph{fonctionnel}.
+
+\subsection*{Version ? Graphe ?}
+
+Une question récurrente des nouveaux utilisateurs de Guix est~: comment est-ce
+que je spécifie la version de l’outil à utiliser ? Une réponse à cette
+question appelle une autre question~: qu’est-ce que l’on appelle version ?
+Est-ce la version du code source ? Est-ce la version du binaire ? Mais
+alors, pour le le même code source transformé par deux chaînes de compilation
+différentes, appelle-t-on les deux binaires résultants la même \emph{version}
+?
+
+
+\thisslide{version}
+\begin{frame}<presentation>[label=version, fragile]{Quelle est ma version de
Guix ?}
+ % \vspace{-0.25cm}
+ \begin{exampleblock}{}
+\begin{verbatim}
+$ guix describe
+Generation 76 Apr 25 2022 12:44:37 (current)
+ guix eb34ff1
+ repository URL: https://git.savannah.gnu.org/git/guix.git
+ branch: master
+ commit: eb34ff16cc9038880e87e1a58a93331fca37ad92
+
+$ guix --version
+guix (GNU Guix) eb34ff16cc9038880e87e1a58a93331fca37ad92
+\end{verbatim}
+ \end{exampleblock}
+
+ % \vspace{-0.175cm}
+ \begin{alertblock}{}
+ \begin{center}
+ Un état fixe toute la collection des paquets et de Guix lui-même
+ \end{center}
+ \end{alertblock}
+
+ (Un état peut contenir plusieurs canaux (\emph{channel} = dépôt Git),\\
+ \hfill avec des URL, branches ou commits divers et variés)
+
+% \vspace{-0.175cm}
+% \begin{verbatim}
+% $ guix package --list-available=^python | head -2
+% python 3.9.9 out,tk,idle gnu/packages/python.scm:431:2
+% python-absl-py 0.6.1 out
gnu/packages/python-xyz.scm:23415:2
+% \end{verbatim}
+\end{frame}
+
+Guix capture un état : la liste de tous les paquets et les commandes Guix
+elles-mêmes. Les commandes Guix sont données par le canal principal et ce
+canal fournit un ensemble de paquets (et de services). Il est tout à fait
+possible d’étendre la collection de paquets en fournissant d’autres canaux
+pour avoir des paquets variants. Par exemple, l’initiative
+\hrefsf{https://hpc.guix.info/about/}{GuixHPC} (qui correspond à Guix dans un
+contexte scientifique) essaie de maintenir une \hrefsf{liste de canaux}.
+
+\medskip
+
+Pour spécifier un canal supplémentaire, l’utilisateur (sans droit particulier)
+doit modifier le fichier \texttt{\$HOME/.config/guix/channels.scm}, p. ex.
+\begin{verbatim}
+(cons (channel
+ (name 'guix-hpc)
+ (url "https://gitlab.inria.fr/guix-hpc/guix-hpc";))
+ %default-channels)
+\end{verbatim}
+Si la canal fournit aussi des substituts binaires ce qui évite de consommer
+des ressources, alors il faut
+\href{https://guix.gnu.org/manual/devel/fr/guix.fr.html#Autoriser-un-serveur-de-substituts}%
+{autoriser le serveur de substituts}. Dans le cas de ce canal, la clé
+publique est
+\begin{verbatim}
+(public-key
+ (ecc
+ (curve Ed25519)
+ (q #89FBA276A976A8DE2A69774771A92C8C879E0F24614AAAAE23119608707B3F06#)))
+\end{verbatim}
+L’ajout de serveurs de substituts nécessite cependant des droits
+d’administration privilégiés pour des raisons de sécurité.
+
+
+\thisslide{dag}
+\begin{frame}<presentation>[label=dag, fragile]{État = Graphe Acyclique Dirigé
(\emph{DAG})}
+ \vspace{-0.5cm}
+ \begin{center}
+ \texttt{guix graph -{}-max-depth=6 python | dot -Tpng > graph-python.png}
+ \end{center}
+
+ \vfill{}
+ \includegraphics[width=\textwidth]{static/graph-python.png}
+ \vfill{}
+
+ Graphe complet : Python = 137 n\oe uds, Numpy = 189, Matplotlib = 915, Scipy
+ = 1439 n\oe uds
+% graph python-scipy -t bag | grep label | cut -f2 -d'[' | sort | uniq | wc -l
+\end{frame}
+
+Guix capture un état, c.-à-d. que Guix capture le graphe complet pour produire
+le binaire résultant. Il capture les relations de dépendances, les recettes
+de construction et la machinerie de Guix elle-même pour traiter tout cela.
+
+\medskip
+
+Il n’y a pas de résolveur de dépendances qui cherche à trouver la meilleure
+solution à un problème sous-contraintes. Guix lui construit un graphe à
+partir de la collection de paquets qu’il connaît dans son état courant.
+Ensuite, ce graphe peut être
+\href{https://guix.gnu.org/manual/devel/fr/guix.fr.html#Options-de-transformation-de-paquets}%
+{\textsf{transformé}} pour obtenir les variants.
+
+\medskip
+
+Ainsi la variabilité est contrôlée aussi finement que possible. Dans la
+plupart des cas d’usage, le résultat final (la courbe publiée par Alice,
+l’utilisation de tel ou tel outil par Carole, etc.) ne sera pas impacté. La
+question se pose à l’inverse quand il y a une différence dans ce résultat.
+D’où vient l’erreur ? En d’autres termes, ce contrôle fin est d’intérêt quand
+on cherche à redéployer une pile logicielle pour reproduire ou dupliquer.
+
+
+\subsection*{Définir un paquet}
+
+
+\thisslide{def-pkg}
+\begin{frame}<presentation>[label=def-pkg, fragile]{Définition d’un paquet
(n\oe ud du graphe)}
+ \vspace{-0.3cm}
+ \begin{exampleblock}{}
+
\lstinputlisting[language=Scheme,columns=space-flexible]{example/mock-define-python.scm}
+ \end{exampleblock}
+
+ \vspace{-0.2cm}
+ \begin{alertblock}{}
+ \begin{itemize}
+ \item Chaque \texttt{inputs} est une définition similaire
+ \hfill (récursion $\rightarrow$ graphe)
+ \item Il n’y a pas de cycle
+ \hfill (\texttt{bzip2} ou ses \texttt{inputs} ne peuvent pas utiliser
\texttt{python})
+ \end{itemize}
+ \end{alertblock}
+
+ \vspace{-0.25cm}
+ \begin{center}
+ \small{%
+ (Quel commencement du graphe ? Problème du \emph{bootstrap} dont nous ne
+ parlerons pas ici)
+ }\normalsize
+ \end{center}
+\end{frame}
+
+Un paquet correspond à un n\oe ud du graphe. D’une part, il contient des
+\emph{meta} informations comme le nom, la version du code source, un synopsis
+et description, la licence. D’autre part, il contient la recette pour être
+construit par Guix~: où trouver les sources, quelle chaîne de compilation par
+défaut, quelles dépendances, et quelles modifications spécifiques
+(\texttt{arguments}) pour indiquer les options de compilation ou les
+changements mineurs dans la chaîne de compilation.
+
+\medskip
+
+Pour faciliter la création de nouveaux paquets,
+\href{https://guix.gnu.org/manual/devel/fr/guix.fr.html#Invoquer-guix-import}%
+{\textsf{la commande \texttt{guix import}}} permet de générer une recette Guix
+à partir des dépôts dédiés à un écosystème (PyPI, CRAN, Bioconductor, etc.).
+Il faut noter que l’\emph{utilisabilité} de la recette résultante est très
+variable car elle dépend fortement de la qualité ou disponibilité des
+métadonnées du dépôt source.
+
+\medskip
+
+De notre point de vue, empaqueter pour Guix est généralement plus facile que
+pour les autres gestionnaires. Cependant, la construction totalement isolée
+de Guix oblige à une certaine gymnastique. Au final, nous tenons à souligner
+que le travail d’empaquetage quelque soit le gestionnaire sous-jacent est un
+tâche laborieuse.
+
+
+\clearpage
+\subsection*{Changer d'état}
+
+La
+\href{https://guix.gnu.org/manual/devel/fr/guix.fr.html#Invoquer-guix-pull}%
+{\textsf{commande \texttt{guix pull}}} permet de changer d’état en mettant à
+jour la collection de paquets des différents canaux et Guix lui-même. Par
+exemple, la commande \texttt{guix pull --news} permet de savoir quelles sont
+les différences entre notre état précédent et notre état courant.
+
+\medskip
+
+La commande \texttt{guix upgrade} permet de mettre à jour les paquets d’un
+profil. Cette commande respecte les transformations, s’il y a, dans la mise à
+jour.
+
+\medskip
+
+En ayant la capacité d’utiliser d’autres canaux, de créer des profils et de
+mettre à jour la collection des paquets, un utilisateur sans privilège devient
+autonome dans la gestion de ses outils. Bien entendu, sur une machine
+mutualisée, l’administrateur peut créer des profils exposés aux utilisateurs
+pour leurs fournir des suites d’outils par défaut.
+
+
+\thisslide{pull}
+\begin{frame}<presentation>[label=pull, fragile]{Concrètement, en pratique ?}
+
+ \begin{alertblock}{}
+ \begin{center}
+ une version = un graphe
+ \end{center}
+ \end{alertblock}
+
+ \begin{center}
+ Mise à jour de Guix
+
+ \texttt{guix pull}
+
+ (création d'une nouvelle \emph{génération} interne)
+ \end{center}
+
+ \begin{itemize}
+ \item Il est possible de \uline{spécifier un \emph{état}} :
+ \begin{exampleblock}{}
+ \begin{center}
+ \begin{tabular}{rl}
+ \blue{\texttt{alice@laptop\$}} & \texttt{guix describe
-{}-format=channels >
+ alice-laptop.scm}
+ \\
+ \violet{\texttt{carole@desktop\$}} & \texttt{guix pull
-{}-channels=alice-laptop.scm}
+ \end{tabular}
+ \end{center}
+ \end{exampleblock}
+ \item Il est possible de se placer \uline{\textbf{temporairement} dans un
état spécifique}\\
+ \hfill pour exécuter une commande (comme créer un profil)
+
+ \begin{exampleblock}{}
+ \begin{center}
+ \texttt{guix time-machine -{}-commit=c61df1792c -{}- install python -p
python/autres}
+ \end{center}
+ \end{exampleblock}
+ \end{itemize}
+\end{frame}
+
+Comme il est possible de connaître l’historique d’installation et de
+suppression des paquets d’un profil avec la commande \texttt{guix package -l},
+la commande \texttt{guix pull -{}-list-generations} fournit l’historique des
+états de l’utilisateur. Notons que les commandes Guix elle-mêmes vivent dans
+un profil particulier (nommé \texttt{\$HOME/.config/guix/current}).
+
+\medskip
+
+Ainsi, sur une machine multi-utilisateurs, cette liste des états peut différer
+entre les utilisateurs. La commande \texttt{guix describe} permet de capturer
+l’état courant pour soit le \emph{versionner} avec un projet, soit le
+partager. Par exemple, Alice sauvegarde son état courant dans le fichier
+\texttt{alice-laptop.scm} et transmet à Carole ce fichier. Ensuite, Carole
+sur une autre machine peut se placer dans l’exact même état qu’Alice.
+
+\medskip
+
+Lorsque l’on travaille sur plusieurs projets, il peut devenir fastidieux de
+changer d’état \emph{globalement} et il est souhaitable d’avoir la capacité de
+se placer temporairement dans un état donné pour réaliser une opération
+(installation, création de profil, etc.). Ceci est possible avec la
+\href{https://guix.gnu.org/manual/devel/fr/guix.fr.html#Invoquer-guix-time_002dmachine}%
+{\textsf{commande} \texttt{guix time-machine}}.
+
+
+
+\thisslide{time-machine}
+\begin{frame}<presentation>[label=time-machine, fragile]{Reproductibilité en
arrière, en avant :
+ \texttt{guix time-machine}}
+
+ \vspace{-1cm}
+ \begin{center}
+ \begin{tikzpicture}
+ % draw horizontal line
+ \draw[thick, -Triangle] (0,0) -- (12,0) node[font=\scriptsize,below
left=3pt and -8pt]{time};
+
+ \node[font=\scriptsize, text height=1.75ex, text depth=.5ex] at (0,-.3)
{2018};
+
+ % draw vertical lines
+ \foreach \x in {1,...,11}
+ \draw (\x cm,3pt) -- (\x cm,-3pt);
+
+ \foreach \x/\descr in {3/Carole,6/Alice,8/Bob}
+ \node[font=\scriptsize, text height=1.75ex, text depth=.5ex] at (\x,-.3)
{$\descr$};
+
+ \node[font=\scriptsize, text height=1.75ex, text depth=.5ex] (Carole) at
(3,+.3) {d7e57e};
+ \node[font=\scriptsize, text height=1.75ex, text depth=.5ex] (Alice) at
(6,+.3) {eb34ff1};
+ \node[font=\scriptsize, text height=1.75ex, text depth=.5ex] (Dan) at
(8,+.3) {3682bd};
+
+ \draw[->] (Carole.north) to [out=50,in=150] (Alice.west);
+ \draw[->] (Dan.north) to [out=100,in=50] (Alice.east);
+
+ \draw[lightgray!0!red, line width=4pt] (2,-.6) -- +(8,0);
+ \foreach \x/\percol in {1/75,9/75}
+ \draw[lightgray!\percol!red, line width=4pt] (\x,-.6) -- +(1,0);
+
+ \node[font=\scriptsize, text height=1.75ex, text depth=.5ex] at (11,-.3)
{$Dan$};
+ \node[font=\scriptsize, text height=1.75ex, text depth=.5ex] (Dan) at
(11,+.3) {c99c3d};
+ \draw[dashed,->] (Dan.north) to [out=40,in=90] (Alice.north);
+
+ \end{tikzpicture}
+ \end{center}
+
+ \begin{exampleblock}{}
+ Pour être \uline{reproductible dans le temps}, il faut :
+ \begin{itemize}
+ \item Une préservation de \textbf{tous} les codes source~%
+ \small{%
+ (\href{https://ngyro.com/pog-reports/latest/}%
+ {$\approx 75\%$ archivés \tiny{(lien)}\small} dans~%
+ \href{https://www.softwareheritage.org/}%
+ {Software Heritage \tiny{(lien)}\small})%
+ }\normalsize
+ \item Une \emph{backward} compatibilité du noyau Linux
+ \item Une compatibilité du \emph{hardware} (p. ex. CPU, disque dur
\tiny{(NVMe)}\normalsize, etc.)
+ \end{itemize}
+ \end{exampleblock}
+
+ \begin{alertblock}{}
+ \begin{center}
+ Quelle est la taille de la fenêtre temporelle avec les 3 conditions
+ satisfaites ?
+ \end{center}
+ \end{alertblock}
+ \begin{center}
+ \scriptsize{(À ma connaissance, le projet Guix réalise une expérimentation
+ grandeur nature et quasi-unique depuis sa v1.0 en 2019)}
+ \end{center}
+\end{frame}
+
+Carole et Bob, les collaborateurs d’Alice, qui aussi travaillent sur d’autres
+projets avec d’autres collaborateurs peuvent convenir d’un état et s’y
+placer. Ils auront le même environnement logiciel. Grâce aux mécanismes
+d’\href{https://guix.gnu.org/manual/devel/fr/guix.fr.html#Inf_00e9rieurs}%
+{inférieurs}, il est possible de tendre à une reproductibilité dans le temps.
+
+\medskip
+
+Pour assurer cette reproductibilité, le seul point sur lequel nous pouvons
+directement agir est la sauvegarde de tous les codes sources. Le projet Guix
+participe à la mise en place de ponts avec des systèmes d’archivage comme
+Software Heritage. Chaque état correspond à une collection de paquets et donc
+à des codes sources et des recettes Guix de construction. Le chantier est en
+cours pour préserver «~quoi~» et «~comment~» construire.
+
+
+\clearpage
+\section{Au final\dots}
+\subsection*{Au final\dots}
+
+
+\thisslide{continuum2}
+\begin{frame}<presentation>[label=continuum2, fragile]{\dots Guix est un
\emph{continuum}%
+ \hfill \small{(sur n'importe quelle distribution Linux)}}
+
+ \vspace{-0.5cm}
+
+ \begin{center}
+ \begin{tabular}{llr}
+ un \uline{\textbf{gestionnaire de paquets}} déclaratif
+ & \texttt{guix package}
+ & (\texttt{-m} \emph{manifest})
+ \\
+ \ \ temporairement étendu à la volée
+ & \texttt{guix shell}
+ & (\texttt{-{}-container})
+ \\
+ \ \ \ \ maîtrisant exactement l'\emph{état}
+ & \texttt{guix time-machine}
+ & (\texttt{-C} \emph{channels})
+ \\
+ \ \ \ \ \ \ qui produit des \uline{\textbf{\emph{packs} distribuables}}
+ & \texttt{guix pack}
+ & (\texttt{-f docker})
+ \\
+ \ \ \ \ \ \ \ \ qui génèrent des \textbf{\uline{\emph{machines
virtuelles}} isolées}
+ & \texttt{guix sytem vm}
+ \\
+ \ \ \ \ \ \ \ \ \ \ \ \ \ et aussi une bibliothèque Scheme
+ & \texttt{guix repl}
+ & (\emph{extensions})
+ \\
+ $\Big($
+ la distribution Linux elle-même
+ & \texttt{config.scm}
+ & (Guix System)
+ $\Big)$
+ \end{tabular}
+
+ \begin{alertblock}{}
+ \begin{center}
+ \textbf{%
+ Guix permet un contrôle fin du graphe de configuration sous-jacent
+ }
+ \end{center}
+ \end{alertblock}
+ \end{center}
+
+ \begin{exampleblock}{}
+ \begin{center}
+ \texttt{guix time-machine -C channels.scm -{}-}
+ \emph{commande options}
+ \texttt{une-config.scm}
+ \end{center}
+ \end{exampleblock}
+
+ \begin{alertblock}{}
+ \begin{center}
+ \texttt{une-config.scm} est \textbf{reproductible}
+ d'une machine à l'autre et dans le temps
+ \end{center}
+ \end{alertblock}
+\end{frame}
+
+
+
+\thisslide{scenarii2}
+\begin{frame}<presentation>[label=scenarii2,fragile]{Scenarii}
+ \vspace{-0.2cm}
+ \begin{itemize}
+ \item Alice utilise \texttt{python@3.9} et \texttt{numpy@1.20.3}
+ \vspace{-0.1cm}
+ \begin{exampleblock}{}
+\begin{verbatim}
+$ guix install python python-numpy
+\end{verbatim}
+ \end{exampleblock}
+ \item Carole \textbf{collabore} avec Alice\ldots{}
+ mais utilise d'autres outils pour un autre projet
+ \vspace{-0.1cm}
+ \begin{exampleblock}{}
+\begin{verbatim}
+$ guix time-machine -C version-alice.scm \
+ -- install -m outils-alice.scm -p projet/alice
+\end{verbatim}
+ \end{exampleblock}
+ \item Charlie \textbf{mets à jour} son système et \textbf{tout est cassé}
+ \vspace{-0.1cm}
+ \begin{exampleblock}{}
+\begin{verbatim}
+$ guix pull --roll-back
+\end{verbatim}
+ \end{exampleblock}
+ \item Bob utilise les \textbf{{mêmes} versions} qu'Alice mais n'a
+ \textbf{pas le {même} résultat}
+ \vspace{-0.1cm}
+ \begin{exampleblock}{}
+\begin{verbatim}
+error: You found a bug
+\end{verbatim}
+ \end{exampleblock}
+ \item Dan essaie de \textbf{rejouer plus tard} le scénario d'Alice\dots
+ \vspace{-0.25cm}
+ \begin{flushright}
+ \scriptsize{(voir ligne commande Carole)}\normalsize
+ \hfill{}
+ \dots ça dépend de la date du scénario ;-)
+ \end{flushright}
+ \end{itemize}
+\end{frame}
+
+\clearpage
+\subsection*{Limitations}
+
+En tant que contributeur régulier, j'ai une vision biaisée qui peut-être
+sur-estime les défauts à traiter et sous-estime toutes les
+fonctionnalités qui résolvent un large spectre de problèmes. Pour sûr, après
+plus de deux années d'utilisation intensive de l'ordinateur portable à la
+machine de calcul en passant pour la station de travail, je ne reviendrai
+pas à des outils sans un paradigme déclaratif et fonctionnel.
+
+
+\thisslide{limit}
+\begin{frame}<presentation>[label=limit,fragile]{On s'habitue vite\dots}
+ \begin{itemize}
+ \item Fonctionne uniquement avec Linux.
+ \item Environnement isolé implique une forte transparence,
+ \begin{flushright}
+ c.-à-d., difficile avec des parties propriétaires.
+ \end{flushright}
+
+ \item Certaines commandes peuvent apparaître lentes (\texttt{pull},
\texttt{search}, etc.),
+ \begin{flushright}
+ ou retourner des erreurs obscures.
+ \end{flushright}
+ \item Les premiers pas requièrent un peu de patience,
+ \begin{flushright}
+ et d’accepter que ce
+ n’est \uline{pas \emph{comme d’habitude}}.
+ \end{flushright}
+ \end{itemize}
+
+ \vfill{}
+ \begin{alertblock}{}
+ \begin{center}
+ \textbf{La communauté est très accueillante et toujours disponible pour
aider}
+ \end{center}
+ \end{alertblock}
+\end{frame}
+
+\begin{enumerate}
+\item Le problème est la transparence de la chaîne de \emph{bootstrap} :
comment
+ construire à «~partir de rien~». Techniquement, en quelques mots, le
+ nœud du problème est le port de la bibliothèque C \texttt{glibc} pour un
autre
+ noyau. Autrement dit, quelle est la taille de la graine binaire que l'on
+ s'autorise comme racine du graphe des dépendances ?
+\item Il est possible d’utiliser des pilotes spécifiques pour certains
+ matériels \emph{hardware} mais c’est du travail. D’un autre côté, dans un
+ contexte de reproductibilité scientifique, ne doit-on pas chercher au
+ maximum la transparence de toute la chaîne de traitement ?
+
+ L’autre implication est l’utilisation de logiciels requérant par exemple un
+ jeton de licence – comme le compilateur Fortran d’Intel \texttt{ifort}.
+ L’environnement de construction étant totalement isolé, l’accès au jeton est
+ impossible lors de la compilation.
+\item Tout est régulièrement amélioré, dans la mesure du possible avec les
+ moyens disponibles.
+\item On y vient, on n’en repart pas.
+\end{enumerate}
+
+\subsection*{Ressources}
+
+
+\thisslide{prod}
+\begin{frame}<presentation>[label=prod]{En production}
+ \vspace{-0.2cm}
+ \begin{exampleblock}{}
+ \begin{tabular}{lcrl|c}
+ \textbf{Grid’5000} & & 828-nodes &(12,000+ cores,
31 clusters) &(France) \\
+ \textbf{GliCID (CCIPL)} & Nantes & 392-nodes &(7500+ cores)
&(France) \\
+ \textbf{PlaFrIM Inria} & Bordeaux & 120-nodes &(3000+ cores)
&(France) \\
+ \textbf{GriCAD} & Grenoble & 72-nodes &(1000+ cores)
&(France) \\
+ \textbf{Max Delbrück Center} & Berlin & 250-nodes &+ workstations
&(Allemagne) \\
+ \textbf{UMC} & Utrecht & 68-nodes &(1000+ cores)
&(Pays-Bas) \\
+ \textbf{UTHSC Pangenome} & & 11-nodes &(264 cores)
&(USA) \\
+ \\
+ \quad (le vôtre ?)
+ \end{tabular}
+ \end{exampleblock}
+
+ \vspace{-0.25cm}
+ \begin{center}
+
\includegraphics[width=0.25\paperwidth]{static/guixhpc-logo-transparent-white}
+
+ \vspace{-0.25cm}
+
+ \href{https://hpc.guix.info/}{\texttt{https://hpc.guix.info}}
+ \end{center}
+
+ \vspace{-1.2cm}
+ \begin{flushright}
+ \includegraphics[width=0.175\paperwidth]{static/cafe-guix}
+ \end{flushright}
+\end{frame}
+
+
+\thisslide{thanks}
+\begin{frame}<presentation>[label=thanks]{Remerciements}
+ \begin{itemize}
+ \item Ludovic Courtès
+ \item Ricardo Wurmus (Guix comme bibliothèque Scheme : Guix Workflow
Language)
+ \item Mathieu Othacehe
+ (\href{https://guix.gnu.org/cuirass/}%
+ {Cuirass \scriptsize{(lien)} \normalsize = CI}
+ qui assure la disponibilité des \emph{substituts} binaires)
+ \item tous les contributeurs (de la question au \emph{patch} en passant par
+ la rapport de \emph{bug})
+ \end{itemize}
+
+ \vfill{}
+
+ \emph{«~Présidents~» de la session} JRES :
+ \begin{itemize}
+ \item Yann Dupont
+ \item Emmanuel Halbwachs
+ \end{itemize}
+\end{frame}
diff --git a/talks/jres-2022/src/example/config-vm-1.scm
b/talks/jres-2022/src/example/config-vm-1.scm
new file mode 100644
index 0000000..0e0b8d3
--- /dev/null
+++ b/talks/jres-2022/src/example/config-vm-1.scm
@@ -0,0 +1,22 @@
+(use-modules (gnu) (guix) (srfi srfi-1))
+(use-service-modules desktop mcron networking xorg)
+(use-package-modules certs fonts xorg)
+
+(operating-system
+ (host-name "gnu")
+ (keyboard-layout (keyboard-layout "us" "altgr-intl"))
+
+ (users (cons (user-account
+ (name "guest")
+ (password "") ;no password
+ (group "users"))
+ %base-user-accounts))
+
+ (packages (append (list font-bitstream-vera nss-certs)
+ %base-packages))
+
+ (services
+ (append (list (service xfce-desktop-service-type)
+ (simple-service 'cron-jobs mcron-service-type
+ (list auto-update-resolution-crutch))
+ (service dhcp-client-service-type)))))
diff --git a/talks/jres-2022/src/example/config-vm-2.scm
b/talks/jres-2022/src/example/config-vm-2.scm
new file mode 100644
index 0000000..68322b6
--- /dev/null
+++ b/talks/jres-2022/src/example/config-vm-2.scm
@@ -0,0 +1,13 @@
+(use-modules (gnu) (guix) (srfi srfi-1))
+(use-service-modules desktop mcron networking xorg)
+(use-package-modules certs fonts xorg)
+
+(operating-system
+ [...]
+ (packages (append (list font-bitstream-vera nss-certs)
+ %base-packages))
+ (services
+ (append (list (service xfce-desktop-service-type)
+ (simple-service 'cron-jobs mcron-service-type
+ (list auto-update-resolution-crutch))
+ (service dhcp-client-service-type)))))
diff --git a/talks/jres-2022/src/example/mock-define-python.scm
b/talks/jres-2022/src/example/mock-define-python.scm
new file mode 100644
index 0000000..994538d
--- /dev/null
+++ b/talks/jres-2022/src/example/mock-define-python.scm
@@ -0,0 +1,9 @@
+(define python
+ (package
+ (name "python")
+ (version "3.9.9")
+ (source ... )
+ (build-system gnu-build-system)
+ (arguments ... )
+ (inputs (list bzip2 expat gdbm libffi sqlite
+ openssl readline zlib tcl tk))))
diff --git a/talks/jres-2022/src/example/some-python-bis.scm
b/talks/jres-2022/src/example/some-python-bis.scm
new file mode 100644
index 0000000..cd6ceb5
--- /dev/null
+++ b/talks/jres-2022/src/example/some-python-bis.scm
@@ -0,0 +1,11 @@
+(define python "python")
+
+(specifications->manifest
+ (append
+ (list python)
+ (map (lambda (pkg)
+ (string-append python "-" pkg))
+ (list
+ "matplotlib"
+ "numpy"
+ "scipy"))))
diff --git a/talks/jres-2022/src/example/some-python-with-gcc7.scm
b/talks/jres-2022/src/example/some-python-with-gcc7.scm
new file mode 100644
index 0000000..6c71cb0
--- /dev/null
+++ b/talks/jres-2022/src/example/some-python-with-gcc7.scm
@@ -0,0 +1,13 @@
+(use-modules (guix transformations))
+
+(define transform
+ (options->transformation
+ '((with-c-toolchain . "python=gcc-toolchain@7"))))
+
+(packages->manifest
+ (map (compose transform specification->package)
+ (list
+ "python"
+ "python-matplotlib"
+ "python-numpy"
+ "python-scipy")))
diff --git a/talks/jres-2022/src/example/some-python.scm
b/talks/jres-2022/src/example/some-python.scm
new file mode 100644
index 0000000..5436dac
--- /dev/null
+++ b/talks/jres-2022/src/example/some-python.scm
@@ -0,0 +1,6 @@
+(specifications->manifest
+ (list
+ "python"
+ "python-matplotlib"
+ "python-numpy"
+ "python-scipy"))
diff --git a/talks/jres-2022/src/header.tex b/talks/jres-2022/src/header.tex
new file mode 100644
index 0000000..4914847
--- /dev/null
+++ b/talks/jres-2022/src/header.tex
@@ -0,0 +1,86 @@
+
+\usepackage[utf8]{inputenc}
+\usepackage[T1]{fontenc}
+\usepackage{graphicx}
+\usepackage{longtable}
+\usepackage{wrapfig}
+\usepackage{rotating}
+\usepackage[normalem]{ulem}
+\usepackage{amsmath}
+\usepackage{amssymb}
+\usepackage{capt-of}
+\usepackage{hyperref}
+\usepackage[french]{babel}
+\usepackage{fancyvrb}
+
+\usepackage{tikz}
+\usetikzlibrary{decorations.pathreplacing,positioning, arrows.meta}
+
+
+\usetheme{Madrid}
+\useoutertheme[subsection=true]{smoothbars}
+
+\makeatletter
+\usecolortheme{whale}
+\usecolortheme{orchid}
+\setbeamerfont{block title}{size={}}
+\setbeamertemplate{navigation symbols}{}
+\setbeamertemplate{itemize items}[triangle]
+\makeatletter
+\setbeamertemplate{footline}
+{
+ \leavevmode%
+ \hbox{%
+ \begin{beamercolorbox}[wd=.15\paperwidth,ht=2.25ex,dp=1ex,left]{author in
head/foot}%
+ \usebeamerfont{author in head/foot}\quad S. Tournier
+ \end{beamercolorbox}%
+ \begin{beamercolorbox}[wd=.7\paperwidth,ht=2.25ex,dp=1ex,center]{title in
head/foot}%
+ \usebeamerfont{title in head/foot}\insertshorttitle
+ \end{beamercolorbox}%
+ \begin{beamercolorbox}[wd=.15\paperwidth,ht=2.25ex,dp=1ex,right]{date in
head/foot}%
+ \insertframenumber{} / \inserttotalframenumber\hspace*{2ex}
+ \end{beamercolorbox}}%
+ \vskip0pt%
+}
+\makeatother
+
+\title[Reproductibilité des environnements logiciels avec GNU Guix]%
+{Reproductibilité des environnements logiciels \\ avec GNU Guix}
+\author{Simon Tournier}
+\date{JRES, 19 mai 2022}
+\institute{Inserm US53 - UAR CNRS 2030 \\ \texttt{simon.tournier@u-paris.fr}}
+\hypersetup{
+ pdfauthor={Simon Tournier},
+ pdftitle={Reproductibilité des environnements logiciels avec GNU Guix},
+ pdfkeywords={GNU Guix, reproductibilité, déploiement logiciels, gestionnaire
de paquets, machine virtuelle},
+ pdfsubject={tutoriel court de l'outil GNU Guix},
+ pdfcreator={with love},
+ pdflang={French}}
+
+
+\newcommand{\violet}{\textcolor{violet}}
+\newcommand{\blue}{\textcolor{blue}}
+\newcommand{\red}{\textcolor{red}}
+\newcommand{\magenta}{\textcolor{magenta}}
+\newcommand{\cyan}{\textcolor{cyan}}
+\newcommand{\green}{\textcolor{green}}
+\definecolor{mauve}{rgb}{0.58,0,0.82}
+\newcommand{\mauve}{\textcolor{mauve}}
+
+\input{listings-scheme}
+
+\newcommand{\someguile}{\textcolor{someguile}}
+\newcommand{\somestring}{\textcolor{somestring}}
+\newcommand{\somevariable}{\textcolor{somevariable}}
+
+\newcommand{\thisslide}[1]{%
+ \begin{figure}[!htb]
+ \begin{center}
+ \includeslide[width=\textwidth]{#1}
+ \end{center}
+ \end{figure}
+}
+
+\newcommand{\smiley}[1]{${\textsf{#1~}}^{\textrm{:-)}}$}
+
+\newcommand{\hrefsf}[2]{\href{#1}{\textsf{#2}}}
diff --git a/talks/jres-2022/src/listings-scheme.tex
b/talks/jres-2022/src/listings-scheme.tex
new file mode 100644
index 0000000..359817a
--- /dev/null
+++ b/talks/jres-2022/src/listings-scheme.tex
@@ -0,0 +1,97 @@
+% This file contains some restricted keywords for highlighting the all the
+% snippets in LaTeX. The main purpose is to easy reading the Scheme
+% Domain-Specific code by coloring what is Guile-specific, user-specific and
DSL-specific.
+%
+% The language shell is also trivially defined.
+
+\usepackage{listings}
+\usepackage{color}
+
+\definecolor{someguile}{rgb}{0.0, 0.25, 0.8}
+\definecolor{somestring}{rgb}{0.8, 0.25, 0.0}
+\definecolor{somevariable}{rgb}{0.0, 0.5, 0.0}
+\definecolor{somecomment}{rgb}{1.0, 0.0, 0}
+\definecolor{bracket}{rgb}{0.6, 0.6, 0.6}
+
+\lstdefinelanguage{Scheme}{
+ basicstyle=\normalsize\ttfamily\slshape\color{somevariable},
+ sensitive=true,
+ alsoletter={-,\#,:,>},
+ morestring = [b]",
+ stringstyle=\upshape\color{somestring},
+ morecomment=[l]{;},
+ commentstyle=\upshape\color{somecomment},
+ literate=
+ *{(}{{\textcolor{bracket}{(}}}{1}
+ {)}{{\textcolor{bracket}{)}}}{1},
+ classoffset=0,
+ % Guile
+ morekeywords={
+ define, define-public,
+ list, map, compose,
+ cons,
+ lambda,
+ let, let*, quote,
+ append, string-append,
+ use-modules, define-module, \#:use-module, \#:prefix
+ },
+ keywordstyle=\ttfamily\upshape\color{someguile},
+ classoffset=1,
+ % Fix
+ morekeywords={
+ guix, transformations,
+ gnu, srfi, srfi-1,
+ desktop, mcron, networking, xorg,
+ certs, fonts,
+ font-bitstream-vera, nss-certs,
+ xfce-desktop-service-type,
+ cron-jobs, mcron-service-type,
+ dhcp-client-service-type,
+ },
+ keywordstyle=\ttfamily\upshape\color{black},
+ classoffset=1,
+ % DSL
+ morekeywords={
+ package,
+ name, version,
+ build-system, gnu-build-system, arguments,
+ inputs,
+ synopsis, description, license,
+ source, origin,
+ method, url-fetch, git-fetch,
+ specifications->manifest, specification->package, packages->manifest,
+ options->transformation, with-c-toolchain,
+ },
+ % DSL VM
+ morekeywords={
+ use-service-modules, use-package-modules,
+ operating-system,
+ host-name, timezone, locale, keyboard-layout, label, firmware,
+ bootloader, bootloader-configuration, grub-bootloader, targets,
terminal-outputs,
+ users, user-account, name, password, group, supplementary-groups,
+ file-systems, file-system, mount-point, device, type,
+ base-file-systems, % bug with %base-
+ base-user-accounts,
+ base-packages,
+ packages,
+ services, service, simple-service,
+ plain-file,
+ },
+ keywordstyle=\ttfamily\bfseries\upshape\color{black},
+ classoffset=0,
+}
+
+\lstdefinelanguage{shell}{
+ basicstyle=\normalsize\ttfamily,
+ sensitive=true,
+ morestring = [b]",
+ stringstyle=\upshape\color{red},
+ morecomment=[l]{\#},
+ commentstyle=\upshape\color{green},
+}
+
+% \lstdefinelanguage{text}{
+% basicstyle=\normalsize\ttfamily,
+% sensitive=true,
+% commentstyle=\upshape\color{green},
+% }
diff --git a/talks/jres-2022/src/manifest.scm b/talks/jres-2022/src/manifest.scm
new file mode 100644
index 0000000..7e649dc
--- /dev/null
+++ b/talks/jres-2022/src/manifest.scm
@@ -0,0 +1,26 @@
+(specifications->manifest
+ (list
+ "rubber"
+
+ "texlive-base"
+ "texlive-fonts-ec"
+ "texlive-kpfonts"
+ "texlive-cm-super"
+ "texlive-amsfonts-fixed"
+
+ "texlive-beamer"
+ "texlive-translator"
+ "texlive-ulem"
+ "texlive-capt-of"
+ "texlive-hyperref"
+ "texlive-carlisle"
+
+ "texlive-latex-geometry"
+ "texlive-latex-wrapfig"
+ "texlive-latex-amsmath"
+ "texlive-babel-french"
+ "texlive-latex-listings"
+ "texlive-latex-fancyvrb"
+ "texlive-latex-pgf"
+ "texlive-latex-fancyhdr"
+ ))
diff --git a/talks/jres-2022/src/presentation.tex
b/talks/jres-2022/src/presentation.tex
new file mode 100644
index 0000000..202777d
--- /dev/null
+++ b/talks/jres-2022/src/presentation.tex
@@ -0,0 +1,70 @@
+\documentclass[aspectratio=169,ignorenonframetext,presentation]{beamer}
+
+\input{header}
+
+\begin{document}
+
+\begin{frame}[plain, fragile, noframenumbering]{}
+ \vspace{5mm}
+ \titlepage
+
+ \vfill{}
+ \vspace{-12mm}
+ \begin{center}
+ \includegraphics[width=0.2\paperwidth]{static/Guix-white}
+
+ \vspace{-10mm}
+ \href{https://hpc.guix.info}{\texttt{https://hpc.guix.info}}
+ \end{center}
+ \vfill{}
+ \normalsize
+ \begin{minipage}{0.2\paperwidth}
+ \vspace{-7mm}
+ \includegraphics[width=0.2\paperwidth]{static/LOGO-JRES-2022}
+ \end{minipage}
+ \begin{flushright}
+ \begin{minipage}{0.2\paperwidth}
+ \vspace{-20mm}
+ \includegraphics[width=0.2\paperwidth]{static/u-paris}
+ \end{minipage}
+ \end{flushright}
+\end{frame}
+
+
+%% From Beamer documentation p.207
+%% User Guide for version 3.66.
+%% http://mirrors.ctan.org/macros/latex/contrib/beamer/doc/beameruserguide.pdf
+\mode<all>
+\input{contenu}
+\mode*
+
+\begin{frame}[plain, noframenumbering]{}
+ \begin{center}
+ \vfill{}
+ \Large{%
+ \textbf{%
+ Des questions ?%
+ }}\normalsize
+
+ \vfill{}
+ \texttt{guix-science@gnu.org}
+
+ \vfill{}
+ \includegraphics[width=0.2\paperwidth]{static/cafe-guix}\\
+
\href{https://hpc.guix.info/events/2022/café-guix/}{\texttt{https://hpc.guix.info/events/2022/café-guix/}}
+
+ % \vfill{}
+ % \tiny{%
+ % Copyright \copyright{} 2021 Simon Tournier%
+ % }
+ \end{center}
+\end{frame}
+
+%% From Beamer documentation p.207
+%% User Guide for version 3.66.
+%% http://mirrors.ctan.org/macros/latex/contrib/beamer/doc/beameruserguide.pdf
+\mode<all>
+\input{supplement}
+\mode*
+
+\end{document}
diff --git a/talks/jres-2022/src/static/Guix-white.pdf
b/talks/jres-2022/src/static/Guix-white.pdf
new file mode 100644
index 0000000..3641e7f
Binary files /dev/null and b/talks/jres-2022/src/static/Guix-white.pdf differ
diff --git a/talks/jres-2022/src/static/LOGO-JRES-2022.png
b/talks/jres-2022/src/static/LOGO-JRES-2022.png
new file mode 100644
index 0000000..aa190df
Binary files /dev/null and b/talks/jres-2022/src/static/LOGO-JRES-2022.png
differ
diff --git a/talks/jres-2022/src/static/cafe-guix.png
b/talks/jres-2022/src/static/cafe-guix.png
new file mode 100644
index 0000000..1698c65
Binary files /dev/null and b/talks/jres-2022/src/static/cafe-guix.png differ
diff --git a/talks/jres-2022/src/static/forest-symlinks.pdf
b/talks/jres-2022/src/static/forest-symlinks.pdf
new file mode 100644
index 0000000..527cf68
Binary files /dev/null and b/talks/jres-2022/src/static/forest-symlinks.pdf
differ
diff --git a/talks/jres-2022/src/static/graph-python.png
b/talks/jres-2022/src/static/graph-python.png
new file mode 100644
index 0000000..b0026b2
Binary files /dev/null and b/talks/jres-2022/src/static/graph-python.png differ
diff --git a/talks/jres-2022/src/static/guixhpc-logo-transparent-white.pdf
b/talks/jres-2022/src/static/guixhpc-logo-transparent-white.pdf
new file mode 100644
index 0000000..3368aad
Binary files /dev/null and
b/talks/jres-2022/src/static/guixhpc-logo-transparent-white.pdf differ
diff --git a/talks/jres-2022/src/static/u-paris.png
b/talks/jres-2022/src/static/u-paris.png
new file mode 100644
index 0000000..0b9ac7e
Binary files /dev/null and b/talks/jres-2022/src/static/u-paris.png differ
diff --git a/talks/jres-2022/src/supplement.tex
b/talks/jres-2022/src/supplement.tex
new file mode 100644
index 0000000..a167422
--- /dev/null
+++ b/talks/jres-2022/src/supplement.tex
@@ -0,0 +1,281 @@
+\mode* %Follow up of Beamer configuration when using ignorenonframetext.
+
+\clearpage
+\appendix
+\section{Bonus}
+
+\subsection{Définition fonctionnelle d'un paquet}
+
+Pour Guix, la construction d'un paquet est vue comme une fonction pure :
+
+\begin{itemize}
+\item la construction retournée est la même pour les mêmes arguments,
+\item l'évaluation n'a pas d'effets de bord.
+\end{itemize}
+Par exemple, si la compilation sauvegarde la date, alors la
+construction retournée n'est pas identiquement la même pour les mêmes
+arguments. Par ailleurs, l'évaluation a un effet de bord car fournir
+une date est une action qui a besoin d'éléments extérieurs qui ne
+dépendent pas uniquement ni exclusivement du corps de la fonction.
+
+
+\thisslide{def-fonc}
+\begin{frame}<presentation>[label=def-fonc, fragile,
noframenumbering]{Définition fonctionnelle (\emph{derivation})
+ \hfill \small{(A valeur d’illustration pour fixer les idées)}\normalsize}
+ \vspace{-0.35cm}
+ \begin{Verbatim}[commandchars=\\\{\}]
+{def} pkg(\blue{source}, \magenta{build_sytem}, \magenta{arguments},
\violet{inputs}):
+ src = fetch(source)
+ {import} build_system {as} bs
+ build = bs.builder(arguments)
+ envBuild = build.add(inputs)
+ binary = envBuild(src)
+ {return} binary
+ \end{Verbatim}
+
+\begin{center}
+ \texttt{python3 = pkg(\blue{Python}, \magenta{configure\_make},
+ \violet{deps}=[bzip2, expat, ...]) }
+\end{center}
+
+ \vspace{-0.35cm}
+ \begin{exampleblock}{}
+ \begin{itemize}
+ \item Les {sources} \texttt{src} sont obtenues à partir de la définition du
+ paquet via \blue{\texttt{source}}
+ \item La recette \texttt{build} est déduite de la définition du paquet via
+ \magenta{\texttt{build-system}} et \magenta{\texttt{arguments}}
+ (\texttt{./configure \&\& make \&\& make install})
+ \item L’environnement \texttt{envBuild} est \uline{\textbf{totalement
+ isolé}} et ne contient que le nécessaire défini par
+ \magenta{\texttt{build-system}} étendus de dépendances
+ \violet{\texttt{inputs}} supplémentaires
+ \end{itemize}
+ \end{exampleblock}
+\end{frame}
+
+
+\clearpage
+\subsection{Autour du graphe des dépendances}
+
+Suivant la transformation de paquets que nous appliquons, il peut arriver que
+le \emph{monde} soit recompilé. Ici, nous illustrons la signification d'un
+contrôle fin du graphe des dépendances.
+
+\bigskip
+
+Nous commençons par construire la paquet \texttt{python} avec le chaîne de
+compilation \texttt{gcc@7} via un fichier déclaratif \emph{manifeste}. En
+étant attentifs, nous remarquons que le paquet \texttt{ghc-emojis} sera
+reconstruit.
+
+\thisslide{around-dag}
+\begin{frame}<presentation>[label=around-dag, fragile, noframenumbering]%
+ {Transformations : pourquoi tout peut-il être recompilé ?}
+ \begin{exampleblock}{}
+\begin{verbatim}
+$ guix build -m example/some-python-with-gcc7.scm --derivations --dry-run
+...
+/gnu/store/vi2j8aakp7jqxq8m97xvqk0d8q8i27s2-ghc-emojis-0.1.2.drv
+...
+\end{verbatim}
+ \end{exampleblock}
+
+ La recette définit :
+ \begin{itemize}
+ \item un \blue{code source} et potentiellement des modifications
\emph{ad-hoc} (\verb+patch+)
+ \item des \magenta{outils de construction} (compilateurs, moteur de
+ production, etc., p. ex. \verb+gcc+, \verb+cmake+)
+ \item des \violet{dépendances}
+ \end{itemize}
+
+
+ \begin{exampleblock}{}
+ \begin{center}
+ Pourquoi doit-on recompiler une bibliothèque Haskell sur les caractères
+ emoji ?
+ \end{center}
+ \end{exampleblock}
+\end{frame}
+
+La question est pourquoi une pile logicielle Python à caractère scientifique
+dépend-elle d'une bibliothèque Haskell de caractère emojis ?
+
+\bigskip
+
+Rappelons que Guix permet d'inspecter le graphe des dépendances. Par exemple,
+le paquet \texttt{python} a 137 dépendances (n\oe uds), majoritairement
+indirectes.
+
+\bigskip % because issue with layout
+
+
+\thisslide{dag-bis}
+\begin{frame}<presentation>[label=dag-bis, fragile, noframenumbering]%
+ {Graph Acyclique Dirigé (\emph{DAG})}
+ \vspace{-0.5cm}
+ \begin{center}
+ \texttt{guix graph -{}-max-depth=6 python | dot -Tpng > graph-python.png}
+ \end{center}
+
+ \vfill{}
+ \includegraphics[width=\textwidth]{static/graph-python.png}
+ \vfill{}
+
+ Graphe complet : \red{Python = 137 n\oe uds}, Numpy = 189, Matplotlib = 915,
Scipy
+ = 1439 n\oe uds
+\end{frame}
+
+
+
+\thisslide{inspect-dag}
+\begin{frame}<presentation>[label=inspect-dag, fragile, noframenumbering]%
+ {Inspection du graphe des dépendances}
+ \vspace{-0.2cm}
+\begin{verbatim}
+python-scipy The Scipy library provides efficient numerical routines
+ghc-emojis Conversion between emoji characters and their names
+\end{verbatim}
+
+ \vspace{-0.1cm}
+ \begin{exampleblock}{}
+ \begin{center}
+ Quelle dépendance entre une bibliothèque scientifique et une
+ bibliothèque de pictogrammes ?
+ \end{center}
+ \end{exampleblock}
+
+ \begin{tabular}{p{0.5\linewidth}p{0.5\linewidth}}
+ \begin{minipage}[t]{0.5\linewidth}
+\begin{Verbatim}[commandchars=\\\{\}]
+$ guix graph \textbackslash
+ --path \blue{python-scipy} \red{ghc-emojis}
+\blue{python-scipy@1.7.3}
+python-pydata-sphinx-theme@0.6.3
+python-jupyter-sphinx@0.3.2
+python-nbconvert@6.0.7
+pandoc@2.14.0.3
+\red{ghc-emojis@0.1.2}
+\end{Verbatim}
+ \end{minipage}
+ &
+ \begin{minipage}[t]{0.5\linewidth}
+\begin{Verbatim}[commandchars=\\\{\}]
+$ guix graph \textbackslash
+ -t bag-emerged \textbackslash
+ --path \red{ghc-emojis} \violet{python}
+\red{ghc-emojis@0.1.2}
+ghc@8.10.7
+\violet{python@3.9.9}
+\end{Verbatim}
+ \end{minipage}
+ \end{tabular}
+
+ \begin{alertblock}{}
+ \begin{center}
+ Guix permet un contrôle fin de l'arbre des dépendances et son inspection
+ \end{center}
+ \end{alertblock}
+\end{frame}
+
+Nous cherchons donc quel est le chemin entre la bibliothèque scientifique
+Python Scipy et la bibliothèque Haskell Emojis. Incroyable, non ? Pour
+construire Scipy, une bibliothèque Python traitant principalement de calcul
+scientifique comme des solveurs de système linéaire, il faut donc un
+compilateur Haskell comme GHC.
+
+\medskip
+
+Nous cherchons ensuite quel est le chemin entre la bibliothèque Haskell Emojis
+et l'interpréteur Python. Incroyable, à nouveau, car il y en a un. Le
+compilateur Haskell a besoin de Python.
+
+\bigskip
+
+Finalement, recompiler le paquet \texttt{python} va automatiquement recompiler
+\texttt{ghc}. Puis, comme le \emph{build system} du paquet
+\texttt{ghc-emojis} n'est pas identiquement le même, ce paquet va être
+reconstruit. Et ainsi de suite\dots
+
+\clearpage
+\subsection{Pour fixer les idées}
+
+
+\thisslide{exec}
+\begin{frame}<presentation>[label=exec, fragile, noframenumbering]%
+ {Que signifie exécuter un programe ?}
+ \vspace{-0.5cm}
+\begin{verbatim}
+python3 -c 'print(1+2)'
+\end{verbatim}
+
+ \begin{itemize}
+ \item \texttt{python3} est ici un exécutable binaire (lisible par une
machine)
+ \item Le code source de \emph{Python} est
\href{https://github.com/python/cpython}{accessible} (lisible par une personne)
+ \item \texttt{python3} dépend à l’exécution de bibliothèques (dépendances)
+ \end{itemize}
+
+ \begin{center}
+ Comment \texttt{python3} est-il obtenu ?
+ \end{center}
+
+ Analogie: \texttt{yahourt} = \emph{Lait} + \texttt{skyr}
+ (Skyr : Yaourt islandais)
+
+ \begin{center}
+ \texttt{python3} = \emph{Python} + \texttt{compilateur} (+ \texttt{make} +
etc.)
+ \end{center}
+
+ \begin{alertblock}{Conclusion}
+ \begin{itemize}
+ \item Les sources (\emph{Python}) ne suffisent pas pour la
Reproductibilité,
+ \item il faut aussi connaître deux environnements :
+ \begin{itemize}
+ \item de construction (\texttt{compilateur}, \texttt{make}, etc.),
+ \item d’exécution (dépendances)
+ \end{itemize}
+ \end{itemize}
+ \end{alertblock}
+\end{frame}
+
+Pour trouver les dépendances nécessaires à l'exécution, il suffit de lancer
+\texttt{ldd \$(which python3)}. À titre d'illustration, ces bibliothèques sont
+nécessaires~: \texttt{linux-vdso.so.1 libpthread.so.0 libutil.so.1 libm.so.6
...}
+
+\medskip
+
+Par conséquent, on peut se demander :
+\begin{enumerate}
+\item Comment le binaire \texttt{python3} a-t-il été produit ? Quel
+ compilateur ? Quelles dépendances ?
+\item Comment les dépendances ont-elles été produites ?
+\end{enumerate}
+
+
+\thisslide{pkg-manager}
+\begin{frame}<presentation>[label=pkg-manager, fragile, noframenumbering]%
+ {Qu'est-ce qu'un gestionnaire de paquets ?}
+ \begin{center}
+ gestionnaire des paquets = gestion des dépendances
+ \end{center}
+ fournit dans une mesure l’environnement de construction et/ou d’exécution.
+
+ \begin{exampleblock}{Est-ce que \texttt{foo} = \texttt{bar} ?}
+ \begin{itemize}
+ \item \texttt{foo} <- \emph{Source@1.2} + \texttt{env-construction@A}
+ \item \texttt{bar} <- \emph{Source@1.2} + \texttt{env-construction@B}
+ \end{itemize}
+ \end{exampleblock}
+
+ \begin{center}
+ Comment s’assurer que deux environnements sont identiques ?
+ \end{center}
+
+ \begin{alertblock}{Conclusion}
+ Trop de combinaisons pour avoir le même environnement :
+ \begin{itemize}
+ \item sur plusieurs machines,
+ \item à différents points dans le temps.
+ \end{itemize}
+ \end{alertblock}
+\end{frame}
diff --git a/talks/jres-2022/src/support-notes-additionnelles.tex
b/talks/jres-2022/src/support-notes-additionnelles.tex
new file mode 100644
index 0000000..73b6a41
--- /dev/null
+++ b/talks/jres-2022/src/support-notes-additionnelles.tex
@@ -0,0 +1,58 @@
+\documentclass[a4paper,oneside,11pt]{article}
+\usepackage{beamerarticle}
+\setjobnamebeamerversion{presentation}
+
+\AtBeginDocument{\def\labelitemi{$\bullet$}}
+
+\usepackage{fancyhdr}
+
+\fancyhf{}
+\fancyhead[R]{Guix @ JRES 2022}
+\fancyfoot[C]{\thepage}
+\pagestyle{fancy}
+\newlength\tindent
+\setlength{\tindent}{\parindent}
+\setlength{\parindent}{0pt}
+
+% \renewcommand{\indent}{\hspace*{\tindent}}
+% \usepackage[french]{babel}
+
+\input{header}
+
+\hyphenation{%
+ as-su-rer
+ au-to-ri-ser
+ col-lec-tion
+ com-man-de
+ com-men-cer
+ com-pi-la-teur
+ com-pu-ta-tion-nel
+ cons-trui-re
+ dif-fi-cul-té
+ dis-po-ni-bi-li-té
+ dé-fi-nis-sons
+ dé-pen-dan-ces
+ en-vi-ron-ne-ments
+ ex-ploi-ta-tion
+ ex-pé-ri-men-tal
+ i-den-ti-que-ment
+ ma-chi-ne
+ op-tions
+ re-po-si-tion-nables
+ re-pro-duc-ti-ble
+ re-pro-duc-ti-bi-li-té
+ re-tour-née
+ scien-ti-fi-que scien-ti-fi-ques
+ sur-es-ti-mant
+ to-ta-le-ment
+ u-ti-li-sa-tion
+ ver-sion
+}
+
+\begin{document}
+
+\maketitle
+\input{contenu}
+\input{supplement}
+
+\end{document}
diff --git a/talks/jres-2022/support-notes-additionnelles.20220519.pdf
b/talks/jres-2022/support-notes-additionnelles.20220519.pdf
new file mode 100644
index 0000000..91adbe9
Binary files /dev/null and
b/talks/jres-2022/support-notes-additionnelles.20220519.pdf differ
diff --git a/talks/jres-2022/talk.20220519.pdf
b/talks/jres-2022/talk.20220519.pdf
new file mode 100644
index 0000000..dc200b5
Binary files /dev/null and b/talks/jres-2022/talk.20220519.pdf differ