anchor.diff:     (parent :initarg :parent
   	   :reader parent
   	   :initform nil
  -	   :documentation "The parent transaction. Think of nested transactions semantics!!")
  +	   :documentation "The parent transaction")
      (status :initform :new
  -	   :accessor status)))
  +	   :accessor status
  +	   :documentation "The transaction status. May be :new, :commited, :failed, etc")))
   
   (defmethod commited-p ((transaction transaction))
     (equalp (status transaction) :commited))
  
positive.code: 	   (sb-thread:release-mutex (%lock object))))))
  
  (defmethod rollback-transaction ((transaction transaction))
    (setf (objects transaction) (make-hash-table)))
  
  (defmethod validate-superclass ((class transactional-class)
  				(superclass standard-class))
    t)
  
  (defun make-transaction ()
    (make-instance 'transaction))
  
  (defun start-transaction ()
    (setf *transaction* (make-transaction)))
  
  (defmacro with-transaction ((&optional (var '*transaction*))
  			    &body body)
    `(let ((,var (make-transaction)))
       ,@body
       (commit-transaction ,var)))
  
  (defmethod serializable-slots-using-class ((object t) (class transactional-class))
    (remove '%lock (call-next-method) :key (lambda (obj)
  
negative.code: 
  (defgeneric transactional-slots-using-class (object class)
    (declare (optimize speed))
    (:documentation "Return a list of transactional slot-definitions.
     The default calls compute slots with class")
    (:method ((object t) (class transactional-class))
      (remove '%lock (remove 'requires-transaction
  			   (class-slots class) :key (lambda (obj)
  						      (slot-value obj 'sb-pcl::name)))
  	    :key (lambda (obj)
  						      (slot-value obj 'sb-pcl::name)))))
  
  (defmethod transactional-slot-p ((object transactional-object) slot-name)
    (some (lambda (slot)
  