[PATCH] doc: "Introduction" revise and add figure.

[myglc2]

Makes the intro read as shown below. Figure attached. Comments welcome.
- George

1 Introduction
**************

The purpose of GNU Guix(1) is to allow users to easily install, upgrade,
and remove free(2) GNU and non-GNU software.

   Guix can be installed stand-alone (*note System Installation::) or on
top of an exiting GNU/Linux system (*note Installation::).

   When installed stand-alone, Guix provides a distribution of the GNU
System consisting entirely of free GNU and non-GNU software, the “Guix
System Distribution” or “GuixSD”, (*note GNU Distribution::).

   Key Guix components and features are shown and discussed below:

Guix Feature Diagram.

   Guix uses a “build daemon” to build and install software packages
(*note Setting Up the Daemon::).  Packages can be built using developer
source code or installed using pre-built package “substitutes” from
elsewhere, for example from the Guix Hydra build farm, ‘hydra.gnu.org’
(*note Substitutes::).  This frees users from dependence on others while
providing the benefits of using pre-built packages if they are
available.

   Guix installs software packages in a special directory, “the store”,
by default ‘/gnu/store’.  When a user installs packages, Guix makes them
available to that user by creating a “per-user profile” of symbolic
links into the store (*note Features::).  When GuixSD is installed, the
packages one would expect for basic user and administrator tasks (plus
additional globally-installed packages, if any) are made available in
the “system profile” (*note Using the Configuration System::).

   When Guix is installed on an existing GNU/Linux system, the existing
system’s package manager provides the system profile and system
services.  In GuixSD, Guix “system configuration” manages the system
profile and system services and supports declarative configuration,
transactional instantiation, and rollback.  Installed either way, Guix
can produce GuixSD virtual machines, disk images, and disk installs
(*note System Configuration::).

   Guix “package management” differs from typical GNU/Linux package
management by focusing on users instead of system administrators.  Guix
enables each user to independently configure, install, upgrade, or
rollback packages for their own use.  This allows users to create
software environments that extend, update, or replace the packages in
the system profile (*note Package Management::).  This, in turn, frees
system administrators from the requirement to meet all user’s needs with
the system profile.

   Guix includes command-line interfaces for package management (*note
Invoking guix package::) and system configuration (*note Invoking guix
system::).  Guix provides an emacs user interface for package
management, system configuration, and package recipes (*note Emacs
Interface::).  Guix is implemented primarily in GNU Guile and provides
Scheme application programming interfaces (APIs) (*note Programming
Interface::) and utilities (*note Utilities::) that simplify software
packaging.

   Key Guix features, such as _declarative_ system configuration,
transactional upgrade/rollback, and garbage collection, are implemented
using a functional package management approach.  The term “functional”
refers to a specific package management discipline pioneered by Nix
(*note Acknowledgments::) in which the package build and installation
process is seen as a function, in the mathematical sense.  That function
takes inputs, such as build scripts, a compiler, and libraries, and
returns an installed package.  As a pure function, its result depends
solely on its inputs—for instance, it cannot refer to software or
scripts that were not explicitly passed as inputs.  A build function
always produces the same result when passed a given set of inputs.  It
cannot alter the environment of the running system in any way; for
instance, it cannot create, modify, or delete files outside of its build
and installation directories.  This is achieved by running build
processes in isolated environments (or “containers”), where only their
explicit inputs are visible.  The result of package build functions is
“cached” in a directory of its own.  The directory name contains a hash
of all the inputs used to build that package; thus, changing an input
yields a different directory name.

   ---------- Footnotes ----------

   (1) “Guix” is pronounced like “geeks”, or “ɡiːks” using the
international phonetic alphabet (IPA).

   (2) The term “free” here refers to the freedom provided to users of
that software (http://www.gnu.org/philosophy/free-sw.html).

0001-doc-Introduction-revise-and-add-figure.patch
Description: Text Data

introduction.png
Description: PNG image