anchor.diff:  (defun start-spot (feed-glld feed-passwd)
     "Start the thread that reads the latest API data from spot.com every
   2.5 minutes. This keeps the *spots* list up-to-date."
  -  (setf *uptodate-thread* (bt:make-thread (lambda () (up-to-dater feed-glld feed-passwd)) :name "up-to-dater"))
  +  (setf *uptodate-thread*
  +	(bt:make-thread
  +	 (lambda ()
  +	   (up-to-dater feed-glld feed-passwd)) :name "up-to-dater"))
     (format t "spot update thread is running...~%"))
   
   (defun get-all-spots-local ()
  
positive.code:   (point-metadata-deserialize-method p point-data)
    (mapcar #'(lambda (n)
  	      (cond
  	       ((equal (first n) 'lat)
  		(setf (point-lat p) (second n)))
  	       ((equal (first n) 'lon)
  		(setf (point-lon p) (second n)))
  	       ((equal (first n) 'id)
  		(setf (point-id p) (second n)))
  	       ((equal (first n) 'unix-time)
  		(setf (point-unix-time p) (second n)))
  	       ((equal (first n) 'message-type)
  		(setf (point-message-type p) (second n)))
  	       ((equal (first n) 'model-id)
  		(setf (point-model-id p) (second n)))
  	       ((equal (first n) 'show-custom-msg)
  		(setf (point-show-custom-msg p) (second n)))
  	       ((equal (first n) 'date-time)
  		(setf (point-date-time p) (second n)))
  	       ((equal (first n) 'battery-state)
  		(setf (point-battery-state p) (second n)))
  	       ((equal (first n) 'hidden)
  		(setf (point-hidden p) (second n)))
  	       ((equal (first n) 'datum)
  		(setf (point-datum p) (second n)))
  	       ))
  	  point-data))
  
  (defun get-spot-locations (feed-glld &optional (passwd nil))
    "Get the last fifty entries as JSON data from the Spot server.
  Accepts an optional password for password-protected location feeds."
    (let ((feed (concatenate 'string "https://api.findmespot.com/spot-main-web/consumer/rest-api/2.0/public/feed/"
  			   feed-glld "/message.json")))
      (if passwd (setf feed (concatenate 'string feed "?feedPassword=" passwd)))
      (let ((result (drakma:http-request feed
                                         :method :get
                                         :accept "application/json"
                                         :content-type "application/json")))
        (if (> (length result) 0)
            (json:decode-json-from-string (babel:octets-to-string 
                                           (nth-value 0 result)))
            nil))))
  
  (defun extract-spot-locations (spot-json)
    "Extract just the location data from the parsed JSON object returned
  from the Spot API."
    (cdr (assoc :message
  	      (cdr (assoc :messages
  			  (cdr (assoc :feed-message-response
  				      (cdr (assoc :response spot-json)))))))))
  
  (defmethod make-location (l)
    "Turn a JSON location into a location object."
    (make-instance 'spot-point
                   :id (cdr (assoc :id l))
                   :messenger-id (cdr (assoc :messenger-id l))
                   :unix-time (cdr (assoc :unix-time l))
                   :message-type (cdr (assoc :message-type l))
                   :lat (cdr (assoc :latitude l))
                   :lon (cdr (assoc :longitude l))
                   :model-id (cdr (assoc :model-id l))
                   :show-custom-msg (cdr (assoc :show-custom-msg l))
                   :date-time (cdr (assoc :date-time l))
                   :battery-state (cdr (assoc :battery-state l))
                   :hidden (cdr (assoc :hidden l))
  		 :creation-source point-spot
                   ))
  
  
negative.code: 
  (defun spot-street-address (spot google-api-key)
    "Convert a spot location into a street address."
    (geocode:extract-street-address-from-json
     (lookup-location spot google-api-key)))
  
  (defun create-location-objects-from-list (location-list)
    "Takes a list of JSON locations (usually
  