anchor.diff:  (defvar *day-names* '("Monday" "Tuesday" "Wednesday"
                         "Thursday" "Friday" "Saturday" "Sunday"))
   (defvar *uptime* (multiple-value-list (get-decoded-time)))
  -(defparameter *commands-names* '("/users" "/help" "/log" "/quit" "/uptime"))
  +(defparameter *commands-names* '("/users" "/help" "/log" "/quit" "/uptime" "/nick"))
   (defparameter *clients* nil)
   (defparameter *messages-stack* nil)
   (defparameter *messages-log* nil)
   (defparameter *server-nickname* "@server")
  +
   
   ;; thread control
   (defvar *message-semaphore* (make-semaphore :name "message semaphore"
  
positive.code:     (write-line message stream)
      (finish-output stream)))
  
  (defun client-reader-routine (client)
    "This function create a IO-bound procedure to act
     by reading the events of a specific CLIENT.
     On this software each client talks on your own thread."
    (loop for message = (read-line (client-stream client))
          while (not (equal message "/quit"))
          if (member message *commands-names* :test #'equal)
            do (send-message client (call-command-by-name message))
          else
            when (> (length message) 0)
              do (push-message (client-name client)
  
negative.code:          (message (make-message :from from :content content :time time)))
      (formated-message message)))
  
  (defun call-command-by-name (string params)
    "Wow, this is a horrible hack to get a string as symbol for functions/command
    like /help /users /log and so on."
    (let ((command-function (find-symbol (string-upcase string) :lisp-chat-server)))
      (when command-function
        (apply command-function params))))
  
  ;; user commands prefixed with /
  (defun /users (client &rest args)
    "Return a list separated by commas of the currently logged users"
    (command-message (format nil "~{~a~^, ~}" (mapcar #'client-name *clients*))))
  
  
  (defun /help (client &rest args)
    "Show a list of the available commands of lisp-chat"
    (command-message (format nil "~{~a~^, ~}" *commands-names*)))
  
  
  (defun /log (client &optional (depth "20") &rest args)
    "Show the last messages typed on the server.
     DEPTH is optional number of messages frames from log"
    (let ((messages (min (or (parse-integer depth :junk-allowed t) 20)
                         (length *messages-log*))))
      (format nil "~{~a~^~%~}" (reverse (subseq *messages-log* 0
                                                messages)))))
  
  (defun /uptime (client &rest args)
    "Return a string nice encoded to preset the uptime since the server started."
    (multiple-value-bind
          (second minute hour date month year day-of-week dst-p tz)
  