anchor.diff:          (debug-format t "Added new user ~s ~%" (client-name client))
           (push client *clients*))
         (push-message "@server" (format nil "The user ~s joined to the party!" (client-name client)))
  -      (sb-thread:with-mutex (*client-read-mutex*)
  -        (push (sb-thread:make-thread #'client-reader
  -                                     :name (format nil "~a reader thread" (client-name client))
  -                                     :arguments (list client))
  -              *client-read-threads*)))))
  +      (sb-thread:make-thread #'client-reader
  +                             :name (format nil "~a reader thread" (client-name client))
  +                             :arguments (list client)))))
   
   
   (defun message-broadcast ()
  
positive.code:                                *clients*)))
    (debug-format t "Deleted user ~s ~%" (client-name client)))
  
  
  (defun client-reader-routine (client)
    (loop for message = (read-line (client-stream client))
          while (not (equal message "/quit"))
          when (> (length message) 0)
            do (push-message (client-name client)
                             message)
          finally (client-delete client)))
  
  (defun client-reader (client)
    (handler-case (client-reader-routine client)
      (end-of-file () (client-delete client))))
  
  
  (defun send-message (client message)
    (let ((stream (client-stream client)))
      (write-line message stream)
      (finish-output stream)))
  
  
  (defun create-client (connection)
  
negative.code:           (message-content message)))
  
  
  (defun command-message (content)
    (let* ((from "@server")
           (time (get-time))
           (message (make-message :from from :content content :time time)))
      (formated-message message)))
  
  
  ;; user commands prefixed with /
  (defun /users ()
    (command-message (format nil "~{~a~^, ~}" (mapcar #'client-name *clients*))))
  
  
  (defun /help ()
    (command-message (format nil "~{~a~^, ~}" *commands-names*)))
  
  
  (defun /log (&optional (depth 15))
    (format nil "~{~a~^~%~}" (reverse (subseq *messages-log* 0
                                              (min depth (length *messages-log*))))))
  
  
  (defun push-message (from content)
    (sb-thread:with-mutex (*message-mutex*)
      (push (make-message :from from
                          :content content
                          :time (get-time))
            *messages-stack*)
      (sb-thread:signal-semaphore *message-semaphore*)))
  
  (defun client-delete (client)
    (push-message "@server"
  