anchor.diff:  operations without creating a new layer at each step, resulting in a fast
   process. In addition, S2I scripts can be written to re-use artifacts stored in a
   previous version of the application image, rather than having to download or
  -build them, each time the build is run.
  +build them each time the build is run.
   
   Patchability:: S2I allows you to rebuild the application consistently if an
   underlying image needs a patch due to a security issue.
   
   Operational efficiency:: By restricting build operations instead of allowing
  -arbitrary actions, such as in a *_Dockerfile_*, the PaaS operator can avoid
  +arbitrary actions, as a *_Dockerfile_* would allow, the PaaS operator can avoid
   accidental or intentional abuses of the build system.
   
   Operational security:: Building an arbitrary *_Dockerfile_* exposes the host
   system to root privilege escalation. This can be exploited by a malicious user
   because the entire Docker build process is run as a user with Docker privileges.
  -S2I restricts the operations performed as a root user, and can run the scripts
  +S2I restricts the operations performed as a root user and can run the scripts
   as a non-root user.
   
   User efficiency:: S2I prevents developers from performing arbitrary `yum
  -install` type operations during their application build, which results in slow
  -development iteration.
  +install` type operations, which could slow down development iteration, during
  +their application build.
   
   Ecosystem:: S2I encourages a shared ecosystem of images where you can leverage
   best practices for your applications.
   
   [#custom-build]
   === Custom Build
  -The Custom build strategy allows developers to define a specific builder image,
  +The Custom build strategy allows developers to define a specific builder image
   responsible for the entire build process. Using your own builder image allows
   you to customize your build process.
   
  
positive.code: }
  ----
  ====
  
negative.code: === Docker Build
  The Docker build strategy invokes the plain
  https://docs.docker.com/reference/commandline/cli/#build[docker build] command,
  and it therefore expects a repository with a *_Dockerfile_* and all required
  artifacts in it to produce a runnable image.
  
  [#source-build]
  === Source-to-Image (S2I) Build
  link:../../creating_images/s2i.html[Source-to-Image (S2I)] is a tool for
  building reproducible Docker images. It produces ready-to-run images by
  injecting application source into a Docker image and assembling a new Docker
  image.  The new image incorporates the base image (the builder) and built source
  and is ready to use with the `docker run` command. S2I supports incremental
  builds, which re-use previously downloaded dependencies, previously built
  artifacts, etc.
  
  The advantages of S2I include the following:
  
  [horizontal]
  Image flexibility:: S2I scripts can be written to inject application code into
  almost any existing Docker image, taking advantage of the existing ecosystem.
  Note that, currently, S2I relies on `tar` to inject application
  source, so the image needs to be able to process tarred content.
  