They aren't as ugly as XML ;)

This was a great read convincing me so: http://www.defmacro.org/ramblings/lisp.html

I prefer: (defun add(a b) (+ a b))

Over: <defun name="add"><params><param>a</param><param>b</param></params> <+><a></a><b></b></+></defun> (Or some variant thereof)

Any day. The article above improved my understanding and appreciation of Lisp(s) but it made me dislike Java even more than what I already had!

Common Lisp has mutable data structures by default and actually I think one of the most elegant parts of CL is the setf macro http://www.lispworks.com/documentation/HyperSpec/Body/m_setf..., which is a very clean interface to changing state.

The best functional lisps to use right now would be Clojure and Racket. They both use immutable data structures by default, though neither is "pure". Clojure if you want all the good JVM bits and maybe actually convincing your manager to use it and Racket if you just want to learn using a language that's more beginner-friendly (http://htdp.org/ and the DrRacket IDE) or (mostly) compatible with Scheme (SICP, Little Schemer, etc.).

I've found there aren't really any widely used purely functional languages out there except Haskell (which needs it due to laziness).

    -- Curried and uncurried add in Haskell:
    curriedAdd :: Int -> Int -> Int
    curriedAdd x y = x + y
    
    uncurriedAdd :: (Int, Int) -> Int
    uncurriedAdd (x, y) = x + y

    ;; Curried and uncurried add in Scheme:
    (define (curried-add x)
      (lambda (y) (+ x y)))
    
    (define (uncurried-add x y)
      (+ x y))