anchor.diff:  
   == Architectures
   
  -An architecture definition specifies a toolchain. For example armv5-gcc would specify a gcc cross compiler. And armv5-clang would specify a clang cross compile. In order to build the same spore for the same processor with two different tools, two different architectures must be created.
  +An architecture definition specifies a toolchain. For example armv5-gcc would specify a gcc cross compiler. And armv5-clang would specify a clang cross compile. In order to build the same seed for the same processor with two different tools, two different architectures must be created.
   
  -Architecture is the mechanism for customized compilation of spores for a particular target. Different spores compiled for the same architecture may have different toolchain settings. The architecture is the means of selection. Spores compiled for the same architecture may be linked together. A mixing of architectures is not supported.
  +Architecture is the mechanism for customized compilation of seeds for a particular target. Different seeds compiled for the same architecture may have different toolchain settings. The architecture is the means of selection. Seeds compiled for the same architecture may be linked together. A mixing of architectures is not supported.
   
   A build architecture is defined by a specific CPU type and associated instruction set.
   
  
positive.code: 
  === Specialization
  
  A given spore may produce artifacts for multiple architectures without requiring duplication of the spore definition.
  The architecture-specific 'specializations' are created from the base spore 'template'.
  Architecture-specific options and overrides can be specified through variables that 'overload' the base definition for the spore.
  
  === Configuration
  
  This is a formalized way to specify and use conditional boolean switches and named string options to specialize the artifacts produced by a spore.
  Configuration is the ideal way to provide the setting that are used during specialization to fine tune the artifacts that are formed.
  Think menuconfig or kconfig.
  
  === Isolation
  
  Each spore is produced in isolation.
  This guarantees that object files and artifacts will never be clobbered, even if multiple spores use the source code in different ways.
  Spore artifacts are produced in a way that encourages creation of small libraries that are combined to produce complex artifacts.
  
  == Code
  
  
negative.code: = Moss Design Overview
  
  Moss is a library for GNU make that streamlines the creation of rules and dependencies for software build artifacts. The core concepts within this library are:
  
  1. Seeds - modular units of source code that are formed into an artifact
  2. Artifacts - outputs of seeds which may be created for multiple architectures and variants
  3. Tools - used to compile source code and form artifacts
  4. Architectures - used to specialize seeds and tools for artifact creation
  5. Variants - global switches for tools
  
  == Seeds
  
  A seed describes how Moss produces artifacts from source code and files in an architecture and toolchain independent fashion.
  Seeds do not possess knowledge of Moss build architecture.
  Instead, they are specialized for different architectures through settings.
  
  === Definition
  
  Seeds are defined entirely through variable definition.
  Creation and management of rules and dependencies is managed automatically by Moss.
  Knowledge of toolchain and architecture specifics are decoupled from the description of the software itself.
  Moss manages the creation and application of all makefile rules required for multiple languages, artifacts, architectures, toolchains, and variants.
  