anchor.diff:      (cond ((requestp msg) 
              (multiple-value-bind (msg-id msg-method msg-params) (parse-request msg)
                (format t "Received request [~A] ~A(~{~A~^, ~})~%" msg-id msg-method (first msg-params))
  -             (send-msg (make-response msg-id (format NIL "Replying to request [~A] ~A(~{~A~^, ~})" msg-id msg-method (first msg-params)) NIL))))
  +             (send-response msg-id (format NIL "Replying to request [~A] ~A(~{~A~^, ~})" msg-id msg-method (first msg-params)) NIL)))
             ((responsep msg) 
              (multiple-value-bind (msg-id msg-result) (parse-response msg)
                (format t "Received response [~A] ~A~%" msg-id msg-result)
  
positive.code:              (format t "Received notification ~A(~{~A~^, ~})~%" msg-method (first msg-params))
               (force-output))))))
  
  (defun send-msg (msg)
    (if *socket*
      (if cl-async-base:*event-base*
        (as:write-socket-data *socket* msg :force t)    
        ;; Because we can't just send message from a thread doesn't have event-loop
        ;; running and since there doesn't seem to be a better way of doing this
        ;; in cl-async, we have to make this thread know about an event loop
        ;; running in the other thread first.
        (let* ((cl-async-base:*event-base* *global-event-base*)
               (cl-async-base:*data-registry* (cl-async-base:event-base-data-registry cl-async-base:*event-base*))
               (cl-async-base:*function-registry* (cl-async-base:event-base-function-registry cl-async-base:*event-base*))
               ; (*buffer-writes* *buffer-writes*)
               ; (*buffer-size* *buffer-size*)
               ; (*output-buffer* (static-vectors:make-static-vector *buffer-size* :element-type 'octet))
               ; (*input-buffer* (static-vectors:make-static-vector *buffer-size* :element-type 'octet))
               ; (*data-registry* (event-base-data-registry *event-base*))
               ; (*function-registry* (event-base-function-registry *event-base*))
               ; (callbacks nil)
               )
          (as:write-socket-data *socket* msg :force t)))))
  
  (defun run (&key (host "127.0.0.1") (port 7777) fn)
    (bt:make-thread (lambda () (cond (fn              (run-listener #'as:pipe-connect fn))
                                     ((and host port) (run-listener #'as:tcp-connect host port))))
                    :name "Event loop")
    (format *standard-output* "Event loop is running..."))
  
negative.code: 
  (defmacro msg-rpc-type (type-name type-id &rest components)
    (let ((make-name (symbol-append 'make- type-name))
          (send-name (symbol-append 'send- type-name))
          (predicate-name (symbol-append type-name 'p))
          (parse-name (symbol-append 'parse- type-name)) 
          (components (mapcar #'mklst components)))
      `(progn
         (defun ,make-name ,(first-els (remove-lsts-with :make components))
           (concatenate '(vector (unsigned-byte 8)) (encode (list ,type-id ,@(mapcar #'(lambda (c) (or (getf (rest c) :make) (first c))) components)))))
         (defun ,send-name ,(first-els (remove-lsts-with :make components))
           (send (,make-name ,@(first-els (remove-lsts-with :make components)))))
         (defun ,predicate-name (msg)
           (= (first msg) ,type-id))
         (defun ,parse-name (msg)
  