persistent reproducibility ?

[zimoun]

Hi Guixers,


Disclaimer: my background is about numerical analysis (PDE, Krylov
solver, etc.) and I am currently working in some Core Facility about
biology and bioinformatic (NGS pipelines, flow cytometry clustering,
etc.). Orthogonal communities but same issues. :-)


The typical research workflow is:

- Alice proposes new method and/or algorithm, publishes a paper and
illustrates that by the software `foo'. Let the best case: Alice
provides a Guix "recipe", and all the material is stored in Github
(let say). This software `foo' depends on both `bar' and `baz', one
also in Github and the other one included in the Guix package tree.

- It is easy for Bob to check out and experiment. Guix allows him to
straightforwardly build the bit identical `foo' (all dependencies
included). Nice!! Repeatability is there for free.

- New features are added to `foo', `bar' and `baz'. All the codes
evolve, especially the research ones.

- Now, Joe is implementing the Alice's method; science means
reproducible. And Joe would like to compare his implementation to the
Alice one provided by `foo'. However, how ? The `foo' "ecosystem" has
changed with the new features. Therefore, Joe has to navigate in the
Git tree of the Guix "recipe" of `foo', `bar', `baz' to be able to
produce the bit-identical `foo' used in the initial paper. I mean, it
is what I understand to do, and it does not seem reasonable.


My question is: does Guix provide any mechanism to build reproducible
software over the time ?


Last, `foo' and `bar' are stored in two Github repositories. And they
should disappear.
( I am not talking if it is good or not to use github, right now, it
just is used by many teams of researchers )

Could we used the Software Heritage initiative to maintain a kind of
persistency ?
https://www.softwareheritage.org


I do not know if my wishes make any sense.

All the best,
-simon