I've been trying to learn Racket macros but articles like this make me feel like I should just give up. For example, in arc a macro looks like this:

  (mac awhen (expr . body)
    `(let it ,expr (if it (do ,@body))))

I can understand that, and start making macros and going about my business. The Racket guys (e.g. Eli and Jay) write macros that look like this:

  (require (lib "stxparam.ss" "mzlib"))
  (define-syntax-parameter it
    (lambda (stx)
      (raise-syntax-error #f "can only be used inside `if'" stx)))
  (define-syntax if*
    (syntax-rules ()
      [(if*) (void)]
      [(if* X) X]
      [(if* C X more ...)
       (let ([b C])
         (if b
           (syntax-parameterize ([it (make-rename-transformer #'b)]) X)
           (if* more ...)))]))

Or like this:

  (define-syntax (123-list stx)
  (define middle-x-stx (second (syntax->list stx)))
  (define x-id (syntax-e middle-x-stx))
  (define new-ctxt-stx (datum->syntax #f 'new-ctxt))
  (datum->syntax
   new-ctxt-stx
   (list (datum->syntax #'123-list 'let)
         (list (list x-id (datum->syntax #'123-list 3)))
         (list (datum->syntax #'123-list '#%app)
               (datum->syntax #'123-list 'list)
               (datum->syntax #'123-list x-id)
               middle-x-stx
               x-id))))

They have reasonable objections to arc-style macros, but I feel like they are overly academic and not relevant to the programming problems that I want to address. I want to eliminate boilerplate, and I'm willing to take the limitations of arc-style macros because they are so much easier to understand.