anchor.diff:  This will check all the operations and types in details, and generate the
   executable implementing each node, or return any encountered error.
   
  -If all went well, you can then GET `/start` for Rigatoni to start all those
  +If all went well, you can then GET `/start` for Ramen to start all those
   executables, and then `/stop` to kill them all.
   
   [[export-API]]
   === Receive Exported Tuples
   
   Some operations export some tuples.
  -Those tuples can then be obtained from Rigatoni at `/export/NODE_NAME`.
  +Those tuples can then be obtained from Ramen at `/export/NODE_NAME`.
   To limit the output, a body can be sent with two optional integer fields:
   `since`, to ask for all tuples _after_ that one, and `max_results` to ask for
   no more than that many tuples.
   
   [[timeseries-API]]
   === Receive Values According to Time
  +
  +[[upload-API]]
  +=== Upload data
  +
  ++RECEIVE+ nodes expect that the data be sent to Ramen, as a CSV, via an HTTP
  +POST to +/upload/NODE_NAME/+.
  
positive.code: seasonality) and `k` (how many seasons in the past to consider). Notice that
  in the example above as well as in the functions below the current value is
  skipped: `v(t)` is not in the average. This is because we often want to
  compare such computation over the past seasons with the actual current value.
  
  Seasonality is similar to fixed length windows but implemented at the
  function level rather than at the aggregation level.
  
negative.code: the configuration. This configuration consists of a graph of operations, each
  of which is given using a specialized high level language inspired by SQL.
  These operations are then compiled by the central server down to machine code
  into individual programs, the xref:Worker[workers], for parallel execution.
  
  Each worker accepts input of a given type and produces output of a given type,
  not unlike SQL rows being consumed by a SQL query that produces other rows used
  as input to a sub query. As in SQL, each row is a xref:Tuple[tuple] of
  primitive types.  This stream of tuples flows directly from one worker to the
  next using efficient memory-mapped ring buffers.  All those tuples are
  statically typed at compile time to avoid runtime failures and improve speed.
  
  == Glossary
  
  [glossary]
  [[AggregationFunction]]Aggregation Function::
    A function that build a result value out of several input values.
    The result is output only when some condition is met.
  
  [[Commit]]Commit::
    When aggregating incoming xref:Tuple[tuples] into a single
    xref:Group[group] met some defined condition then the result of the
    aggregation is going to be output. This is called to _commit_ the group.
    What happens next to the group depends on the configuration but oftentimes
    it will merely be deleted.
  
  [[ConfGraph]]Configuration Graph::
    The directed graph of the defined operations. The nodes of this graph
    represent the operations while the edges represents the flow of tuples.
    This graph can be cyclic, with some limitations (see xref:Layer[]).
  
  [[Event]]Event::
    An individual message to be processed. In Ramen events are
    xref:Tuples[tuples].
  
  [[FQName]]Fully Qualified Name::
    The fully qualified name of a node is the name of the layer it belongs to,
    then a slash ("/"), then the name of the node. Those FQ names are globally
    unique.
  
  [[Group]]Group::
    Within the context of a operation, a `group` refers to an aggregation group,
    ie the set of tuples sharing the same key and aggregated together. This
    group live as long as it is committed (and then it can be deleted or reduced
    before resuming the operation). Aggregation groups are therefore closely
    related to the concept of xref:Windowing[windows].
  
  [[Layer]]Layer::
    A subgraph of the xref:ConfGraph[Configuration Graph]. Containing one or
    several xref:Node[nodes]. This is the smallest subset of the configuration
    that can be edited/compiled/started/stopped. Inside a layer nodes are allowed
    to form cycles, but the layers themselves must form a tree.
    In addition to a set of nodes, a layer also has a name. Those names must be
    globally unique.
  
  [[Node]]Node::
    Vertices of the xref:ConfGraph[Configuration Graph]. A node is composed of a
    name and an operation. Node names must be unique within a layer.  Every node
    has an input and an output type, which is the types of the tuples they
    consume and produce. These types may only be known after the layer is compiled,
    though. Nodes can receive tuples from any other nodes of the same layer, or
    from any nodes of any layer defined previously.
  
  [[Nullable]]Nullable::
    Said of a tuple field that can hold the NULL value. Most fields should not be
    nullable as it implies expensive runtime checks.
  
  [[Operation]]Operation::
    The description, in the SQL-inspired specific language, of how a node produce
    output from its input.
  
  [[RingBuffer]]Ring-Buffer::
    Fixed sized buffer with a cursor where the writers add content to, and
    another cursor where the readers read values from, both wrapping around the
    buffer, thus implementing a fixed size FIFO.
  
  [[RotatingBloomFilters]]Rotating Bloom Filters::
    Array of https://en.wikipedia.org/wiki/Bloom_filter[bloom filters], each
    entry coding for a particular slice of time, and rotated as time passes, in
    order to make (approximate) deletion possible.
  
  [[StatefulFunction]]Stateful function::
    A function that requires an internal state in order to output a result.
    xref:AggregationFunction[Aggregation functions] are a special case of
    stateful functions.
  
  [[StatelessFunction]]Stateless function::
    A function that requires nothing more than its parameters to compute its
    result. For instance, all arithmetic functions are stateless.
  
  [[StreamProcessor]]Stream Processor::
    A software which purpose it to perform user defined computation on a
    theoretically infinite stream of data.
    See: https://en.wikipedia.org/wiki/Data_stream_management_system.
  
  [[Tuple]]Tuple::
    What is consumed and produced by nodes.  A set of values, each of its own
    type. Those values are called "fields" and beside its type a field also has a
    name that must be unique in the tuple.  Tuples are the only constructed data
    type, and must itself be composed only of primitive types.
  
  [[Windowing]]Windowing::
    In a xref:StreamProcessor[stream processor], _windowing_ refers to how
    incoming events are batched before processing. Usually windows are either
    sliding or tumbling, with variations (see for instance
    https://i.stack.imgur.com/mm06A.jpg[this picture]). Ramen is rather unique
    in this regard that it has n o notion of a window, especially not one bound
    to time, since it has no preconception of time. Instead, Ramen has explicit
    conditions for when to stop a aggregation (to xref:Commit[commit] the
    group), and what to keep from one aggregation to the next. This makes it
    possible to configure any conceivable windows, including non sequential
    "windows".
  
  [[Worker]]Worker::
    One of the possibly many programs generated and executed by Ramen to carry
    out some operation on the data stream.
  
  == The Configuration Language Reference
  
  We describe first values, then expressions, then operations.  All these
  