From 5af1406a499ed3936fea303a532015e90370c4b6 Mon Sep 17 00:00:00 2001
From: Boud Roukema <boud@cosmo.torun.pl>
Date: Wed, 25 Nov 2020 17:07:28 +0100
Subject: Reviewer points 1-15; appendix clickable links

This commit updates "paper.tex" and "peer-review/1-answer.txt"
for the first 15 (out of 59!) reviewer points, excluding
points 2 (not yet done) and 9 (README-hacking.md needs
tidying).

A fix to "reproduce/analysis/make/paper.mk" for the
links in the appendices is also done in this commit (the same
algorithm as for paper.tex is added). The links in the appendices
are not (yet) clickable.
---
 paper.tex | 107 +++++++++++++++++++++++++++++++++-----------------------------
 1 file changed, 57 insertions(+), 50 deletions(-)

(limited to 'paper.tex')

diff --git a/paper.tex b/paper.tex
index ad4aa2b..0e3cf7a 100644
--- a/paper.tex
+++ b/paper.tex
@@ -126,7 +126,7 @@ Decades later, scientists are still held accountable for their results and there
 \section{Longevity of existing tools}
 \label{sec:longevityofexisting}
 \new{Reproducibility is defined as ``obtaining consistent results using the same input data; computational steps, methods, and code; and conditions of analysis'' \cite{fineberg19}.
-Longevity is defined as the time during which a project remains usable.
+Longevity is defined as the length of time during which a project remains usable.
 Usability is defined by context: for machines (machine-actionable, or executable files) \emph{and} humans (readability of the source).
 Many usage contexts do not involve execution: for example, checking the configuration parameter of a single step of the analysis to re-\emph{use} in another project, or checking the version of used software, or the source of the input data (extracting these from the outputs of execution is not always possible).}
 
@@ -150,7 +150,12 @@ We will thus focus on Docker here.
 
 \new{It is hypothetically possible to precisely identify the used Docker ``images'' with their checksums (or ``digest'') to re-create an identical OS image later.
 However, that is rarely done.}
-Usually images are imported with generic operating system (OS) names; e.g., \cite{mesnard20} uses `\inlinecode{FROM ubuntu:16.04}' \new{(more examples in the appendices)}.
+Usually images are imported with generic operating system (OS) names; e.g., \cite{mesnard20} uses `\inlinecode{FROM ubuntu:16.04}'
+  \ifdefined\noappendix
+  \new{(more examples in the \href{https://doi.org/10.5281/zenodo.\projectzenodoid}{appendices})}.%
+  \else%
+  \new{(more examples: see the appendices (\ref{appendix:existingtools})).}%
+  \fi%
 The extracted tarball (from \url{https://partner-images.canonical.com/core/xenial}) is updated almost monthly, and only the most recent five are archived there.
 Hence, if the image is built in different months, its output image will contain different OS components.
 In the year 2024, when long-term support for this version of Ubuntu expires, the image will be unavailable at the expected URL.
@@ -687,12 +692,12 @@ An advantages of VMs is that they are a single file which can be copied from one
 VMs are used by cloud service providers, enabling fully independent operating systems on their large servers (where the customer can have root access).
 
 VMs were used in solutions like SHARE \citeappendix{vangorp11} (which was awarded second prize in the Elsevier Executable Paper Grand Challenge of 2011 \citeappendix{gabriel11}), or in suggested reproducible papers like \citeappendix{dolfi14}.
-However, due to their very large size, they are expensive to maintain, thus leading SHARE to discontinue its services in 2019.
-Also, the URL to the VM that is mentioned in \citeappendix{dolfi14} is no longer accessible (probably due to the same reason of size and archival costs).
+However, due to their very large size, these are expensive to maintain, thus leading SHARE to discontinue its services in 2019.
+The URL to the VM file \texttt{provenance\_machine.ova} that is mentioned in \citeappendix{dolfi14} is not currently accessible (we suspect that this is due to size and archival costs).
 
 \subsubsection{Containers}
 \label{appendix:containers}
-Containers also host a binary copy of a running environment, but don't have their own kernel.
+Containers also host a binary copy of a running environment, but do not have their own kernel.
 Through a thin layer of low-level system libraries, programs running within a container talk directly with the host operating system kernel.
 Otherwise, containers have their own independent software for everything else.
 Therefore, they have much less overhead in hardware/CPU access.
@@ -711,10 +716,10 @@ Below we'll review some of the most common container solutions: Docker and Singu
   This is a major security flaw that discourages many high performance computing (HPC) facilities from providing it.
 
 \item {\bf\small Singularity:} Singularity \citeappendix{kurtzer17} is a single-image container (unlike Docker which is composed of modular/independent images).
-  Although it needs root permissions to be installed on the system (once), it doesn't require root permissions every time it is run.
+  Although it needs root permissions to be installed on the system (once), it does not require root permissions every time it is run.
   Its main program is also not a daemon, but a normal program that can be stopped.
-  These features make it much easier for HPC administrators to install compared to Docker.
-  However, the fact that it requires root access for initial install is still a hindrance for a random project: if its not already present on the HPC, the project can't be run as a normal user.
+  These features make it much safer for HPC administrators to install compared to Docker.
+  However, the fact that it requires root access for the initial install is still a hindrance for a typical project: if Singularity is not already present on the HPC, the user's science project cannot be run by a non-root user.
 
 \item {\bf\small Podman:} Podman uses the Linux kernel containerization features to enable containers without a daemon, and without root permissions.
   It has a command-line interface very similar to Docker, but only works on GNU/Linux operating systems.
@@ -726,18 +731,18 @@ Because of this they will be large (many Gigabytes) and expensive to archive, do
 Recall the two examples above for VMs in Section \ref{appendix:virtualmachines}. But this is also valid for Docker images, as is clear from Dockerhub's recent decision to delete images of free accounts that haven't been used for more than 6 months.
 Meng \& Thain \citeappendix{meng17} also give similar reasons on why Docker images were not suitable in their trials.
 
-On a more fundamental level, VMs or contains don't store \emph{how} the core environment was built.
+On a more fundamental level, VMs or contains do not store \emph{how} the core environment was built.
 This information is usually in a third-party repository, and not necessarily inside container or VM file, making it hard (if not impossible) to track for future users.
 This is a major problem when considering reproducibility which is also highlighted as a major issue in terms of long term reproducibility in \citeappendix{oliveira18}.
 
 The example of \cite{mesnard20} was previously mentioned in Section \ref{criteria}.
 Another useful example is the \href{https://github.com/benmarwick/1989-excavation-report-Madjedbebe/blob/master/Dockerfile}{\inlinecode{Dockerfile}} of \citeappendix{clarkso15} (published in June 2015) which starts with \inlinecode{FROM rocker/verse:3.3.2}.
 When we tried to build it (November 2020), the core downloaded image (\inlinecode{rocker/verse:3.3.2}, with image ``digest'' \inlinecode{sha256:c136fb0dbab...}) was created in October 2018 (long after the publication of that paper).
-Theoretically it is possible to investigate the difference between this new image and the old one that the authors used, but that will require a lot of effort and may not be possible where the changes are not in a third public repository or not under version control.
-In Docker, it is possible to retrieve the precise Docker image with its digest for example \inlinecode{FROM ubuntu:16.04@sha256:XXXXXXX} (where \inlinecode{XXXXXXX} is the digest, uniquely identifying the core image to be used), but we haven't seen it practiced often in ``reproducible'' \inlinecode{Dockerfiles}.
+In principle, it is possible to investigate the difference between this new image and the old one that the authors used, but that would require a lot of effort and may not be possible where the changes are not available in a third public repository or not under version control.
+In Docker, it is possible to retrieve the precise Docker image with its digest for example \inlinecode{FROM ubuntu:16.04@sha256:XXXXXXX} (where \inlinecode{XXXXXXX} is the digest, uniquely identifying the core image to be used), but we haven't seen this often done in existing examples of ``reproducible'' \inlinecode{Dockerfiles}.
 
 The ``digest'' is specific to Docker repositories.
-A more generic/longterm approach to ensure identical core OS componets at a later time is to construct the containers or VMs with fixed/archived versions of the operating system ISO files.
+A more generic/longterm approach to ensure identical core OS components at a later time is to construct the containers or VMs with fixed/archived versions of the operating system ISO files.
 ISO files are pre-built binary files with volumes of hundreds of megabytes and not containing their build instructions).
 For example the archives of Debian\footnote{\inlinecode{\url{https://cdimage.debian.org/mirror/cdimage/archive/}}} or Ubuntu\footnote{\inlinecode{\url{http://old-releases.ubuntu.com/releases}}} provide older ISO files.
 
@@ -752,8 +757,8 @@ However, attempting to archive the actual binary container or VM files as a blac
 \subsubsection{Independent build in host's file system}
 \label{appendix:independentbuild}
 The virtual machine and container solutions mentioned above, have their own independent file system.
-Another approach to having an isolated analysis environment is to use the same filesystem as the host, but installing the project's software in a non-standrard, project-specific directory that doesn't interfere with the host.
-Because the environment in this approach can be built in any custom location on the host, this solution generally doesn't require root permissions or extra low-level layers like containers or VMs.
+Another approach to having an isolated analysis environment is to use the same filesystem as the host, but installing the project's software in a non-standrard, project-specific directory that does not interfere with the host.
+Because the environment in this approach can be built in any custom location on the host, this solution generally does not require root permissions or extra low-level layers like containers or VMs.
 However, ``moving'' the built product of such solutions from one computer to another is not generally as trivial as containers or VMs.
 Examples of such third-party package managers (that are detached from the host OS's package manager) include Nix, GNU Guix, Python's Virtualenv package and Conda, among others.
 Because it is highly intertwined with the way software are built and installed, third party package managers are described in more detail as part of Section \ref{appendix:packagemanagement}.
@@ -782,7 +787,7 @@ Note that we are not including package managers that are specific to one languag
 
 
 \subsubsection{Operating system's package manager}
-The most commonly used package managers are those of the host operating system, for example \inlinecode{apt} or \inlinecode{yum} respectively on Debian-based, or RedHat-based GNU/Linux operating systems, \inlinecode{pkg} in FreeBSD, among many others in other OSs.
+The most commonly used package managers are those of the host operating system, for example \inlinecode{apt} or \inlinecode{yum} respectively on Debian-based, or RedHat-based GNU/Linux operating systems, \inlinecode{pkg} in FreeBSD, among many others in other OSes.
 
 These package managers are tightly intertwined with the operating system: they also include the building and updating of the core kernel and the C library.
 Because they are part of the OS, they also commonly require root permissions.
@@ -792,7 +797,7 @@ Hence if two projects need different versions of a software, it is not possible
 When a container or virtual machine (see Appendix \ref{appendix:independentenvironment}) is used for each project, it is common for projects to use the containerized operating system's package manager.
 However, it is important to remember that operating system package managers are not static: software are updated on their servers.
 Hence, simply running \inlinecode{apt install gcc}, will install different versions of the GNU Compiler Collection (GCC) based on the version of the OS and when it has been run.
-Requesting a special version of that special software doesn't fully address the problem because the package managers also download and install its dependencies.
+Requesting a special version of that special software does not fully address the problem because the package managers also download and install its dependencies.
 Hence a fixed version of the dependencies must also be specified.
 
 In robust package managers like Debian's \inlinecode{apt} it is possible to fully control (and later reproduce) the build environment of a high-level software.
@@ -800,12 +805,13 @@ Debian also archives all packaged high-level software in its Snapshot\footnote{\
 Hence it is indeed theoretically possible to reproduce the software environment only using archived operating systems and their own package managers, but unfortunately we have not seen it practiced in scientific papers/projects.
 
 In summary, the host OS package managers are primarily meant for the operating system components or very low-level components.
-Hence, many robust reproducible analysis solutions (reviewed in Appendix \ref{appendix:existingsolutions}) don't use the host's package manager, but an independent package manager, like the ones below discussed below.
+Hence, many robust reproducible analysis solutions (reviewed in Appendix \ref{appendix:existingsolutions}) do not use the host's package manager, but an independent package manager, like the ones below discussed below.
 
 \subsubsection{Packaging with Linux containerization}
 Once a software is packaged as an AppImage\footnote{\inlinecode{\url{https://appimage.org}}}, Flatpak\footnote{\inlinecode{\url{https://flatpak.org}}} or Snap\footnote{\inlinecode{\url{https://snapcraft.io}}} the software's binary product and all its dependencies (not including the core C library) are packaged into one file.
-This makes it very easy to move that single software's built product to newer systems: because the C library is not included, it can fail on older systems.
-However, these are designed for the Linux kernel (using its containerization features) and can thus only be run on GNU/Linux operating systems.
+This makes it very easy to move that single software's built product to newer systems.
+However, because the C library is not included, it can fail on older systems.
+Moreover, these are designed for the Linux kernel (using its containerization features) and can thus only be run on GNU/Linux operating systems.
 
 \subsubsection{Nix or GNU Guix}
 \label{appendix:nixguix}
@@ -839,7 +845,7 @@ However, it is not possible to fix the versions of the dependencies through the
 This is thoroughly discussed under issue 787 (in May 2019) of \inlinecode{conda-forge}\footnote{\url{https://github.com/conda-forge/conda-forge.github.io/issues/787}}.
 In that discussion, the authors of \citeappendix{uhse19} report that the half-life of their environment (defined in a YAML file) is 3 months, and that at least one of their their dependencies breaks shortly after this period.
 The main reply they got in the discussion is to build the Conda environment in a container, which is also the suggested solution by \citeappendix{gruning18}.
-However, as described in Appendix \ref{appendix:independentenvironment} containers just hide the reproducibility problem, they don't fix it: containers aren't static and need to evolve (i.e., re-built) with the project.
+However, as described in Appendix \ref{appendix:independentenvironment} containers just hide the reproducibility problem, they do not fix it: containers aren't static and need to evolve (i.e., re-built) with the project.
 Given these limitations, \citeappendix{uhse19} are forced to host their conda-packaged software as tarballs on a separate repository.
 
 Conda installs with a shell script that contains a binary-blob (+500 mega bytes, embedded in the shell script).
@@ -852,14 +858,14 @@ However, the resulting environment is not fully independent of the host operatin
   However, the host operating system's directories are also appended afterwards.
   Therefore, a user, or script may not notice that a software that is being used is actually coming from the operating system, not the controlled Conda installation.
 
-\item Generally, by default Conda relies heavily on the operating system and doesn't include core analysis components like \inlinecode{mkdir}, \inlinecode{ls} or \inlinecode{cp}.
+\item Generally, by default Conda relies heavily on the operating system and does not include core analysis components like \inlinecode{mkdir}, \inlinecode{ls} or \inlinecode{cp}.
   Although they are generally the same between different Unix-like operating systems, they have their differences.
   For example \inlinecode{mkdir -p} is a common way to build directories, but this option is only available with GNU Coreutils (default on GNU/Linux systems).
   Running the same command within a Conda environment on a macOS for example, will crash.
   Important packages like GNU Coreutils are available in channels like conda-forge, but they are not the default.
   Therefore, many users may not recognize this, and failing to account for it, will cause unexpected crashes.
 
-\item Many major Conda packaging ``channels'' (for example the core Anaconda channel, or very popular conda-forge channel) don't include the C library, that a package was built with, as a dependency.
+\item Many major Conda packaging ``channels'' (for example the core Anaconda channel, or very popular conda-forge channel) do not include the C library, that a package was built with, as a dependency.
   They rely on the host operating system's C library.
   C is the core language of modern operating systems and even higher-level languages like Python or R are written in it, and need it to run.
   Therefore if the host operating system's C library is different from the C library that a package was built with, a Conda-packaged program will crash and the project will not be executable.
@@ -869,7 +875,7 @@ However, the resulting environment is not fully independent of the host operatin
   However, this is rarely practiced in the main Git repositories of channels like Anaconda and conda-forge: only the name of the high-level prerequisite packages is listed in a package's \inlinecode{meta.yaml} file, which is version-controlled.
   Therefore two builds of the package from the same Git repository will result in different tarballs (depending on what prerequisites were present at build time).
   In the Conda tarball (that contains the binaries and is not under version control) \inlinecode{meta.yaml} does include the exact versions of most build-time dependencies.
-  However, because the different software of one project may have been built at different times, if they depend on different versions of a single software there will be a conflict and the tarball can't be rebuilt, or the project can't be run.
+  However, because the different software of one project may have been built at different times, if they depend on different versions of a single software there will be a conflict and the tarball cannot be rebuilt, or the project cannot be run.
 \end{itemize}
 
 As reviewed above, the low-level dependence of Conda on the host operating system's components and build-time conditions, is the primary reason that it is very fast to install (thus making it an attractive tool to software developers who just need to reproduce a bug in a few minutes).
@@ -878,7 +884,7 @@ However, these same factors are major caveats in a scientific scenario, where lo
 
 \subsubsection{Spack}
 Spack is a package manager that is also influenced by Nix (similar to GNU Guix), see \citeappendix{gamblin15}.
-  But unlike Nix or GNU Guix, it doesn't aim for full, bit-wise reproducibility and can be built without root access in any generic location.
+  But unlike Nix or GNU Guix, it does not aim for full, bit-wise reproducibility and can be built without root access in any generic location.
   It relies on the host operating system for the C library.
 
   Spack is fully written in Python, where each software package is an instance of a class, which defines how it should be downloaded, configured, built and installed.
@@ -957,7 +963,7 @@ There are many tools for managing the sequence of jobs, below we'll review the m
 The most commonly used workflow system for many researchers is to run the commands, experiment on them and keep the output when they are happy with it.
 As an improvement, some also keep a narrative description of what they ran.
 Atleast in our personal experience with colleagues, this method is still being heavily practiced by many researchers.
-Given that many researchers don't get trained well in computational methods, this is not surprizing and as discussed in Section \ref{discussion}, we believe that improved literacy in computational methods is the single most important factor for the integrity/reproducibility of modern science.
+Given that many researchers do not get trained well in computational methods, this is not surprizing and as discussed in Section \ref{discussion}, we believe that improved literacy in computational methods is the single most important factor for the integrity/reproducibility of modern science.
 
 \subsubsection{Scripts}
 \label{appendix:scripts}
@@ -967,7 +973,7 @@ However, as the series of operations become complex and large, managing the work
 
 For example if 90\% of a long project is already done and a researcher wants to add a followup step, a script will go through all the previous steps (which can take significant time).
 In other scenarios, when a small step in the middle of an analysis has to be changed, the full analysis needs to be re-run from the start.
-Scripts have no concept of dependencies, forcing authors to ``temporarily'' comment parts of that they don't want to be re-run (forgetting to un-comment such parts are the most common cause of frustration for the authors and others attempting to reproduce the result).
+Scripts have no concept of dependencies, forcing authors to ``temporarily'' comment parts of that they do not want to be re-run (forgetting to un-comment such parts are the most common cause of frustration for the authors and others attempting to reproduce the result).
 
 Such factors discourage experimentation, which is a critical component of the scientific method.
 It is possible to manually add conditionals all over the script to add dependencies or only run certain steps at certain times, but they just make it harder to read, and introduce many bugs themselves.
@@ -996,7 +1002,7 @@ Therefore all three components in a rule must be files on the running filesystem
 
 To decide which operation should be re-done when executed, Make compares the time stamp of the targets and prerequisites.
 When any of the prerequisite(s) is newer than a target, the recipe is re-run to re-build the target.
-When all the prerequisites are older than the target, that target doesn't need to be rebuilt.
+When all the prerequisites are older than the target, that target does not need to be rebuilt.
 The recipe can contain any number of commands, they should just all start with a \inlinecode{TAB}.
 Going deeper into the syntax of Make is beyond the scope of this paper, but we recommend interested readers to consult the GNU Make manual for a nice introduction\footnote{\inlinecode{\url{http://www.gnu.org/software/make/manual/make.pdf}}}.
 
@@ -1016,7 +1022,7 @@ Bazel\footnote{\inlinecode{\url{https://bazel.build}}} is a high-level job organ
 Scons is a Python package for managing operations outside of Python (in contrast to CGAT-core, discussed below, which only organizes Python functions).
 In many aspects it is similar to Make, for example it is managed through a `SConstruct' file.
 Like a Makefile, SConstruct is also declarative: the running order is not necessarily the top-to-bottom order of the written operations within the file (unlike the imperative paradigm which is common in languages like C, Python, or FORTRAN).
-However, unlike Make, SCons doesn't use the file modification date to decide if it should be remade.
+However, unlike Make, SCons does not use the file modification date to decide if it should be remade.
 SCons keeps the MD5 hash of all the files (in a hidden binary file) to check if the contents have changed.
 
 SCons thus attempts to work on a declarative file with an imperative language (Python).
@@ -1041,7 +1047,7 @@ Another drawback with this workflow manager is that Python is a very high-level
 \subsubsection{Guix Workflow Language (GWL)}
 GWL is based on the declarative language that GNU Guix uses for package management (see Appendix \ref{appendix:packagemanagement}), which is itself based on the general purpose Scheme language.
 It is closely linked with GNU Guix and can even install the necessary software needed for each individual process.
-Hence in the GWL paradigm, software installation and usage doesn't have to be separated.
+Hence in the GWL paradigm, software installation and usage does not have to be separated.
 GWL has two high-level concepts called ``processes'' and ``workflows'' where the latter defines how multiple processes should be executed together.
 
 In conclusion, shell scripts and Make are very common and extensively used by users of Unix-based OSs (which are most commonly used for computations).
@@ -1079,8 +1085,8 @@ However, editors that can execute or debug the source (like GNU Emacs), just run
 With text editors, the final edited file is independent of the actual editor and can be further edited with another editor, or executed without it.
 This is a very important feature that is not commonly present for other solutions mentioned below.
 Another very important advantage of advanced text editors like GNU Emacs or Vi(m) is that they can also be run without a graphic user interface, directly on the command-line.
-This feature is critical when working on remote systems, in particular high performance computing (HPC) facilities that don't provide a graphic user interface.
-Also, the commonly used minimalistic containers don't include a graphic user interface.
+This feature is critical when working on remote systems, in particular high performance computing (HPC) facilities that do not provide a graphic user interface.
+Also, the commonly used minimalistic containers do not include a graphic user interface.
 
 \subsubsection{Integrated Development Environments (IDEs)}
 To facilitate the development of source files, IDEs add software building and running environments as well as debugging tools to a plain text editor.
@@ -1169,7 +1175,7 @@ On the other hand, the dependency graph of tools written in high-level languages
 For example see Figure 1 of \citeappendix{alliez19}, it shows the dependencies and their inter-dependencies for Matplotlib (a popular plotting module in Python).
 Acceptable version intervals between the dependencies will cause incompatibilities in a year or two, when a robust package manager is not used (see Appendix \ref{appendix:packagemanagement}).
 
-Since a domain scientist doesn't always have the resources/knowledge to modify the conflicting part(s), many are forced to create complex environments with different versions of Python and pass the data between them (for example just to use the work of a previous PhD student in the team).
+Since a domain scientist does not always have the resources/knowledge to modify the conflicting part(s), many are forced to create complex environments with different versions of Python and pass the data between them (for example just to use the work of a previous PhD student in the team).
 This greatly increases the complexity of the project, even for the principal author.
 A good reproducible workflow can account for these different versions.
 However, when the actual workflow system (not the analysis software) is written in a high-level language this will cause a major problem.
@@ -1192,7 +1198,7 @@ Once they have mastered one version of a language (mostly in the early stages of
 The inertia of programming languages is very strong.
 This is natural, because they have their own science field to focus on, and re-writing their high-level analysis toolkits (which they have curated over their career and is often only readable/usable by themselves) in newer languages every few years requires too much investment and time.
 
-When this investment is not possible, either the mentee has to use the mentor's old method (and miss out on all the new tools, which they need for the future job prospects), or the mentor has to avoid implementation details in discussions with the mentee, because they don't share a common language.
+When this investment is not possible, either the mentee has to use the mentor's old method (and miss out on all the new tools, which they need for the future job prospects), or the mentor has to avoid implementation details in discussions with the mentee, because they do not share a common language.
 The authors of this paper have personal experiences in both mentor/mentee relational scenarios.
 This failure to communicate in the details is a very serious problem, leading to the loss of valuable inter-generational experience.
 
@@ -1231,24 +1237,25 @@ Other studies have also attempted to review existing reproducible solutions, for
 \subsection{Suggested rules, checklists, or criteria}
 Before going into the various implementations, it is also useful to review existing suggested rules, checklists or criteria for computationally reproducible research.
 
-All the cases below are primarily targetted to immediate reproducibility and don't consider longevity explicitly.
-Therefore, they lack a strong/clear completeness criteria (mainly merely suggesting to record versions, or the ultimate suggestion to store the full binary OS in a binary VM or container is problematic (as mentioned in \ref{appendix:independentenvironment} and \citeappendix{oliveira18}).
+All the cases below are primarily targetted to immediate reproducibility and do not consider longevity explicitly.
+Therefore, they lack a strong/clear completeness criterion (they mainly only suggest, rather than require, the recording of versions, and their ultimate suggestion of storing the full binary OS in a binary VM or container is problematic (as mentioned in \ref{appendix:independentenvironment} and \citeappendix{oliveira18}).
 
-Sandve et al. \citeappendix{sandve13} propose ``ten simple rule for reproducible computational research'' that can be applied in any project.
-Generally, the are very similar to the criteria proposed here and follow a similar spirit but they don't provide any actual research papers following all those points, or a proof of concept.
-The Popper convention \citeappendix{jimenez17} also provides a set of principles that are indeed generally useful and some are shared with the criteria here (for example automatic validation, and like Maneage, they suggest having a template for new users).
-but they don't include completness or attention to longevity as mentioned above (Popper itself is written in Python with many dependencies, and its core operating language has already changed once).
+Sandve et al. \citeappendix{sandve13} propose ``ten simple rules for reproducible computational research'' that can be applied in any project.
+Generally, these are very similar to the criteria proposed here and follow a similar spirit, but they do not provide any actual research papers following up all those points, nor do they provide a proof of concept.
+The Popper convention \citeappendix{jimenez17} also provides a set of principles that are indeed generally useful, among which some are common to the criteria here (for example, automatic validation, and, as in Maneage, the authors suggest providing a template for new users),
+but the authors do not include completeness as a criterion nor pay attention to longevity (Popper itself is written in Python with many dependencies, and its core operating language has already changed once).
 For more on Popper, please see Section \ref{appendix:popper}.
 
 For improved reproducibility in Jupyter notebook users, \citeappendix{rule19} propose ten rules to improve reproducibility and also provide links to example implementations.
-They can be very useful for users of Jupyter and not generic to any computational project.
-Some criteria (which are indeed very good in a more general context) don't directly relate to reproducibility, for example their Rule 1: ``Tell a Story for an Audience''.
+These can be very useful for users of Jupyter, but are not generic for non-Jupyter-based computational projects.
+Some criteria (which are indeed very good in a more general context) do not directly relate to reproducibility, for example their Rule 1: ``Tell a Story for an Audience''.
 Generally, as reviewed in Sections \ref{sec:longevityofexisting} and \ref{appendix:jupyter}, Jupyter itself has many issues regarding reproducibility.
 
 To create Docker images, N\"ust et al. propose ``ten simple rules'' in \citeappendix{nust20}.
-They do recommend some issues that can indeed help increase the quality of Docker images and their production/usage, for example their rule 7 to ``mount datasets at run time'' to separate the computational evironment from the data.
-However, like before, the long term reproducibility of the images is not a concern, for example in they recommend using base operating systems only with a version like \inlinecode{ubuntu:18.04}, which was clearly shown to have longevity issues in Section \ref{sec:longevityofexisting}.
-Furthermore, in their proof of concept Dockerfile (listing 1), \inlinecode{rocker} is used with a tag (not a digest), which can be problematic (as shown in Section \ref{appendix:containers}).
+They recommend some issues that can indeed help increase the quality of Docker images and their production/usage, such as their rule 7 to ``mount datasets [only] at run time'' to separate the computational environment from the data.
+However, long-term reproducibility of the images is not included as a criterion by these authors.
+For example, they recommend using base operating systems, with version identification limited to a single brief identifier such as \inlinecode{ubuntu:18.04}, which has a serious problem with longevity issues (Section \ref{sec:longevityofexisting}).
+Furthermore, in their proof-of-concept Dockerfile (listing 1), \inlinecode{rocker} is used with a tag (not a digest), which can be problematic due to the high risk of ambiguity (as discussed in Section \ref{appendix:containers}).
 
 \subsection{Reproducible Electronic Documents, RED (1992)}
 \label{appendix:red}
@@ -1323,7 +1330,7 @@ It is an extension of the Jupyter notebook (see Appendix \ref{appendix:editors})
 However, the wrapper modules just call an existing tool on the host system.
 Given that each server may have its own set of installed software, the analysis may differ (or crash) when run on different GenePattern servers, hampering reproducibility.
 
-%% GenePattern shutdown announcement (although as of November 2020, it doesn't open any more!): https://www.genepattern.org/blog/2019/10/01/the-genomespace-project-is-ending-on-november-15-2019
+%% GenePattern shutdown announcement (although as of November 2020, it does not open any more!): https://www.genepattern.org/blog/2019/10/01/the-genomespace-project-is-ending-on-november-15-2019
 The primary GenePattern server was active since 2008 and had 40,000 registered users with 2000 to 5000 jobs running every week \citeappendix{reich17}.
 However, it was shut down on November 15th 2019 due to end of funding.
 All processing with this sever has stopped, and any archived data on it has been deleted.
@@ -1371,7 +1378,7 @@ Besides the fact that it is no longer maintained, VisTrails didn't control the s
 \label{appendix:galaxy}
 
 Galaxy\footnote{\inlinecode{\url{https://galaxyproject.org}}} is a web-based Genomics workbench \citeappendix{goecks10}.
-The main user interface are ``Galaxy Pages'', which doesn't require any programming: users simply use abstract ``tools'' which are a wrappers over command-line programs.
+The main user interface are ``Galaxy Pages'', which does not require any programming: users simply use abstract ``tools'' which are a wrappers over command-line programs.
 Therefore the actual running version of the program can be hard to control across different Galaxy servers.
 Besides the automatically generated metadata of a project (which include version control, or its history), users can also tag/annotate each analysis step, describing its intent/purpose.
 Besides some small differences Galaxy seems very similar to GenePattern (Appendix \ref{appendix:genepattern}), so most of the same points there apply here too (including the very large cost of maintining such a system).
@@ -1509,11 +1516,11 @@ The captured environment can be viewed in plain text or a web interface.
 Sumatra also provides \LaTeX/Sphinx features, which will link the paper with the project's Sumatra database.
 This enables researchers to use a fixed version of a project's figures in the paper, even at later times (while the project is being developed).
 
-The actual code that Sumatra wraps around, must itself be under version control, and it doesn't run if there is non-committed changes (although its not clear what happens if a commit is amended).
+The actual code that Sumatra wraps around, must itself be under version control, and it does not run if there is non-committed changes (although its not clear what happens if a commit is amended).
 Since information on the environment has been captured, Sumatra is able to identify if it has changed since a previous run of the project.
 Therefore Sumatra makes no attempt at storing the environment of the analysis as in Sciunit (see Appendix \ref{appendix:sciunit}), but its information.
 Sumatra thus needs to know the language of the running program and isn't generic.
-It just captures the environment, it doesn't store \emph{how} that environment was built.
+It just captures the environment, it does not store \emph{how} that environment was built.
 
 
 
@@ -1685,7 +1692,7 @@ Hence for complex data analysis operations with involve thousands of steps, it i
 %%\begin{itemize}
 %%\item \url{https://sites.nationalacademies.org/cs/groups/pgasite/documents/webpage/pga_180684.pdf}, does the following classification of tools:
 %%  \begin{itemize}
-%%    \item Research environments: \href{http://vcr.stanford.edu}{Verifiable computational research} (discussed above), \href{http://www.sciencedirect.com/science/article/pii/S1877050911001207}{SHARE} (a Virtual Machine), \href{http://www.codeocean.com}{Code Ocean} (discussed above), \href{http://jupyter.org}{Jupyter} (discussed above), \href{https://yihui.name/knitr}{knitR} (based on Sweave, dynamic report generation with R), \href{https://cran.r-project.org}{Sweave} (Function in R, for putting R code within \LaTeX), \href{http://www.cyverse.org}{Cyverse} (proprietary web tool with servers for bioinformatics), \href{https://nanohub.org}{NanoHUB} (collection of Simulation Programs for nanoscale phenomena that run in the cloud), \href{https://www.elsevier.com/about/press-releases/research-and-journals/special-issue-computers-and-graphics-incorporates-executable-paper-grand-challenge-winner-collage-authoring-environment}{Collage Authoring Environment} (discussed above), \href{https://osf.io/ns2m3}{SOLE} (discussed above), \href{https://osf.io}{Open Science framework} (a hosting webpage), \href{https://www.vistrails.org}{VisTrails} (discussed above), \href{https://pypi.python.org/pypi/Sumatra}{Sumatra} (discussed above), \href{http://software.broadinstitute.org/cancer/software/genepattern}{GenePattern} (reviewed above), Image Processing On Line (\href{http://www.ipol.im}{IPOL}) journal (publishes full analysis scripts, but doesn't deal with dependencies), \href{https://github.com/systemslab/popper}{Popper} (reviewed above), \href{https://galaxyproject.org}{Galaxy} (reviewed above), \href{http://torch.ch}{Torch.ch} (finished project for neural networks on images), \href{http://wholetale.org/}{Whole Tale} (discussed above).
+%%    \item Research environments: \href{http://vcr.stanford.edu}{Verifiable computational research} (discussed above), \href{http://www.sciencedirect.com/science/article/pii/S1877050911001207}{SHARE} (a Virtual Machine), \href{http://www.codeocean.com}{Code Ocean} (discussed above), \href{http://jupyter.org}{Jupyter} (discussed above), \href{https://yihui.name/knitr}{knitR} (based on Sweave, dynamic report generation with R), \href{https://cran.r-project.org}{Sweave} (Function in R, for putting R code within \LaTeX), \href{http://www.cyverse.org}{Cyverse} (proprietary web tool with servers for bioinformatics), \href{https://nanohub.org}{NanoHUB} (collection of Simulation Programs for nanoscale phenomena that run in the cloud), \href{https://www.elsevier.com/about/press-releases/research-and-journals/special-issue-computers-and-graphics-incorporates-executable-paper-grand-challenge-winner-collage-authoring-environment}{Collage Authoring Environment} (discussed above), \href{https://osf.io/ns2m3}{SOLE} (discussed above), \href{https://osf.io}{Open Science framework} (a hosting webpage), \href{https://www.vistrails.org}{VisTrails} (discussed above), \href{https://pypi.python.org/pypi/Sumatra}{Sumatra} (discussed above), \href{http://software.broadinstitute.org/cancer/software/genepattern}{GenePattern} (reviewed above), Image Processing On Line (\href{http://www.ipol.im}{IPOL}) journal (publishes full analysis scripts, but does not deal with dependencies), \href{https://github.com/systemslab/popper}{Popper} (reviewed above), \href{https://galaxyproject.org}{Galaxy} (reviewed above), \href{http://torch.ch}{Torch.ch} (finished project for neural networks on images), \href{http://wholetale.org/}{Whole Tale} (discussed above).
 %%    \item Workflow systems: \href{http://www.taverna.org.uk}{Taverna}, \href{http://www.wings-workflows.org}{Wings}, \href{https://pegasus.isi.edu}{Pegasus}, \href{http://www.pgbovine.net/cde.html}{CDE}, \href{http://binder.org}{Binder}, \href{http://wiki.datakurator.org/wiki}{Kurator}, \href{https://kepler-project.org}{Kepler}, \href{https://github.com/everware}{Everware}, \href{http://cds.nyu.edu/projects/reprozip}{Reprozip}.
 %%    \item Dissemination platforms: \href{http://researchcompendia.org}{ResearchCompendia}, \href{https://datacenterhub.org/about}{DataCenterHub}, \href{http://runmycode.org}, \href{https://www.chameleoncloud.org}{ChameleonCloud}, \href{https://occam.cs.pitt.edu}{Occam}, \href{http://rcloud.social/index.html}{RCloud}, \href{http://thedatahub.org}{TheDataHub}, \href{http://www.ahay.org/wiki/Package_overview}{Madagascar}.
 %%    \end{itemize}
@@ -1711,7 +1718,7 @@ Hence for complex data analysis operations with involve thousands of steps, it i
 %%  \item \citeappendix{stodden18}: Effectiveness of journal policy on computational reproducibility.
 %%  \item \citeappendix{fanelli18} is critical of the narrative that there is a ``reproducibility crisis'', and that its important to empower scientists.
 %%  \item \citeappendix{burrell18} open software (in particular Python) in heliophysics.
-%%  \item \citeappendix{allen18} show that many papers don't cite software.
+%%  \item \citeappendix{allen18} show that many papers do not cite software.
 %%  \item \citeappendix{zhang18} explicity say that they won't release their code: ``We opt not to make the code used for the chemical evo-lution modeling publicly available because it is an important asset of the re-searchers’ toolkits''
 %%  \item \citeappendix{jones19} make genuine effort at reproducing every number in the paper (using Docker, Conda, and CGAT-core, and Binder), but they can ultimately only release scripts. They claim its not possible to reproduce that level of reproducibility, but here we show it is.
 %%  \item LSST uses Kubernetes and docker for reproducibility \citeappendix{banek19}.
-- 
cgit v1.2.1

