anchor.diff:  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 and Languages
  -------------------
  +Code
  +----
   
  -A language is named after its source form (for example, C or Rust).
  -The Moss language description defines the outputs that will be created (for example, object files or other source language files).
  -Translation is performed into a language from another source.
  -Compilation is performed from a language into an object file.
  +Code is compiled before it is included in a final artifact.
  +It may also be transcoded before this compilation step.
  +Translation is converts code from one language from another language.
  +Compilation is converts source code into object code.
   Moss manages the chaining of translation and compilation to ultimately produce and object file from source file as required.
   
  -Each toolchain supports at least one language that is used by source files.
  -Many toolchains support multiple languages (e.g. GCC and LLVM).
  +Files
  +-----
  +
  +Files are formed into artifacts without being passed through a compiler.
  +For example, a tarball is simply a collection of files packaged into a single artifact.
  +Files may also be additional content required for production of executable outputs, such as tool configurations, etc.
  +Object files are implicitly included in the list of files for an artifact base on the source code.
   
   Artifacts
   ---------
   
  -Three types of artifacts are envisioned as default.
  +Three types of artifacts are envisioned initially.
   
   - Executable: a fully-linked binary executable
   - Static Library: a library for static linking into one or more executables
   - Shared Library: a dynamic library for use with one or more executable artifacts
   
  -Most artifacts will require creation of obejct files using a compiler.
  +Most artifacts will require creation of object files using a compiler.
   Some artifacts may be produced directly from source files.
   
   Tools
   -----
   
  -A tool is used to form artifacts from code.
  +Tool are used to form all build artifacts.
   
  -A toolchain is a set of tools that are used for a specific architecture.
  -A tool uses both architecture and variant to customize settings to the specific code generation tools.
  -Additional customization may be overlaid for each spore based upon architecture.
  -
  -Code generated by one toolchain cannot be linked or combined with code generated for another toolchain unless it is explicitly forced through spore dependencies.
  -
  +A tool uses both architecture and variant to specialize settings for object code generation.
  +Code generated by one toolchain cannot be linked or combined with code generated for another toolchain unless it is explicitly forced through dependencies.
   Generally, debug versus release build variants are handled at the tool level due to the significant impact that may be present on generated code.
   
   Transcode
  
positive.code: Spores
  ------
  
  The spore is the fundamental unit of modular software artifact production in Moss.
  A spore describes how Moss produces artifacts from code in an architecture and toolchain independent fashion.
  
  Definition
  ~~~~~~~~~~
  
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
  