To defend your coworker here for a moment, I think he was talking about the general concepts of abstraction and DWIM (do what I mean). It is indeed true that Common Lisp and (perhaps to a slightly lesser extent) Scheme do this better than just about any other programming languages out there partially because it supports stuff like weak (actually, optionally strong) typing and first class functions long before 'modern' scripting languages popularized them, but mostly because by essentially having one single syntactic structure -- (DoThis To This Stuff) -- you are able to easily use self-analyzing and self-modifying code via macros. Since you brought up "it" in your post, I think a good and interesting example is Paul Graham's "anaphoric" macros from his book On Lisp ( http://www.paulgraham.com/onli...
Macro definition of "aif":
(defmacro aif (test-form then-form &optional else-form)
Now, the regular if is uses an (if this then_do_this else_do_this) form. Paul's macro functions exactly as if except the word "it" is now automatically variable referring to the value returned by 'this' in the preceeding if usage example
. Thus, an example usage of aif:
(aif [really_friggin_long_to_type_and_computationally_expensive_thing] (print it) (print "null value error"))
The "it" variable is lexically scoped only within the aif, and in Lisp variables can be "shadowed" by interior redefinitions an arbitrary number of times (basically, once you hit the relevant ")" the higher-up definition of "it" takes over once again), so you can chain together consecutive or nested aifs seemlessly. And of course you can build aands, awhiles (very useful), etc. Note that usage of macros do not result in runtime slowdowns, only (potentially) compile-time slowdowns. Also note how simple of an example this is--look at how short that macro definition was. And once you train yourself to comprehend the ()s, it's perfectly and easily readable.
Common Lisp's generic functions (i.e. methods, except not hopelessly hobbled and limited in scope) are another good example of JustDoIt style programming. Also note that you can override the default definition of any operator/function so that, if you really felt like it, you could replace if's definition with aif.
None of this gets you out of actually defining what "it" is in JustDoIt (you are stuck with that in any language), but if done properly this kind of flexibility and abstraction results in code that is both more readable and more modular / maintainable. And it's a fast language, DAMN fast if you know what you're doing. Faster than Java, if you turn on the proper optimizations. No need for an interpreter--most of the heavy lifting can be done at compile time.
Just to show I'm not a total fanboy, almost all of the Lisps suffer from "good enough" syndrome and crotchety old man syndrome. The concept of M-Expressions (i.e. infix syntax, i.e. not having to use ()s all over the damn place) was abandoned because S-Expressions turned out to be so incredibly powerful. Power is good, but if you make it mandatory you jack up the learning curve unnecessarily, as well as make some things harder to read or as well as requiring more keystrokes to program... although I must say if you do pattern X more than once, you can always abstract out whatever pattern X is--just as aif abstracts out the pattern of evaluating an expression and then binding the return value to a disposable variable. That's the blessing/curse of Lisp. It's so easy for a journeyman Lisper to fix the warts in the language that no one ever fixes them in the language spec itself, and that unnecessarily scares off the noobs.
That, and there is just way, way too much fad-ism in computer languages... of which Java's popularity is possibly the best example.