Introduction
  
    The problem space
    
      Nix is a system for controlling the automatic creation and distribution
      of data, such as computer programs and other software artifacts.  This is
      a very general problem, and there are many applications that fall under
      this description.
    
    
      Build management
      
	Build management tools are used to perform software
	  builds, that is, the construction of derived products such
	as executable programs from source code.  A commonly used build tool is
	Make, which is a standard tool on Unix systems. These tools have to
	deal with several issues:
	
	  
	    
	    
	  
	
      
    
    
      Package management
      
	After software has been built, is must also be
	deployed in the intended target environment, e.g.,
	the user's workstation.  Examples include the Red Hat package manager
	(RPM), Microsoft's MSI, and so on.  Here also we have to deal with
	several issues:
	
	  
	    
	      The creation of packages from some formal
	      description of what artifacts should be distributed in the
	      package.
	    
	  
	  
	    
	      The deployment of packages, that is, the
	      mechanism by which we get them onto the intended target
	      environment.  This can be as simple as copying a file, but
	      complexity comes from the wide range of possible installation
	      media (such as a network install), and the scalability of the
	      process (if a program must be installed on a thousand systems, we
	      do not want to visit each system and perform some manual steps to
	      install the program on that system; that is, the complexity for
	      the system administrator should be constant, not linear).
	    
	  
	
      
    
  
  
  
    What Nix can do for you
    
      Here is a summary of what Nix provides:
    
    
      
	
	  Reliable dependencies.
	
      
      
	
	  Support for variability.
	
      
      
	
	  Transparent source/binary deployment.
	
      
      
	
	  Easy configuration duplication.
	
      
      
	
	  Automatic storage management.
	
      
      
	
	  Atomic upgrades and rollbacks.
	
      
      
	
	  Support for many simultaneous configurations.
	
      
    
    
      Here is what Nix doesn't yet provide, but will:
    
    
      
	
	  Build management.  In principle it is already
	  possible to do build management using Fix (by writing builders that
	  perform appropriate build steps), but the Fix language is not yet
	  powerful enough to make this pleasant.  The Maak build manager
	  should be retargeted to produce Nix expressions, or alternatively,
	  extend Fix with Maak's semantics and concrete syntax (since Fix needs
	  a concrete syntax anyway).  Another interesting idea is to write a
	  make implementation that uses Nix as a back-end to
	  support legacy 
	  build files.
	
      
    
  
  
  
    The Nix system
    
      ...
    
    
      Existing tools in this field generally both a underlying model (such as
      the derivation graph of build tools, or the versioning scheme that
      determines when two packages are compatible
 in a package
      management system) and a formalism that allows ...
    
    
      Following the principle of separation of mechanism and policy, the Nix
      system separates the low-level aspect of file system
      object management form the high-level aspect of the
      ...