If the square root of a small number, such as .0000009, is taken, since the 
correct value is only .0003, the allowed error is actually larger than the 
correct result, so the procedure is worthless for such small values.

For sufficiently large numbers, in an interpreter supporting limited precision, 
the minimum error achievable (i.e. by taking the representable number nearest 
the correct answer) will be greater than the allowed error of .001 despite the 
fact that no better approximation can be found, so the algorithm will not 
terminate.  (NB: I think this question is a bit obscure given the intention 
stated in footnote 4 to ignore the tricky numerical issues that arise on real 
machines, especially since floating point arithmetic and what exactly is meant 
by "limited precision" is fortunately not explained in the text.)

The alternative of exiting when the change in the guess between successive 
iterations becomes small enough requires us to compare the new with the old 
guess, so:

(define (close-enough? guess old-guess)
  (< (/ (abs (- guess old-guess)) guess) 0.001))

We can then redefine sqrt-iter:

(define (new-sqrt-iter guess old-guess x)
  (if (close-enough? guess old-guess)
      guess
      (new-sqrt-iter (improve guess x) guess x)))

and sqrt:

(define (new-sqrt x)
  (new-sqrt-iter 1.0 2.0 x)) ; 2.0 is arbitrary, it just needs to prevent sqrt-iter from returning on the first iteration

This approach should be better for both large and small numbers (though it will 
still fail for sufficiently large numbers where floating point arithmetic is 
used).