diff --git a/contrib/swank-asdf.lisp b/contrib/swank-asdf.lisp
index e74b9c3..2e5169b 100644
--- a/contrib/swank-asdf.lisp
+++ b/contrib/swank-asdf.lisp
@@ -11,36 +11,57 @@
 (in-package :swank)
 
 (eval-when (:compile-toplevel :load-toplevel :execute)
+  #|
+  ;; The recommended way to install an ASDF upgrade is to configure
+  ;; your source-registry in e.g. ~/.config/common-lisp/source-registry.conf
+  ;; and register a copy of the asdf source tree somewhere in there.
+  ;; See the ASDF documentation for details.
+  ;; However, if you want to work with versions of Lisp so old that they
+  ;; don't even ship with ASDF 2, stick in your ~/.swank.lisp something like:
+  (defparameter swank::*asdf-directory* #p"/path/to/asdf/")
+  |#
   (defvar *asdf-directory*
     (merge-pathnames #p"cl/asdf/" (user-homedir-pathname))
     "Directory in which your favorite and/or latest version
      of the ASDF source code is located")
-  (defvar *upgrade-asdf-p* nil
-    "Should we upgrade ASDF immediately upon startup?
-     This is recommended if you upgrade ASDF at all."))
+  (defvar *upgrade-asdf-p* t
+    "Should we attempt an upgrade of ASDF immediately upon startup?
+     This is *STRONGLY* recommended and done by recent versions of ASDF anyway.
+     If you insist not to, just don't have any asdf.asd registered."))
 
 ;;; Doing our best to load ASDF
 ;; First, try loading asdf from your implementation.
-;; Use eval to not fail on old CLISP.
+;; Use funcall to not fail on old CLISP.
 (eval-when (:compile-toplevel :load-toplevel :execute)
   (unless (member :asdf *features*)
-    (ignore-errors (eval '(require "asdf")))))
+    (ignore-errors (funcall 'require "asdf"))))
 
 ;; If not found, load asdf from wherever the user specified it
 (eval-when (:compile-toplevel :load-toplevel :execute)
   (unless (member :asdf *features*)
     (ignore-errors
      (handler-bind ((warning #'muffle-warning))
-       (let ((asdf-lisp (probe-file
-                         (make-pathname :name "asdf" :type "lisp"
-                                        :defaults *asdf-directory*))))
-         (when asdf-lisp (load asdf-lisp)))))))
+       (let* ((build-asdf-lisp
+                (merge-pathnames
+                 (make-pathname :directory '(#-gcl :relative "build")
+                                :name "asdf" :type "lisp"
+                                :defaults *asdf-directory*)
+                 *asdf-directory*))
+              (asdf-lisp
+                (make-pathname :directory (pathname-directory *asdf-directory*)
+                               :defaults build-asdf-lisp)))
+         (cond
+           ((probe-file build-asdf-lisp)
+            (load build-asdf-lisp))
+           ((probe-file asdf-lisp)
+            (load asdf-lisp))))))))
 
 ;; If still not found, error out.
 (eval-when (:compile-toplevel :load-toplevel :execute)
   (unless (member :asdf *features*)
     (error "Could not load ASDF.
-Please install ASDF2 and in your ~~/.swank.lisp specify:
+Please update your implementation or
+install ASDF2 and in your ~~/.swank.lisp specify:
  (defparameter swank::*asdf-directory* #p\"/path/containing/asdf/\")")))
 
 ;;; If ASDF is found, try to upgrade it to the latest installed version.
@@ -48,18 +69,25 @@ Please install ASDF2 and in your ~~/.swank.lisp specify:
   (when *upgrade-asdf-p*
     (handler-bind ((warning #'muffle-warning))
       (pushnew *asdf-directory* asdf:*central-registry*)
-      (ignore-errors (asdf:oos 'asdf:load-op :asdf)))))
+      (ignore-errors (asdf:operate 'asdf:load-op :asdf :verbose nil)))))
 
 ;;; If ASDF is too old, punt.
+;; Quicklisp has 2.014.6 for the longest time, now 2.26.
+;; CLISP ships with 2.11? Too bad, have them upgrade or
+;; install an upgrade yourself and configure *asdf-directory*
+;; It's just not worth the hassle supporting something
+;; that doesn't even have COERCE-PATHNAME.
 (eval-when (:compile-toplevel :load-toplevel :execute)
-  (unless (or #+asdf2 (asdf:version-satisfies (asdf:asdf-version) "2.000"))
+  (unless (or #+asdf2
+              (asdf:version-satisfies (asdf:asdf-version) "2.14.6"))
     (error "Your ASDF version is too old.
-Please upgrade to ASDF2 and in your ~~/.swank.lisp specify:
- (defparameter swank::*asdf-directory* #p\"/path/containing/asdf/\")")))
+Please upgrade to the latest stable ASDF and register it in your source-registry.")))
+
 
 ;;; Import functionality from ASDF that isn't available in all ASDF versions.
 ;;; Please do NOT depend on any of the below as reference:
 ;;; they are sometimes stripped down versions, for compatibility only.
+;;; Indeed, they are supposed to work on *OLDER*, not *NEWER* versions of ASDF.
 ;;;
 ;;; The way I got these is usually by looking at the current definition,
 ;;; using git blame in one screen to locate which commit last modified it,
@@ -98,48 +126,9 @@ Please upgrade to ASDF2 and in your ~~/.swank.lisp specify:
                  ((defmethod) (defmethod* version aname args))
                  ((defvar) (defvar* name aname args)))))))
 
-(asdefs "2.015"
- (defvar *wild* #-cormanlisp :wild #+cormanlisp "*"))
-
-(asdefs "2.010"
- (defun collect-sub*directories (directory collectp recursep collector)
-   (when (funcall collectp directory)
-     (funcall collector directory))
-   (dolist (subdir (subdirectories directory))
-     (when (funcall recursep subdir)
-       (collect-sub*directories subdir collectp recursep collector)))))
-
-(asdefs "2.011"
- (defun find-symbol* (s p)
-   (find-symbol (string s) p)))
-
-(asdefs "2.012"
- (defvar *wild-file*
-   (make-pathname :name *wild* :type *wild*
-                  :version (or #-(or abcl xcl) *wild*) :directory nil))
- (defvar *wild-directory*
-   (make-pathname :directory `(:relative ,*wild*)
-                  :name nil :type nil :version nil)))
-
-(asdefs "2.014"
- (defun ensure-directory-pathname (pathspec)
-   (cond
-     ((stringp pathspec)
-      (ensure-directory-pathname (pathname pathspec)))
-     ((not (pathnamep pathspec))
-      (error "Invalid pathname designator ~S" pathspec))
-     ((wild-pathname-p pathspec)
-      (error "Can't reliably convert wild pathname ~S" pathspec))
-     ((asdf::directory-pathname-p pathspec)
-      pathspec)
-     (t
-      (make-pathname :directory (append (or (pathname-directory pathspec)
-                                            (list :relative))
-                                        (list (file-namestring pathspec)))
-                     :name nil :type nil :version nil
-                     :defaults pathspec)))))
+(asdefs "2.15"
+ (defvar *wild* #-cormanlisp :wild #+cormanlisp "*")
 
-(asdefs "2.015"
  (defun collect-asds-in-directory (directory collect)
    (map () collect (directory-asd-files directory)))
 
@@ -149,7 +138,7 @@ Please upgrade to ASDF2 and in your ~~/.swank.lisp specify:
        (collect-sub*directories-asd-files
         directory :exclude exclude :collect collect))))
 
-(asdefs "2.016"
+(asdefs "2.16"
  (defun load-sysdef (name pathname)
    (declare (ignore name))
    (let ((package (asdf::make-temporary-package)))
@@ -179,7 +168,7 @@ Please upgrade to ASDF2 and in your ~~/.swank.lisp specify:
                          #+sbcl
                          (when (find-symbol "RESOLVE-SYMLINKS" '#:sb-impl)
                            '(:resolve-symlinks nil)))))))
-(asdefs "2.017"
+(asdefs "2.17"
  (defun collect-sub*directories-asd-files
      (directory &key
                 (exclude asdf::*default-source-registry-exclusions*)
@@ -198,7 +187,7 @@ Please upgrade to ASDF2 and in your ~~/.swank.lisp specify:
  (defun filter-logical-directory-results (directory entries merger)
    (if (typep directory 'logical-pathname)
        (loop for f in entries
-             when 
+             when
              (if (typep f 'logical-pathname)
                  f
                  (let ((u (ignore-errors (funcall merger f))))
@@ -212,7 +201,7 @@ Please upgrade to ASDF2 and in your ~~/.swank.lisp specify:
  (defun directory-asd-files (directory)
    (directory-files directory asdf::*wild-asd*)))
 
-(asdefs "2.019"
+(asdefs "2.19"
     (defun subdirectories (directory)
       (let* ((directory (ensure-directory-pathname directory))
              #-(or abcl cormanlisp genera xcl)
@@ -244,7 +233,7 @@ Please upgrade to ASDF2 and in your ~~/.swank.lisp specify:
          (let ((prefix (or (normalize-pathname-directory-component
                             (pathname-directory directory))
                            ;; because allegro 8.x returns NIL for #p"FOO:"
-                           '(:absolute)))) 
+                           '(:absolute))))
            (lambda (d)
              (let ((dir (normalize-pathname-directory-component
                          (pathname-directory d))))
@@ -257,6 +246,9 @@ Please upgrade to ASDF2 and in your ~~/.swank.lisp specify:
                               (last dir))))))))))))
 
 (asdefs "2.21"
+ (defun component-loaded-p (c)
+   (and (gethash 'load-op (component-operation-times (find-component c nil))) t))
+
  (defun normalize-pathname-directory-component (directory)
    (cond
      #-(or cmu sbcl scl)
@@ -286,7 +278,7 @@ Please upgrade to ASDF2 and in your ~~/.swank.lisp specify:
     :type (make-pathname-component-logical (pathname-type pathname))
     :version (make-pathname-component-logical (pathname-version pathname)))))
 
-(asdefs "2.022"
+(asdefs "2.22"
  (defun directory-files (directory &optional (pattern *wild-file*))
    (let ((dir (pathname directory)))
      (when (typep dir 'logical-pathname)
@@ -310,14 +302,13 @@ Please upgrade to ASDF2 and in your ~~/.swank.lisp specify:
                          :version (make-pathname-component-logical
                                    (pathname-version f)))))))))
 
-(asdefs "2.27"
- (defmethod component-relative-pathname ((component asdf:component))
+(asdefs "2.26.125"
+ (defmethod component-relative-pathname ((system system))
    (asdf::coerce-pathname
-    (or (and (slot-boundp component 'asdf::relative-pathname)
-             (slot-value component 'asdf::relative-pathname))
-        (asdf::component-name component))
-    :type (asdf::source-file-type component (asdf::component-system component))
-    :defaults (asdf::component-parent-pathname component))))
+    (and (slot-boundp system 'relative-pathname)
+         (slot-value system 'relative-pathname))
+    :type :directory
+    :defaults (system-source-directory system))))
 
 ;;; Taken from ASDF 1.628
 (defmacro while-collecting ((&rest collectors) &body body)
@@ -431,7 +422,7 @@ AND in its source-registry. (legacy name)"
       #+asdf2
       (progn
         (asdf:ensure-source-registry)
-        (if (asdf:version-satisfies (asdf:asdf-version) "2.015")
+        (if (asdf:version-satisfies (asdf:asdf-version) "2.15")
             (loop :for k :being :the :hash-keys :of asdf::*source-registry*
                   :do (c k))
             (dolist (entry (asdf::flatten-source-registry))
@@ -484,9 +475,7 @@ already knows."
         files)))
 
 (defslimefun asdf-system-loaded-p (name)
-  (and (gethash 'asdf:load-op
-                (asdf::component-operation-times (asdf:find-system name)))
-       t))
+  (component-loaded-p name))
 
 (defslimefun asdf-system-directory (name)
   (namestring (asdf:system-source-directory name)))
