Re: LISP PROGRAMMING

(defun odd-reverse (list)
   (let ((result
          (loop for (odd even) on list by #'cddr
                collect odd into odds
                collect even into evens
                finally (return (loop for odd in (reverse odds)
                                      for even in evens
                                      collect odd
                                      collect even)))))
     (subseq result 0 (list-length list))))

 
Another viewpoint:
 
(defun reverse-odd-elems (list)
  (loop with v       = (coerce list 'simple-vector)
        with len     = (length list)
        with odd-len = (if (evenp len) len (1- len))
        for i from 0 upto (floor odd-len 2)
        when (oddp i) do (rotatef (aref v i) (aref v (- odd-len i)))
        finally (return (coerce v 'list))))

* (odd-reverse '(0 1 2 3 4 5 6 7))
(6 1 4 3 2 5 0 7)

Gauche Scheme

;; The length of the list must be even.
(define (odd-reverse lst)
  (do ((a () (cons (pop! lst) a))
       (b () (cons (pop! lst) b)))
    ((null? lst) (append-map list a (reverse b)))))

(odd-reverse '(0 1 2 3 4 5 6 7))
  ===>
(6 1 4 3 2 5 0 7)