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 0000000000000000000000000000000000000000..3641e7fc651602a1953308a2e4e05d9171a69801
GIT binary patch
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 0000000000000000000000000000000000000000..aa190dfab9f600dfd230bb133dfd1495d68074e8
GIT binary patch
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 0000000000000000000000000000000000000000..1698c65b9042a352cafc8fe67ec621e95a3ef57f
GIT binary patch
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 0000000000000000000000000000000000000000..527cf68076ab526f2bd96e1fe1726954a4917b71
GIT binary patch
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 0000000000000000000000000000000000000000..b0026b2dc1d5ea9118131333e074ebfd062a015d
GIT binary patch
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 0000000000000000000000000000000000000000..3368aad7ff1607ed3809dc55eff45b45aeb56b83
GIT binary patch
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 0000000000000000000000000000000000000000..0b9ac7e9cd4dd9a5eb8059b390e637ac85a8e5ad
GIT binary patch
diff --git a/talks/jres-2022/src/supplement.tex b/talks/jres-2022/src/supplement.tex
new file mode 100644
index 0000000..b0f4a85
--- /dev/null
+++ b/talks/jres-2022/src/supplement.tex
@@ -0,0 +1,282 @@
+\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 0000000000000000000000000000000000000000..91adbe9764711280f5ff2d13a59dce5617e25752
GIT binary patch
diff --git a/talks/jres-2022/talk.20220519.pdf b/talks/jres-2022/talk.20220519.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..dc200b5d20419e0fb640a0a11df2e947809bb967
