anchor.diff:  
               | "pastry"::stuff -> // only handles '/pastry'
                   let error_message = sprintf "Unrecognized pastry request url: '%s'" path
  -                Invalid(error_message, 400, "Illegal action")
  +                Invalid(error_message, 404, "Illegal action")
               | _ ->
                   let error_message = sprintf "Not related to pastry: %s" path
  -                Invalid(error_message, 404, "Not found")
  +                Invalid(error_message, 200, "Not found")
   
           match result with
           | Valid(updated_node) ->
  
positive.code: type Node = {
      guid: GUID;
      address: NetworkLocation;
      // I assume that there are never more than 65k rows in the table
      routing_table: Map<GUID, Address> list;
      minleaf: U128;
      maxleaf: U128;
      neighbors: Map<GUID, Address>;  // Physical location proximity (IP address)
      leaves: Map<GUID, Address>;     // GUID-numerically closest nodes
  }
  
  // A result type to simplify the interpretation a little
  
negative.code: 
          printfn "Neighbors of %A: %A" node.guid neighbors
          printfn "Leaves    of %A: %A" node.guid leaves
          let updated_node =
              { node with
                  neighbors = neighbors;
                  leaves = leaves;
                  minleaf = minleaf;
                  maxleaf = maxleaf;
              }
          let notify guid address =
              match send_message address Update (serialize updated_node) guid with
              | Some(_) -> ()
              | None -> printfn "PASTRY: Failed to notify %A at '%s' of update..." guid address
          Map.iter notify updated_node.leaves
          Map.iter notify updated_node.neighbors
          List.iter (fun map_level -> Map.iter notify map_level) updated_node.routing_table
          printfn "PASTRY: State after joining: %A" updated_node
          updated_node
  
      | Update -> // The node is notified of a new node joining
          let state = deserialize message
          let updated_node = try_add_neighbor (try_add_leaf node state.guid state.address) state.guid state.address
          printfn "PASTRY: State after update: %A" updated_node
          updated_node
      | _ ->
          node
  
  