remove environment section

Author: drupol

resources/sourcecode/python.dockerfile

@@ -1454,121 +1454,13 @@ and at any point in the past or future​​​​.
   variety of environments or machines.
 ]
 
-=== Environments <ch2-environments>
-
-Environments where a build or computational process occurs can be broadly
-categorised into two types: hardware and software environments. While software
-environments can be managed to a high degree of consistency, achieving
-reproducibility across different hardware, particularly different #gls("CPU")
-architectures #eg[`x86`, `ARM`], is essentially impossible. Tasks like
-instruction execution, memory management, and floating-point calculations are
-handled in distinct ways. Even small variations in these processes can lead to
-differences in output. Consequently, even with identical software, builds on
-different types of #gls("CPU") architectures will produce different results.
-When something is said to be reproducible, it typically means reproducible
-within the same #gls("CPU") architecture. Therefore, this section will focus
-exclusively on the reproducibility challenges within software environments.
-
-A software environment is composed of the #gls("OS"), along with the set of
-tools, libraries, and dependencies required to build or run a specific
-application. Any change in these components can influence the outcome of a
-software build or execution. For example, a minor update to a library could
-potentially alter the behaviour of the software, producing different outcomes
-across different executions​​ or more importantly, have an impact on the security
-level.
-
-To enhance reproducibility, it is critical to ensure that the software
-environment remains stable and unaltered during both the build and execution
-phases. Unfortunately, conventional #glspl("OS") such as Linux distributions,
-Microsoft Windows, and macOS, are #emph[mutable] by default. This mutability is
-primarily facilitated through package managers, which enable users to easily
-modify their environments by installing or upgrading software packages​. As a
-result, uncontrolled changes to dependencies may also lead to inconsistencies in
-software behaviour, or have a impact on the security level, undermining
-reproducibility​.
-
-To mitigate these issues, #emph[immutable] environments have gained popularity.
-Tools such as Docker #cite(<docker>,form:"normal") provide mechanisms to
-encapsulate software and its dependencies in containers, thus creating
-environments that remain unchanged after creation. Once a container is built, it
-can be shared and executed across different systems with the guarantee that it
-will function identically, given the same environment. This characteristic makes
-containers highly suitable for distributing software.
-
-Despite the advantages of immutability, it does not guarantee reproducibility by
-default. For instance, container images hosted on platforms like Docker Hub
-#cite(<dockerhub>,form:"normal"), including popular language interpreters
-#eg[Python, Node, PHP], may not be reproducible due to non-deterministic
-steps during the image creation. A specific example can be found in
-#ref(<python-dockerfile>), which runs `apt-get update` at line 4 as part of the
-image build process. Since `apt-get` pulls the latest version of package lists
-at build-time, it is impossible to reproduce the same image later, compromising
-Docker's build-time reproducibility.
-
-#figure(
-  sourcefile(
-    lang: "dockerfile",
-    read("../../resources/sourcecode/python.dockerfile"),
-  ),
-  caption: [
-    An excerpt of the Python's Dockerfile
-    #cite(<python-dockerfile-repository>,form:"normal") used to build the
-    #emph[official] Python images.
-  ],
-) <python-dockerfile>
-
-Docker images, once built, are immutable. While Docker does not guarantee
-build-time reproducibility, it has the potential to ensure run-time
-reproducibility, reflecting Docker's philosophy of
-#emph["build once, use everywhere"]. This distinction between build-time
-reproducibility (@def-reproducibility-build-time) and run-time reproducibility
-(@def-reproducibility-run-time) is key. Docker does not ensure that an image
-will always be built consistently, often due to the base image used (as
-specified in the `FROM` directive of a `Dockerfile`), as seen in
-@python-dockerfile. Although building a reproducible image with Docker is
-technically possible, it would require additional effort, external tools, and a
-more complex setup. Therefore, we assume that build-time reproducibility is not
-guaranteed, but the immutability of the environment significantly enhances the
-potential for reproducibility at run-time.
-
-#info-box[
-  Docker #cite(<docker>,form:"normal") is a platform for building, shipping, and
-  running applications in containers, with Docker Hub
-  #cite(<dockerhub>,form:"normal") providing a large repository of container
-  images, which has significantly contributed to Docker's popularity. Among
-  these are "official" Docker images
-  #cite(<dockerofficialimages>,form:"normal"), which are curated and reviewed by
-  Docker Inc. These images offer standard environments for popular software and
-  adhere to some quality standards.
-
-  However, the term "official" can be misleading. One might suggest that these
-  images are maintained by the original software's developers, but it's not
-  always the case. For example, the PHP Docker image is not maintained by the
-  core PHP development team. This means updates or fixes may not be as prompt or
-  specific as if the software’s developers maintained the image.
-
-  While Docker vets these images for quality, responsibility for the contents
-  rests with the maintainers. Users should be aware that official images are not
-  immune to security risks or outdated software, and reviewing the documentation
-  for issues is advisable.
-
-  In summary, "official" Docker images are trusted but may not be maintained by
-  the software’s creators. Developers should use them with care, especially in
-  production environments, and verify that the images meet their security and
-  functionality needs.
-]
-
-Package managers are a critical aspect of the reproducibility puzzle. Without
-proper control over how dependencies are resolved and installed, achieving
-consistent and reproducible builds becomes difficult​.
-
 ==== Configuration Management
 
 Reproducibility relies on stable, consistent and well-maintained codebases but
 also heavily depends on stable, consistent and well-maintained environments as
-seen in @ch2-environments. In addition, a critical component is environment
-configuration management. Configuration management plays a critical role in
-ensuring reproducibility by mitigating the non-deterministic behaviours
+seen in (add ref to ch2-environments). In addition, a critical component is
+environment configuration management. Configuration management plays a critical
+role inensuring reproducibility by mitigating the non-deterministic behaviours
 introduced by configuration drifts.
 
 #info-box[
@@ -1656,15 +1548,15 @@ goal of this model, providing the highest level of determinism and reliability
 in system behaviours.
 
 Congruent management, particularly through the adoption of immutable
-environment (@ch2-environments), ensures that environment remain in a
+environment ((add ref to ch2-environments)), ensures that environment remain in a
 well-defined state, thus maximising reproducibility. However, this approach can
 lack the flexibility required for dynamic environments, where each minor
 adjustments may necessitate rebuilding the entire system. This limitation
 highlights the importance of carefully choosing between convergent and congruent
 approaches based on the environment's needs.
 
 #info-box[
-  Immutable environments (@ch2-environments) are environments that are designed
+  Immutable environments ((add ref to ch2-environments)) are environments that are designed
   to be unchangeable once they are created. They are often used in containers
   #eg[Docker #cite(<docker>,form:"normal")], where the ability to quickly create
   and destroy environments is essential. Immutable environments enhance