anchor.diff:  This document captures core design principles and concepts for the Moss build system.
   
   Moss produces completed software artifacts from source code.
  -The core concepts required by this process are:
  +The core concepts in this process are:
   
  -1. Code - the source code everything is formed from
  -2. Spore - related bits of code that are combined together into a build artifact
  +1. Spore - description of how to produce a final build artifact
  +2. Code - content that must be compiled before being included in the artifact
  +3. File - content that is directly used while forming the artifact
   3. Artifact - software build output with content from one or more spores
   
   Tools are used to produce artifacts from code.
   All tools with Moss to perform one of three actions:
   
   1. Transcode: source code -> source code
  -2. Compile: source code -> object code
  -3. Form: code + files + artifacts -> artifact
  +2. Compile: source code -> object files
  +3. Form: files + artifacts -> artifact
   
   Tools may be specialized according to:
   
  
positive.code: Specialization
  ~~~~~~~~~~~~~~
  
  Several design concepts are being considered to manage the multitude of spore varieties and artifacts that are required for non-trivial applications:
  
  1. Architectural specialization.
  A given spore may produce artifacts for multiple architectures without requiring duplication of the spore definition.
  The architecture-specific definitions 'extend' or 'inherit' from the base definiton.
  
  2. Selection and application of architecture and tool options for building spores.
  Architecture-specific options and overrides can be specified through variables that 'overload' the base definition for the spore.
  
  3. Spore configuration through settings (think menuconfig or kconfig).
  This is a formalized way to specify and use conditional boolean switches and string settings to specialize the artifacts produced by a spore.
  This mechanism would likely be used as part of option 2 for maximum flexibility.
  
  4. Specialization of spores through inheritance.
  This is a more general application of option 1.
  A spore may inherit from another spore and overriding specific definitions.
  
  These concepts are each different and should be kept as orthogonal as possible. It is highly likely that options 1-2 are the only ones needed initially.
  
  Isolation
  ~~~~~~~~~
  
negative.code: 
  Examples: host, amd64, cortex-m4, cortex-r7, avr, mipsel, etc.
  
  Good discussion on architecture naming here: http://clang.llvm.org/docs/CrossCompilation.html
  
  Variants
  