anchor.diff:  
   type ServerRequestHandler(readQueue: BlockingCollection<byte[]>, writeQueue: BlockingCollection<byte[]>, objects: List<obj>) =
       
  -//    let readQueue = new BlockingCollection<byte[]>(50)
  -//    let writeQueue = new BlockingCollection<byte[]>(50)
  -//    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 objects = new List<obj>()
   
       let handleRequest(request: Request) : Response =
           match request with
  
positive.code:     // For now, correctness and simplicity are more important
      let readQueue  = new BufferQueue(50)
      let writeQueue = new BufferQueue(50)
      
      let receiveRequests(socket: Socket) =
          let reader = new BinaryReader(new NetworkStream(socket))
          async {
              Logger.LogF(LogLevel.Info, fun _ -> sprintf "BufferStreamConnection(%A): starting to read" socket.LocalEndPoint)
              while true do
                  let count = reader.ReadInt32()
                  Logger.LogF(LogLevel.Info, fun _ -> sprintf "Read count: %d." count)
                  let bytes = Array.zeroCreate<byte> count
                  let rec readFrom cur = 
                      if cur >= count then ()
                      else 
                          let bytesRead = reader.Read(bytes, cur, count - cur)
                          Logger.LogF(LogLevel.Info, fun _ -> sprintf "%d bytes read." bytesRead)
                          readFrom (cur + bytesRead)
                  readFrom 0
                  readQueue.Add bytes
          }
  
      let sendResponses(socket: Socket) = 
          let writer = new BinaryWriter(new NetworkStream(socket))
          async {
              Logger.LogF(LogLevel.Info, fun _ -> sprintf "BufferStreamConnection(%A): starting to write" socket.LocalEndPoint)
              for response in writeQueue.GetConsumingEnumerable() do
                  Logger.LogF(LogLevel.Info, fun _ -> sprintf "Responding with %d bytes." response.Length)
                  writer.Write(response.Length)
                  writer.Write(response)
                  Logger.LogF(LogLevel.Info, fun _ -> sprintf "%d bytes written." response.Length)
          }
  
  
negative.code: open Prajna.Tools.FSharp
  open Prajna.Tools.Network
  
  //do Logger.ParseArgs([|"-con"|])
  do BufferListStream<byte>.InitSharedPool()
  
  type BufferQueue = BlockingCollection<byte[]>
  