anchor.diff:      // 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))
  +        let reader = new NetworkStream(socket)
           async {
               Logger.LogF(LogLevel.Info, fun _ -> sprintf "BufferStreamConnection(%A): starting to read" socket.LocalEndPoint)
               while true do
  -                let count = reader.ReadInt32()
  +                let! countBytes = reader.AsyncRead 4
  +                let count = BitConverter.ToInt32(countBytes, 0)
                   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
  +                let! bytes = reader.AsyncRead count 
                   readQueue.Add bytes
           }
   
       let sendResponses(socket: Socket) = 
  -        let writer = new BinaryWriter(new NetworkStream(socket))
  +        let writer = 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)
  +                let countBytes = BitConverter.GetBytes(response.Length)
  +                do! writer.AsyncWrite(countBytes)
  +                do! writer.AsyncWrite(response)
                   Logger.LogF(LogLevel.Info, fun _ -> sprintf "%d bytes written." response.Length)
           }
   
  
positive.code: open Prajna.Tools.FSharp
  open Prajna.Tools.Network
  
  do Logger.ParseArgs([|"-con"|])
  do BufferListStream<byte>.InitSharedPool()
  
  type BufferQueue = BlockingCollection<byte[]>
  
negative.code:         readQueue <- rq
          writeQueue <- wq
  
      do
          Logger.LogF(LogLevel.Info, fun _ -> sprintf "Starting client node")
          network.Connect<BufferStreamConnection>(addr, port, onConnect) |> ignore
  
  