anchor.diff:          }
   
       member this.Start() =
  +        Logger.LogF(LogLevel.Info, fun _ -> sprintf "Starting request handler")
  +        processRequests() |> Async.Start
  +
  +type ServerNode() =
  +
  +    let network = new ConcreteNetwork()
  +    let objects = new List<obj>()
  +    
  +    let onConnect readQueue writeQueue =
  +        let handler = ServerRequestHandler(readQueue, writeQueue, objects)
  +        handler.Start()
  +
  +    member this.Start() =
           Logger.LogF(LogLevel.Info, fun _ -> sprintf "Starting server node")
  -        network.Listen<BufferStreamConnection>(1500, (readQueue, writeQueue))
  -        processRequests() |> Async.Start
  +        network.Listen<BufferStreamConnection>(1500, onConnect)
   
   
   type ClientNode(addr: string, port: int) =
   
  -    let readQueue = new BlockingCollection<byte[]>(50)
  -    let writeQueue = new BlockingCollection<byte[]>(50)
  +    let mutable readQueue : BufferQueue = null
  +    let mutable writeQueue : BufferQueue = null
       let network = new ConcreteNetwork()
   
       let serializer = 
           let memStreamBConstructors = (fun () -> new MemoryStreamB() :> MemoryStream), (fun (a,b,c,d,e) -> new MemoryStreamB(a,b,c,d,e) :> MemoryStream)
           GenericSerialization.GetDefaultFormatter(CustomizedSerializationSurrogateSelector(memStreamBConstructors))
   
  +    let onConnect rq wq =
  +        readQueue <- rq
  +        writeQueue <- wq
  +
       member this.Start() =
  -        async {
  -            Logger.LogF(LogLevel.Info, fun _ -> sprintf "Starting client node")
  -            network.Connect<BufferStreamConnection>(addr, port, (readQueue, writeQueue)) |> ignore
  -        }
  -        |> Async.Start
  +        Logger.LogF(LogLevel.Info, fun _ -> sprintf "Starting client node")
  +        network.Connect<BufferStreamConnection>(addr, port, onConnect) |> ignore
   
       member internal this.Run(request: Request) : Response =
           let memStream = new MemoryStream()
  
positive.code: 
          member this.Init(socket: Socket, state: obj) = 
              Logger.LogF(LogLevel.Info, fun _ -> sprintf "New connection created (%A)." socket.LocalEndPoint)
              do 
                  let queues = state :?> BlockingCollection<byte[]> * BlockingCollection<byte[]>
                  readQueue <- fst queues
                  writeQueue <- snd queues
              receiveRequests socket
              sendResponses socket
  
          member this.Close() = ()  
  
  
negative.code:                 readFrom 0
                  readQueue.Add bytes
          }
  
      let sendResponses(socket: Socket) = 
          let writer = new BinaryWriter(new NetworkStream(socket))
  