diff --git a/drracket/browser/private/btree.rkt b/drracket/browser/private/btree.rkt
index 07d08c5ae..564fd484a 100644
--- a/drracket/browser/private/btree.rkt
+++ b/drracket/browser/private/btree.rkt
@@ -27,171 +27,158 @@
                                 (node-pos n)))))
 
 (define (rotate-left n btree)
-  (let ([old-right (node-right n)])
-    (deadjust-offsets n old-right)
-    
-    (let ([r (node-left old-right)])
-      (set-node-right! n r)
-      (when r
-        (set-node-parent! r n)))
-    
-    (let ([p (node-parent n)])
-      (set-node-parent! old-right p)
-      (cond
-       [(not p) (set-btree-root! btree old-right)]
-       [(eq? n (node-left p)) (set-node-left! p old-right)]
-       [else                 (set-node-right! p old-right)]))
-    
-    (set-node-left! old-right n)
-    (set-node-parent! n old-right)))
+  (define old-right (node-right n))
+  (deadjust-offsets n old-right)
+  
+  (let ([r (node-left old-right)])
+    (set-node-right! n r)
+    (when r
+      (set-node-parent! r n)))
+  
+  (let ([p (node-parent n)])
+    (set-node-parent! old-right p)
+    (cond
+      [(not p) (set-btree-root! btree old-right)]
+      [(eq? n (node-left p)) (set-node-left! p old-right)]
+      [else (set-node-right! p old-right)]))
+  
+  (set-node-left! old-right n)
+  (set-node-parent! n old-right))
 
 (define (rotate-right n btree)
-  (let ([old-left (node-left n)])
-    (adjust-offsets old-left n)
-    
-    (let ([l (node-right old-left)])
-      (set-node-left! n l)
-      (when l
-        (set-node-parent! l n)))
-    
-    (let ([p (node-parent n)])
-      (set-node-parent! old-left p)
-      (cond
-       [(not p) (set-btree-root! btree old-left)]
-       [(eq? n (node-left p)) (set-node-left! p old-left)]
-       [else                 (set-node-right! p old-left)]))
-    
-    (set-node-right! old-left n)
-    (set-node-parent! n old-left)))
+  (define old-left (node-left n))
+  (adjust-offsets old-left n)
+  
+  (let ([l (node-right old-left)])
+    (set-node-left! n l)
+    (when l
+      (set-node-parent! l n)))
+  
+  (let ([p (node-parent n)])
+    (set-node-parent! old-left p)
+    (cond
+      [(not p) (set-btree-root! btree old-left)]
+      [(eq? n (node-left p)) (set-node-left! p old-left)]
+      [else (set-node-right! p old-left)]))
+  
+  (set-node-right! old-left n)
+  (set-node-parent! n old-left))
 
 
 (define (insert before? n btree pos data)
-  (let ([new (node pos data #f #f #f 'black)])
-    (if (not (btree-root btree))
-        (set-btree-root! btree new)
-        
-        (begin
-          
-          (set-node-color! new 'red)
-          
-                                        ; Insert into tree
-          (if before?
-              
-              (if (not (node-left n))
-                  (begin
-                    (set-node-left! n new)
-                    (set-node-parent! new n))
-                  
-                  (let loop ([node (node-left n)])
-                    (if (node-right node)
-                        (loop (node-right node))
-                        (begin
-                          (set-node-right! node new)
-                          (set-node-parent! new node)))))
-              
-              (if (not (node-right n))
-                  (begin
-                    (set-node-right! n new)
-                    (set-node-parent! new n))
-                  
-                  (let loop ([node (node-right n)])
-                    (if (node-left node)
-                        (loop (node-left node))
-                        (begin
-                          (set-node-left! node new)
-                          (set-node-parent! new node))))))
-          
-                                        ; Make value in new node relative to right-hand parents
-          (let loop ([node new])
-            (let ([p (node-parent node)])
-              (when p
-                (when (eq? node (node-right p))
-                  (adjust-offsets p new))
-                (loop p))))
-          
-                                        ; Balance tree
-          (let loop ([node new])
-            (let ([p (node-parent node)])
-              (when (and (not (eq? node (btree-root btree)))
-                         (eq? 'red (node-color p)))
-                (let* ([recolor-k
-                        (lambda (y)
-                          (set-node-color! p 'black)
-                          (set-node-color! y 'black)
-                          (let ([pp (node-parent p)])
-                            (set-node-color! pp 'red)
-                            (loop pp)))]
-                       [rotate-k
-                        (lambda (rotate node)
-                          (let ([p (node-parent node)])
-                            (set-node-color! p 'black)
-                            (let ([pp (node-parent p)])
-                              (set-node-color! pp 'red)
-                              (rotate pp btree)
-                              (loop pp))))]
-                       [k
-                        (lambda (node-y long-rotate always-rotate)
+  (define new (node pos data #f #f #f 'black))
+  (if (not (btree-root btree))
+      (set-btree-root! btree new)
+  
+      (begin
+  
+        (set-node-color! new 'red)
+  
+        ; Insert into tree
+        (if before?
+  
+            (if (not (node-left n))
+                (begin
+                  (set-node-left! n new)
+                  (set-node-parent! new n))
+  
+                (let loop ([node (node-left n)])
+                  (if (node-right node)
+                      (loop (node-right node))
+                      (begin
+                        (set-node-right! node new)
+                        (set-node-parent! new node)))))
+  
+            (if (not (node-right n))
+                (begin
+                  (set-node-right! n new)
+                  (set-node-parent! new n))
+  
+                (let loop ([node (node-right n)])
+                  (if (node-left node)
+                      (loop (node-left node))
+                      (begin
+                        (set-node-left! node new)
+                        (set-node-parent! new node))))))
+  
+        ; Make value in new node relative to right-hand parents
+        (let loop ([node new])
+          (let ([p (node-parent node)])
+            (when p
+              (when (eq? node (node-right p))
+                (adjust-offsets p new))
+              (loop p))))
+  
+        ; Balance tree
+        (let loop ([node new])
+          (let ([p (node-parent node)])
+            (when (and (not (eq? node (btree-root btree))) (eq? 'red (node-color p)))
+              (let* ([recolor-k (lambda (y)
+                                  (set-node-color! p 'black)
+                                  (set-node-color! y 'black)
+                                  (let ([pp (node-parent p)])
+                                    (set-node-color! pp 'red)
+                                    (loop pp)))]
+                     [rotate-k (lambda (rotate node)
+                                 (let ([p (node-parent node)])
+                                   (set-node-color! p 'black)
+                                   (let ([pp (node-parent p)])
+                                     (set-node-color! pp 'red)
+                                     (rotate pp btree)
+                                     (loop pp))))]
+                     [k (lambda (node-y long-rotate always-rotate)
                           (let ([y (node-y (node-parent p))])
                             (if (and y (eq? 'red (node-color y)))
                                 (recolor-k y)
-                                (let ([k (lambda (node)
-                                           (rotate-k always-rotate node))])
+                                (let ([k (lambda (node) (rotate-k always-rotate node))])
                                   (if (eq? node (node-y p))
                                       (begin
                                         (long-rotate p btree)
                                         (k p))
                                       (k node))))))])
-                  (if (eq? p (node-left (node-parent p)))
-                      (k node-right rotate-left rotate-right)
-                      (k node-left rotate-right rotate-left))))))
-          
-          (set-node-color! (btree-root btree) 'black)))))
+                (if (eq? p (node-left (node-parent p)))
+                    (k node-right rotate-left rotate-right)
+                    (k node-left rotate-right rotate-left))))))
+  
+        (set-node-color! (btree-root btree) 'black))))
 
 (define (find-following-node btree pos)
-  (let ([root (btree-root btree)])
-    (let loop ([n root]
-               [so-far root]
-               [so-far-pos (and root (node-pos root))]
-               [v 0])
-      (if (not n) 
-          (values so-far so-far-pos)
-          (let ([npos (+ (node-pos n) v)])
-            (cond
-             [(<= pos npos)
-              (loop (node-left n) n npos v)]
-             [(or (not so-far-pos)
-                  (> npos so-far-pos))
-              (loop (node-right n) n npos npos)]
-             [else
-              (loop (node-right n) so-far so-far-pos npos)]))))))
+  (define root (btree-root btree))
+  (let loop ([n root]
+             [so-far root]
+             [so-far-pos (and root (node-pos root))]
+             [v 0])
+    (if (not n)
+        (values so-far so-far-pos)
+        (let ([npos (+ (node-pos n) v)])
+          (cond
+            [(<= pos npos) (loop (node-left n) n npos v)]
+            [(or (not so-far-pos) (> npos so-far-pos)) (loop (node-right n) n npos npos)]
+            [else (loop (node-right n) so-far so-far-pos npos)])))))
 
 (define (create-btree)
   (btree #f))
 
 (define (btree-get btree pos)
-  (let-values ([(n npos) (find-following-node btree pos)])
-    (and n
-         (= npos pos)
-         (node-data n))))
+  (define-values (n npos) (find-following-node btree pos))
+  (and n (= npos pos) (node-data n)))
 
 (define (btree-put! btree pos data)
-  (let-values ([(n npos) (find-following-node btree pos)])
-    (if (and n (= npos pos))
-        (set-node-data! n data)
-        (insert (and n (< pos npos))
-                n btree pos data))))
+  (define-values (n npos) (find-following-node btree pos))
+  (if (and n (= npos pos))
+      (set-node-data! n data)
+      (insert (and n (< pos npos)) n btree pos data)))
 
 (define (btree-shift! btree start delta)
   (let loop ([n (btree-root btree)]
              [v 0])
     (when n
-      (let ([npos (node-pos n)])
-        (cond
-         [(< start (+ v npos))
-          (set-node-pos! n (+ npos delta))
-          (loop (node-left n) v)]
-         [else
-          (loop (node-right n) (+ v npos))])))))
+      (define npos (node-pos n))
+      (cond
+        [(< start (+ v npos))
+         (set-node-pos! n (+ npos delta))
+         (loop (node-left n) v)]
+        [else (loop (node-right n) (+ v npos))]))))
 
 (define (btree-for-each btree f)
   (when (btree-root btree)
@@ -209,12 +196,9 @@
    (let loop ([n (btree-root btree)]
               [v 0]
               [a null])
-     (if (not n)
-         a
-         (let* ([pre (loop (node-left n) v a)]
-                [here (cons (f (+ v (node-pos n))
-                               (node-data n))
-                            pre)])
-           (loop (node-right n)
-                 (+ v (node-pos n))
-                 here))))))
+     (cond
+       [(not n) a]
+       [else
+        (define pre (loop (node-left n) v a))
+        (define here (cons (f (+ v (node-pos n)) (node-data n)) pre))
+        (loop (node-right n) (+ v (node-pos n)) here)]))))
diff --git a/drracket/browser/private/bullet.rkt b/drracket/browser/private/bullet.rkt
index 3ec528198..10703d7f3 100644
--- a/drracket/browser/private/bullet.rkt
+++ b/drracket/browser/private/bullet.rkt
@@ -11,8 +11,7 @@
 
 (define bullet-size 
   (make-parameter
-   (let ([s (send (send (send (make-object text%) get-style-list) basic-style)
-                  get-size)])
+   (let ([s (send+ (make-object text%) (get-style-list) (basic-style) (get-size))])
      (max 7 (quotient s 2)))))
 
 (define (get-bullet-width)
@@ -51,16 +50,15 @@
                           [(0) (values (lambda (x y w h) (send dc draw-ellipse x y w h)) #t)]
                           [(1) (values (lambda (x y w h) (send dc draw-ellipse x y w h)) #f)]
                           [else (values (lambda (x y w h) (send dc draw-rectangle x y w h)) #f)])])
-            (let ([b (send dc get-brush)])
-              (send dc set-brush
-                    (if solid?
-                        (send the-brush-list
-                              find-or-create-brush
-                              (send (send dc get-pen) get-color)
-                              'solid)
-                        transparent-brush))
-              (draw x y bsize bsize)
-              (send dc set-brush b)))))]
+            (define b (send dc get-brush))
+            (send
+             dc
+             set-brush
+             (if solid?
+                 (send the-brush-list find-or-create-brush (send (send dc get-pen) get-color) 'solid)
+                 transparent-brush))
+            (draw x y bsize bsize)
+            (send dc set-brush b))))]
     [define/override copy
       (lambda ()
         (make-object bullet-snip% depth))]
@@ -69,11 +67,10 @@
         (send stream put depth))]
     [define/override get-text
       (lambda (offset num flattened?)
-        (if (< num 1)
-            ""
-            (if flattened?
-                "* "
-                "*")))]
+        (cond
+          [(< num 1) ""]
+          [flattened? "* "]
+          [else "*"]))]
     (super-new)
     (set-snipclass bullet-snip-class)
     (set-count 1)))
diff --git a/drracket/browser/private/entity-names.rkt b/drracket/browser/private/entity-names.rkt
index 0095cff99..9809e7099 100644
--- a/drracket/browser/private/entity-names.rkt
+++ b/drracket/browser/private/entity-names.rkt
@@ -256,6 +256,6 @@
           (euro . 8364)))
 
 (define (entity-name->integer s)
-  (hash-ref table s (lambda () #f)))
+  (hash-ref table s #f))
 
 
diff --git a/drracket/browser/private/html.rkt b/drracket/browser/private/html.rkt
index 0f97992d7..d3f13ab5e 100644
--- a/drracket/browser/private/html.rkt
+++ b/drracket/browser/private/html.rkt
@@ -41,13 +41,17 @@
 
 ;; load-status : boolean string (union #f url) -> void
 (define (load-status push? what url)
-  (let ([s (format "Loading ~a ~a..." 
-                   what 
-                   (if url
-                       (trim 150 (url->string url))
-                       "unknown url"))])
-    (status-stack (cons s (if push? (status-stack) null)))
-    (status "~a" s)))
+  (define s
+    (format "Loading ~a ~a..."
+            what
+            (if url
+                (trim 150 (url->string url))
+                "unknown url")))
+  (status-stack (cons s
+                      (if push?
+                          (status-stack)
+                          null)))
+  (status "~a" s))
 
 (define (pop-status)
   (status-stack (cdr (status-stack)))
@@ -86,52 +90,45 @@
         (cond
          [(null? rects) #f]
          [else
-          (let ([rect (car rects)])
-            (if (and (<= (image-map-rect-left rect) x (image-map-rect-right rect))
-                     (<= (image-map-rect-top rect) y (image-map-rect-bottom rect)))
-                rect
-                (loop (cdr rects))))])))
+          (define rect (car rects))
+          (if (and (<= (image-map-rect-left rect) x (image-map-rect-right rect))
+                   (<= (image-map-rect-top rect) y (image-map-rect-bottom rect)))
+              rect
+              (loop (cdr rects)))])))
     
     ;; add-area : string (listof number) string -> void
     ;; currently only supports rect shapes
     (define/public (add-area shape coords href)
       (when (and (equal? shape "rect")
                  (= 4 (length coords)))
-        (let ([x1 (car coords)]
-              [y1 (cadr coords)]
-              [x2 (caddr coords)]
-              [y2 (cadddr coords)])
-          (set! rects (cons (make-image-map-rect
-                             href
-                             (min x1 x2)
-                             (min y1 y2)
-                             (max x1 x2)
-                             (max y1 y2))
-                            rects)))))
+        (define x1 (car coords))
+        (define y1 (cadr coords))
+        (define x2 (caddr coords))
+        (define y2 (cadddr coords))
+        (set! rects
+              (cons (make-image-map-rect href (min x1 x2) (min y1 y2) (max x1 x2) (max y1 y2)) rects))))
     
     (define/override (on-event dc x y editor-x editor-y evt)
       (when (send evt button-up?)
-        (let* ([snipx (- (send evt get-x) x)]
-               [snipy (- (send evt get-y) y)]
-               [rect (find-rect snipx snipy)])
-          (when rect
-            (send html-text post-url (image-map-rect-href rect)))))
+        (define snipx (- (send evt get-x) x))
+        (define snipy (- (send evt get-y) y))
+        (define rect (find-rect snipx snipy))
+        (when rect
+          (send html-text post-url (image-map-rect-href rect))))
       (super on-event dc x y editor-x editor-y evt))
     
     (define/override (adjust-cursor dc x y editor-x editor-y evt)
-      (let ([snipx (- (send evt get-x) x)]
-            [snipy (- (send evt get-y) y)])
-        (if (find-rect snipx snipy)
-            finger-cursor
-            #f)))
+      (define snipx (- (send evt get-x) x))
+      (define snipy (- (send evt get-y) y))
+      (if (find-rect snipx snipy) finger-cursor #f))
 
     ;; warning: buggy. This doesn't actually copy the bitmap
     ;; over because there's no get-bitmap method for image-snip%
     ;; at the time of this writing.
     (define/override (copy)
-      (let ([cp (new image-map-snip% (html-text html-text))])
-        (send cp set-key key)
-        (send cp set-rects rects)))
+      (define cp (new image-map-snip% (html-text html-text)))
+      (send cp set-key key)
+      (send cp set-rects rects))
     
     (super-make-object)
     
diff --git a/drracket/version/tool.rkt b/drracket/version/tool.rkt
index 81aca6f9e..34a31b20e 100644
--- a/drracket/version/tool.rkt
+++ b/drracket/version/tool.rkt
@@ -30,9 +30,11 @@
   ;; wait until the definitions are instantiated, return top-level window
   (define (wait-for-definitions)
     (define ws (get-top-level-windows))
-    (if (null? ws)
-      (begin (sleep 1) (wait-for-definitions))
-      (car ws)))
+    (cond
+      [(null? ws)
+       (sleep 1)
+       (wait-for-definitions)]
+      [else (car ws)]))
   #| ;; Cute code, but may resize the window if too much space, and people
      ;; didn't like this way of asking if you want update checks.
   ;; show a message and a disable button
@@ -181,4 +183,4 @@
              (super help-menu:after-about m))
            (super-new))))
       (thread check-for-updates))
-    (when (> patchlevel 0) (version:add-spec 'p patchlevel))))
+    (when (positive? patchlevel) (version:add-spec 'p patchlevel))))