anchor.diff:  
   == Components
   
  -MapView is built in a particularly modular way as
  -link:http://noexc.org/[our own] requirements change fairly often. Typically, we
  -experiment with new technologies and telemetry systems on each flight we
  -perform, and it is important that we are able to compensate for these changes
  -quickly, and reflect them in the MapView codebase with relative ease.
  +Previous versions of MapView came with several different executable, each
  +responsible for crunching certain kinds of data. However, this lead to us
  +inventing a fake IPC pipeline that did not scale well and was difficult to
  +configure and maintain.
   
  -Here we give a brief overview of each component. Each component has its own
  -documentation file with more information about the role it plays.
  +MapView 3 takes a "configuration driven development" approach. That is, your
  +configuration file is a Haskell file which gets compiled and run. Your
  +configuration file **is** your MapView instance, customized exactly for your
  +flight.
   
  -Programs (each of which is considered an individual component) which ship with
  -MapView, as a rule, are all prefixed with `mapview-`. For example,
  -`mapview-telemetryparser` is the program (component) which parses raw telemetry
  -in realtime during a flight.
  +This approach is not new. In fact, it is how the XMonad tiling window manager
  +works.
   
  -We don't currently make use of any kind of real "IPC" framework. Instead, we
  -write out state to files (usually in JSON) and listen for changes to these files
  -in various components. In the future, we could optionally make use of something
  -along the lines of `dbus` for dealing with IPC, if there is a need/want.
  +Here's how it works: MapView is no longer a "system." Instead, it is a library
  +for *creating* systems. We provide basic types to glue things together, and you
  +provide callbacks that work exactly how you want them to, over the data you
  +collect.
  +
  +To make things easier for you, we provide a wide array of callbacks in the
  +MapView library, which you can take advantage of in your configuration. If they
  +don't work, you can simply write your own callback (possibly based on ours!) and
  +use it instead.
   
   === mapview: The Library
   
  
positive.code: reception system for
  link:https://en.wikipedia.org/wiki/High-altitude_balloon[high-altitude balloon projects].
  It is meant to be used by those with an interest in HAB chases, as a means of
  tracking and following the balloon during a flight.
  
  It consists of several individual components, some of which interoperate with
  each other, and some of which can be run independently during and after a
  balloon chase.
  
  MapView is written from a standpoint that prefers stability (and correctness)
  and modularity over speed and ease of installation. Because of this, setting it
  up for the first time can be daunting, particularly if you are not familiar with
  building and installing Haskell packages.
  
  It is our hope that this documentation makes the process as pain-free as
  possible, but we invite and encourage questions about the process in the
  
negative.code: link:https://en.wikipedia.org/wiki/Cyclic_redundancy_check[CRC] validation,
  parsing of raw telemetry data, configuration file parsing, and datatypes and
  typeclasses which are reused throughout the various components.
  
  == Bugs, Comments, Issues
  
  