anchor.diff:  (defun write-string-to-repl (string)
     (let ((buffer (repl-buffer)))
       (when buffer
  -      (with-open-stream (stream (make-buffer-output-stream (lem::buffer-end-point buffer)))
  +      (with-open-stream (stream (make-buffer-output-stream (buffer-end-point buffer)))
           (princ string stream))
         (lem.listener-mode:listener-update-point (buffer-end-point buffer))
         (when (eq buffer (current-buffer))
  
positive.code: 
  (defun log-message (message)
    (let ((buffer (get-buffer-create "*lisp-events*")))
      (with-open-stream (stream (make-buffer-output-stream (lem::buffer-end-point buffer)))
        (print message stream))))
  
  (defvar *unknown-keywords* nil)
  
negative.code: 
  (defun highlight-notes (notes)
    (lisp-remove-notes)
    (when notes
      (let ((overlays '()))
        (lem.sourcelist:with-sourcelist (sourcelist "*lisp-compilations*")
          (dolist (note notes)
            (optima:match note
              ((and (optima:property :location
                                     (or (list :location
                                               (list :buffer buffer-name)
                                               (list :offset pos _)
                                               _)
                                         (list :location
                                               (list :file file)
                                               (list :position pos)
                                               _)))
                    (or (optima:property :message message) (and))
                    (or (optima:property :source-context source-context) (and)))
               (let ((jump-fun (if buffer-name
                                   (lambda ()
                                     (let ((buffer (get-buffer buffer-name)))
                                       (when buffer
                                         (setf (current-window) (pop-to-buffer buffer))
                                         (move-to-position (current-point) pos))))
                                   (lambda ()
                                     (find-file file)
                                     (move-to-position (current-point) pos)))))
                 (lem.sourcelist:append-sourcelist
                  sourcelist
                  (let ((name (or buffer-name file)))
                    (lambda (cur-point)
                      (insert-string cur-point name :attribute 'lem.grep:title-attribute)
                      (insert-string cur-point ":")
                      (insert-string cur-point (princ-to-string pos) :attribute 'lem.grep:position-attribute)
                      (insert-string cur-point ":")
                      (insert-character cur-point #\newline 1)
                      (insert-string cur-point message)
                      (insert-character cur-point #\newline)
                      (insert-string cur-point source-context)))
                  jump-fun)
                 (push (make-highlight-overlay pos
                                               (if buffer-name
                                                   (get-buffer buffer-name)
                                                   (get-file-buffer file)))
                       overlays))))))
        (when overlays
          (setf *note-overlays* overlays)))))
  
  (define-command lisp-remove-notes () ()
    (mapc #'delete-overlay *note-overlays*))
  