anchor.diff:                (setq stderr stdout) (setq stdout nil))
   ;;;              
           (when (and stdout (> (length stdout) 0))
  -          (send-stream (kernel-iopub (shell-kernel shell)) msg "stdout" stdout :key (kernel-key shell)))
  +          (send-stream (kernel-iopub (shell-kernel shell)) msg "stdout" stdout 
  +              :key (kernel-key shell)))
           ;; send the stderr
           (when (and stderr (> (length stderr) 0))
  -          (send-stream (kernel-iopub (shell-kernel shell)) msg "stderr" stderr :key (kernel-key shell)))
  +          (send-stream (kernel-iopub (shell-kernel shell)) msg "stderr" stderr 
  +              :key (kernel-key shell)))
   	
           ;; send the first result
   	(send-execute-result (kernel-iopub (shell-kernel shell)) 
   			     msg execution-count (car results) :key (kernel-key shell))
   	;; status back to idle
  -	(send-status-update (kernel-iopub (shell-kernel shell)) msg "idle" :key (kernel-key shell))
  +	(send-status-update (kernel-iopub (shell-kernel shell)) msg "idle" 
  +	    :key (kernel-key shell))
   	;; send reply (control)
   	(let ((reply (make-message msg "execute_reply" nil
   				   `(("status" . "ok")
   				     ("execution_count" . ,execution-count)
   				     ("payload" . ,(vector))))))
  -	  (message-send (shell-socket shell) reply :identities identities :key (kernel-key shell))
  +	  (message-send (shell-socket shell) reply :identities identities 
  +	      :key (kernel-key shell))
   	  t)))))
   
   
  -(defclass message-content ()
  -  ()
  +(defclass message-content ()()
     (:documentation "The base class of message contents."))
   
   
  
positive.code:   ;;(vector-push-extend code (evaluator-history-in evaluator))
    (let ((execution-count (length (evaluator-history-in evaluator))))
      (let ((code-to-eval code))
        (let* ((stdout-str (make-array 0 :element-type 'character :fill-pointer 0 :adjustable t))
  	     (stderr-str (make-array 0 :element-type 'character :fill-pointer 0 :adjustable t)))
  	 (let ((results (with-output-to-string (stdout stdout-str)
  	    (with-output-to-string (stderr stderr-str)
  	      (let ((*standard-output* stdout) (*error-output* stderr))
  	          (if (or (starts-with-p code ")co") 
  	                  (starts-with-p code ")lib")
  	                  (not *cl-guard*))
  	             (multiple-value-list (ispad-eval code)) 
  		         (handling-errors
  		           (let ((*evaluator* evaluator))       
  			         (multiple-value-list (ispad-eval code))))) 
     ))))) 
     ;;EVAL
     (vector-push-extend code (evaluator-history-in evaluator))
     (vector-push-extend results (evaluator-history-out evaluator))
  
negative.code: 	     (format stream "[JSon parse error] ~A"
  		     (match-error-message condition)))))
  
  
  (defun char-whitespace-p (char)
    (or (char= char #\Space)
        (char= char #\Tab)
        (char= char #\Return)
        (char= char #\Linefeed)))
  
  
  (defun read-next-char (input)
    (loop 
      (let ((char (read-char input nil :eof)))
        (cond ((eql char :eof) 
          (error 'json-parse-error :message "Unexpected end of file"))
  	      ((char= char #\\) ; c-style escape chars
  	      (let ((char (read-char input nil :eof)))
  	  (cond ((eql char :eof) 
  		(error 'json-parse-error :message "Unexpected end of file (after '\'"))
  		      ((char= char #\n) (return #\Newline))
  		      (t (return char)))))
  	     ((not (char-whitespace-p char)) (return char))))))
  