So, sorry for the mess. It's a bit impressing all these people and so on. I'm Simon. I'm
working as a research engineer in the University of Paris and I'm going here to present you
Geeks to be able to do some reversible research and there is a group Geeks HPC which tried
to apply Geeks tooling for scientific context. So, currently we are in a replication and
reproducibility crisis. So, more than 70% of researchers are enabled to reproduce the
results of peers or more than half are enabled to reproduce their own results. So, we have
a big issue. So, there is many problems of this replication crisis and maybe one solution
is open science. So, what does it mean open science? So, what does it mean science? Science
means being transparent and collective activity. And what is a scientific result? Scientific
result is some experiment. So, producing experimental data and then we have some numerical processing.
So, to do that in today, we have different way because we need to communicate so we need
to write results. So, we need open article to be able to read the results. We need to
share the data. So, we have open data. We need to share the source code. But there is
something that we never discuss is that all that need to be glued together because there
is a numerical processing. So, we need to glue everything together. So, we need another
one. We need a computational environment and this is really mean is one of the issue
is that if this is not open, all the other stack is failing. So, that is the topic of
today. How do we manage this computational environment? So, again, a result is a paper,
some data and an analysis. And there is some parts which are mean possible to audit. For
example, a paper, you can read it. A data, you can read the protocol that generates the
data. You have analysis. You can read the script. But there is some part that are opaque.
For example, the instrument, a telescope, a microscope. This is opaque. We don't know
how it works. But there is something that is depend on our collective practice as researcher.
And this is something that we can act on to do a better research. So, the question is
to be able to eliminate at least this dependent and turn this as an auditable task to be really
transparent. So, yeah, from my point of view, a computation and computing is just similar
to an instrument. So, we should apply the same strategy that experimental people are
applying for any instrument. And computing is just an experiment, in fact. So, the challenge
about reputable science. From my point of view, there is two kinds. The first one is
controlling the source of variation. What is different between this and that? So, between
this computational environment and this computational environment. Because as with a telescope,
for example, we want to know what is different between this telescope and this telescope
to be sure that what we are observing is correct. So, from a scientific method, we
need that the computational environment is transparent. And from a scientific knowledge
viewpoint, what we are building together need to be independent. So, what I'm observing,
you should observe the same. And this observation should be sustainable when the time is passing.
We should be able to observe the same thing. Otherwise, it means that maybe we miss something.
So, the big question today is with this kind of context, how do we redo later and elsewhere?
So, I did something on my machine and you have to do this thing on your machine, for
example, six months or one year or five years later, with the computer. And this is a big
issue and is part of the reputable crisis in science from my point of view. So, what
is a computational environment? Computational environment implies various points. For example,
what is a source code? But, for example, if, say, I use Python and this script, okay,
we have the source code of Python is in C and we have the source code of this Python
script, okay. But the Python interpreter requires a C compiler. So, we need tools for building.
And my script, for example, needs some Python library. So, we need also tools for running
at runtime. So, and each tool has the same issue. What is the source code? What is the
tools for building? And so, this is really reclusive. So, this is a big issue. And answering
all these questions is controlling the source of variation. So, the question is, so, how
do we capture the answer of all these questions? So, the question is not new. We have already
tools, package manager, modified container. So, for example, with package manager, like
APT for Debian, you can control this computational environment. But there is some issue. For
example, how do you have several versions of open blasts on the same machine? It doesn't
work really easily with Debian or with you and so on. So, there is fixes, but it's not
really, I mean, practically, sometimes it's difficult. So, you have, to fix this issue,
you have an environment manager, like Conda, PIP, Modifies, and so on. But this is really
difficult because, for example, in Conda, how do you know how it is built? What is inside
what you install? So, this is for transparency in science. Modifies, how do you use Modifies
on the laptop? I think no one. And Docker is for container, Docker, Singularity, or whatever,
is a strategy which generally based on the previous solution. So, in fact, you have exactly
the same problems as the previous solution. It just helps to move stuff from one place
to the other one, but it doesn't help to be able to have the correct thing in the first
time. Geeks, in fact, is all these three solutions glued together. So, it tries to fix all the
annoyance from each to have something, I mean, working, fixing all the issues of everything.
So, Geeks is a package manager, like APT, UME, etc. It's transactional and declarative.
It means that you can roll back, you can have a concurrent version, and so on. You can produce
a pack, which is Docker images, for example. You can produce virtual machines, like Ansible
for deploying on some machine. You can build a complete distribution, and it's also a
self-came library, so you can extend Geeks. So, okay, the talk is 25 minutes. So, it's
just a kind of aperitif before lunch. So, I don't speak about all that, because it's
a little too much. So, I just speak about how Geeks help in open research from my point
of view. So, I think it's really easy to try. You have just a script, and give a look before
installing it. It's just a bar script, but check it. And you can install Geeks on any
recent distribution. So, it's really easy to try. You are running Debian. You can try
Geeks without installing the complete distribution. You can use Geeks on the top of any distribution,
and it's really easy to try. Give a try. So, now, Geeks is just another package manager.
So, you have the same command that you have in any package manager, for sharing packages,
showing packages, installing packages, removing packages, and so on. It's exactly the same
as any package manager. But you have some more functionality, like transactional. So, everything,
you can do two actions in the same time. So, for example, removing and installing in the
same transaction. Or you can roll back. So, for example, you install something, and you
want to roll back to uninstall this thing without breaking nothing. So, okay, this is
another package manager. But is it really another package manager? So, yeah, we can have,
it's a command line. It's a, we install, remove without special privilege. So, this is nice.
It's transactional. So, there is no broken state. We have been able to substitute. So,
we don't have to wait hours and hours to have our binary. But this is nice. But what is
really, really nice is decorative management. It means that everything is a configuration
file with scheme. But you can declare everything. And you can produce isolated environment on
the fly. This is something that's really helpful. And you can also see Geeks as a factory for
the Docker images, for example. So, okay, this is all interesting feature. But why Geeks
is reproducible? Or what does it mean it's reproducible? For reproducibility, we need
to talk about what is a version. So, what is a version? Alice say, for example, I use
GCC Adversion 11. Okay, nice. But what does it mean, concretely, I use GCC Adversion 11.
It means that you need GCC, the compiler. But you also need AD, which is the linker.
And you know, Binitils, for example. And the Jelitsi library. But the compiler GCC, it
needs, for example, MPC, which is a package that does, I don't know what exactly. Anyway.
And you need also MPFR and so on. And you have this kind of graph. And we can ask the
question, is it the same GCC Adversion 11 if we replace this MPFR Adversion 4.1 by MPFR
Adversion 4.0? Is it the same GCC or not? And maybe not. And if it is not the same, maybe
you are feeling a difference. How can we be sure that we are using the exact same GCC?
So this is just an extract of the graph because the graph have roots. And yeah, it can be
really large. And maybe we can also talk about what are the roots of this graph. But this
is another talk. So when you say that, okay, but I need to have a version. So what is my
version in GICS? So GICS describe the state of GICS. So in fact, GICS describe is a version
of GICS. And what it does, in fact, it pins the complete collection of all the packages
and GICS itself. And because of that, we are able to freeze the complete graph. We can
move this graph from one place to the other. So, okay. So this graph, in fact, describe
the nodes of each, each, each node in this graph specify a receipt. And this receipt
defines the code source, the build time tombs, and the dependency. So for me, yeah. And this
graph can be really, really large. For example, for Skypy, which is a scientific Python library,
there is more than 1,000 nodes. So, yeah, it can be really large. So for when I say GCC
at version 11, it means one fixed graph. And providing the state which describe, this capture
this complete graph. And I can reproduce this complete graph on another machine. So this
is collaboration in action. So Alice describes the list of the tools in a manifest, declarative
way. She generates the environment, GICS shell, and providing the tools. So this creates an
environment containing the tools that are listed in the manifest file. Okay. This is
nice. But now she describes the revision of GICS. So she writes GICS describe and this
fix the state of Alice. So, okay, this Alice is working on her laptop. But collaboration
is share this computational environment. So it's about sharing the state. To share this
state, you need to share one specific graph. To share this graph, you need to only share
these two files. And if, sorry, if Blake has these two files, Blake can create the exact
same computational environment as Alice. So you have the GICS time machine. You specify
the state of Alice shell and specify the tools that Alice used. And Blake and Alice are running
the exact same computational environment. And for example, if you have Carol, who knows
these two files, she also can reproduce the exact same that Alice and Blake. So, in fact,
you only need two files. And with these two files, you can reproduce everything from one
place to the other. So, in fact, you have this kind of picture. Alice, Blake, Carol are
in different time frame. But they can jump from this time frame, virtually time different
time frame, to the same place. Because their machine are in different state, but they can
temporarily go to another state to create the computational environment. To make this work,
when the time is passing, you need to preserve all the source code. And this is not straightforward.
It is not trivial to preserve all the source code. And you also need some backward compatibility
of the Linux kernel and some compatibility of the hardware. But, okay. And when these
three conditions are satisfied, you have the reproducibility. But what is the size of the
window, of the time window, where these three conditions are satisfied? And this is, from
my point of view, unknown. And GICS is, to my knowledge, a case unique by experimenting
to be able, because we have the tooling to do all that. And now we can know what is the
size that we are able to reproduce the past in the future. So what is software heritage?
So software heritage is an archive. It collects preserved software in source code form from
a very long term. And GICS is able to save the source code of the package and the receipt
of the package itself. And GICS itself is also saved in software heritage. And GICS is
able to use software heritage archive to fall back if a swim disappears. So you have the
postdoc working on some GitLab and Stance. And the account is closed because the postdoc
is moving to other place and so on. And now you have this paper with this URL of, with
the GitLab package and say, oh, no, it doesn't work because the account is closed. If you
were using GICS transparently, you can check if the source code is on software heritage.
And this asks really good question about how to see the software and do you notice it only
the source or, and what about the dependency and the build time options and so on. How
do you see the software? And how, I mean, how do you see this? Do you see it with intrinsic
identifier like checksum or with intrinsic identifier like version label? This is easy.
So in summary, there is three commands. I'm almost done, right? Yeah. So in summary, you
have three commands. And these three commands, which are GICS shell, GICS time machine and
GICS subscribe, they help you to have a computational environment that you can, I mean, inspect and
collectively share. So if you have this and two files, manifest and channel files, you
are reproducible over the time. So okay, for offline, when you are, because I hope I convince
you that is cool. So here is some resources that to, to, to, to, to read offline. So GICS
HPC is a group of people trying to apply this GICS tooling to, to, to, to, to scientific
research. And we are organizing coffee gigs where we, we drink coffee and speak about GICS.
There is a, an article trying to explain this kind of vision of what GICS could provide
for, for open research. And for French speaker, there is a one hour tutorial. So yeah. And
there is a, now GICS is tenure, so it's kind of ready. So they, we organize the ten years
events where there is some really nice materials about, about GICS. And GICS is not new at
first them. So yeah, there is, all the number are, are linked to, to the previous presentation.
So as you see, there is a 31 presentation about GICS in first them. So you have a lot
of material about what GICS can do for, for your job, for your task. So you run in production
on big cluster, but also in a lot of laptop and desktop. And here, for example, is to
paper in completely, I mean, medical and biomedical stuff using GICS as a, as, as tooling with,
as, as I presented about GICS shell, time machine and so on. So, okay, open science
means to be able to trace and transparent because is to be able to, to collectively
study bug to bug, to be what is different from one thing to the other thing. And this
is a scientific method and we have to apply the scientific method to the computational
environment. This is my, my opinion and the message that I, I would like you bring back
to home. And if you, if, if we have GICS, we can do that by controlling the environment
and compare two different environment to know what is different. So, okay, this is,
yeah, the kind of, what we are trying to, to do with the GICS project. So, thank you.
And I'm ready for your question.
Yeah. Yeah. So, we have five minutes for questions and switching speakers. Please take question
and do repeat them for the stream. Thanks. I will try to do my best. Yeah.
Yeah. Ah. Lobing. So, the question is, okay, I, I, I don't have the, the, the root privilege
to install GICS on the cluster because once GICS is installed on any cluster, you can,
you can run it without privilege, but you need to install, the first time you need to
install GICS, you need root privilege. And the system administrator of my cluster doesn't
mean, yeah, I need to convince him. So, maybe the, the answer is to say other people are,
are already doing that. So, it's, it's not, I mean, to reduce the scare to, to, to provide
a new tool. This is what I, I, I would like to try to say, okay, these people are doing,
they're doing it. So, maybe it's not so scary. Uh, I think it was after, yeah. So, yeah.
Yeah. You mentioned that you're not sure how, how big the time window is. Yeah.
If you look today, how far can you back and still reproduce? So, five years, ten years?
No. So, the, the question is, okay, what is the size of the window and can we go back
five years, uh, from now in the past? The issue is that the, the mechanism to, to bring
back in time or to, to, to travel in time in GICS, uh, had been introduced in, uh, 2019.
So, in fact, with GICS, we don't have the tooling to go back earlier. So, now, I mean,
the, the, the zero for GICS is, uh, is version one. So, it's, uh, 2019. Yeah.
Um, a lot of, um, scientists are using macOS and not Linux. Is there, is it possible to
use all this stuff even though GICS can't really run on macOS?
So, GICS cannot run on macOS. But we can ask the question, is it transparent if we are
running on macOS? So, is it, are we are playing scientific method if we are running on macOS?
So, I mean, I, I, I, I, I have not the question. It's, it's a collective decision. Yeah.
My name is Alain. Um, as far as I understand, uh, GICS, uh, or GICS, uh, provides the same
approach as the NICS. Yeah. So, um, I've never used, uh, GICS before, but I, uh, I have some
experience with NICS. Uh, is there any crucial difference?
So, from my point of view, oops. Ah, sorry, anyway. Um, in the slides, there, there is
a, some, uh, appendix. So, there is extra slides. And there is one extra slide trying
to, to explain what, from my point of view, the difference with NICS. So, the question
is, uh, what is the difference between NICS and, and GICS? Because NICS, you, I mean,
GICS use exactly the same, uh, functional strategy, package management, functional
strategy. So, what is the difference? From my point of view, the difference is that you
have a continuum in GICS in the language. The package are, are, are, are wrote in scheme
and, and, and, and the, the code of, uh, GICS itself is also wrote in scheme. The
configuration file are wrote in scheme. So, you have a, a, a big continuation with
everything. And because of that, you can extend GICS for your own, uh, uh, stuff.
So, for example, you can write a package transformation on the fly using, I mean,
GICS as a library. You cannot do that with, with NICS because you have a lot of
different tooling in C++ and some, uh, from my point of view, is this unity of,
of, of the, the, the, the continuum of the language.
Yeah. Yeah. But scheme allow you to, to write kind of domain specific language.
It's, it's, uh, it's, uh, it's, uh, yeah. It's, it's a, it's a good language to, to
write domain specific language. So, in fact, you have the both of, of the two worlds.
From my point of view. Thank you.
Oh yeah. Sorry. Last question. Yeah.
Uh, that's good. It's, it's, it's, it's a good language to, to write domain specific
language. So, in fact, you have the both of, of the two worlds. From my point of
view. Yeah. This is, uh, so, when you are running GICS, for example, on the top of
Debian, so, uh, how do we manage the graph and can we cut the graph to reuse a part
of the Debian part? I mean, a part of the graph from Debian. So, the question is,
uh, maybe it could be, maybe it could be, maybe it could be, maybe it could be,
a part of the graph from Debian. So, the question is, uh, maybe it could be
helpful for some packages. But, but when you do that, you are not able to, to
manage the computational environment. Because if you have, for example, if I
cut the graph on Debian, so I have a, a state in, in Debian with some packages,
I cut the graph at some place to use these Debian packages.
If I do that, how my collaborator can cut the graph
in the same place with the same Debian packages?
So this is kind of issue of replicability.
So from a practical point of view,
it could be nice because, for example,
Debian has some machine learning packages that are not
yet in Geek, so maybe we can reuse some part.
But from a replicability point of view,
you lose the property to move from one place to the other.