anchor.diff:  (defun socket-connect (host port &key (element-type 'character))
     (let ((usock))
       (with-mapped-conditions (usock)
  -       (let ((sock (ext:make-socket (host-to-hostname host) port)))
  +      (let* ((sock-addr (jdi:jcoerce
  +                         (jdi:do-jnew-call "java.net.InetSocketAddress"
  +                                           (host-to-hostname host)
  +                                           (jdi:jcoerce port :int))
  +                         "java.net.SocketAddress"))
  +             (jchan (jdi:do-jstatic-call "java.nio.channels.SocketChannel"
  +                                         "open" sock-addr))
  +             (sock (jdi:do-jmethod-call jchan "socket")))
  +        (describe sock)
            (setf usock
                  (make-stream-socket
                   :socket sock
  -                :stream (ext:get-socket-stream sock
  +                :stream (ext:get-socket-stream (jdi:jop-deref sock)
                                                  :element-type element-type)))))))
   
   (defun socket-listen (host port
  
positive.code:                            (backlog 5)
                             (element-type 'character))
    (let* ((reuseaddress (if reuse-address-supplied-p reuse-address reuseaddress))
           (sock-addr (jnew-call ("java.net.InetSocketAddress"
                                  "java.lang.String" "int")
                                 (host-to-hostname host) port))
           (chan (jstatic-call "java.nio.channels.ServerSocketChannel" ("open")))
           (sock (java:jcall
                  (java:jmethod "java.nio.channels.ServerSocketChannel"
                                "socket") chan)))
      (when reuseaddress
        (jmethod-call sock
                      ("setReuseAddress" "boolean")
                      (java:make-immediate-object reuseaddress :boolean)))
      (jmethod-call sock
                    ("bind" "java.net.SocketAddress" "int")
                    sock-addr backlog)
      (make-stream-server-socket sock :element-type element-type)))
  
  (defmethod socket-accept ((socket stream-server-usocket) &key element-type)
    (let* ((jsock (socket socket))
           (jacc-sock (jmethod-call jsock ("accept")))
           (jacc-stream
            (ext:get-socket-stream jacc-sock
                                   :element-type (or element-type
                                                     (element-type socket)))))
      (make-stream-socket :socket jacc-sock
  
negative.code: 
  |#
  
  (defun op-read ()
    (jdi:do-jfield "java.nio.channels.SelectionKey"
                   "OP_READ"))
  
  (defun op-accept ()
    (jdi:do-jfield "java.nio.channels.SelectionKey"
                   "OP_ACCEPT"))
  
  (defun op-connect ()
    (jdi:do-jfield "java.nio.channels.SelectionKey"
                   "OP_CONNECT"))
  
  (defun valid-ops (jchannel)
    (jdi:do-jmethod-call jchannel "validOps"))
  
  (defun channel-class (jchannel)
    (let ((valid-ops (valid-ops jchannel)))
  