I keep seeing the word "Enlightenment" paired with Lisp. What is this godly epiphany that Lisp programmers carry on about?

They understand this joke:

That strip was among the references that piqued my interest.

Any chance you can clarify?

I guess it's in large part the "data and code are the same... just symbols" concept.

I once saw a real awesome "enlightening" screencast, I think it was called "DSLs in Lisp", but I can't find it anymore.

The LISP syntax is structured in such a way that you can process code itself as easily as any other data structure. Thus (among other things), the language allows for arbitrarily powerful macros, unlike C's preprocessor.

The light of LISP is also because of its minimal, yet non low-level, and highly consistent syntax. You have (, ), some operators, be done. And it is nearly as old as modern computing (1958).

It is so fucking minimal yet freakingly high level yet easy to parse I don't know what else would be like it damn.

It ... is.

To me the Lisp "enlightenment" derives from two factors: (1) the extremely simple and consistent syntax; (2) the distinction between Lisp code and data fades and fades and fades the more you use the language.

Lisp is just a programming language that has some nice features that work together very well.

Basically Lisp just lets you use LOTS of cleverness, but at the same time it forces that same cleverness to be as consistent as possible. In the end though reading someone else's clever code is still hell, and your own clever code just stays in memory longer.
__________

For instance in Lisp CLOS, the OO system was originally implemented entirely in Lisp(Not changing the underlying language at all). Lispers will argue that CLOS is a more powerful OO system than what you would see in any other language(Java or better).

__________

You're probably better off just laughing at the religious Lispers. After all they forgot one of the most important rules of programming: these are just tools, nothing else.

I think as more and more languages start to pick up more and more functional features, the impact of Lisp's "aha!" moment is going to decrease. Lamdas and closures and currying are pretty rawksome, but most languages can do that now. The last, big feature that Lisp has that is still pretty rare in other languages is the macro system and its shear depth (specifically because of the whole data=code thing). Ruby does some macroing like that, but it's not quite as powerful, probably because of how much more complex the Ruby syntax is over Lisp. Oh, and don't forget that Lisp can do this at incredible speed, almost C-fast with the right compiler.

Check out Scheme, a variant of Lisp we used at Uni to interpret and specialize programs.

To learn some Lisp, see these ancient but interesting MIT video lectures from Gerald Sussman, "Structure and Interpretation of Computer Programs".

Also, the lecture "Growing a Language" by Guy L. Steele is worth checking out, for some thoughts on the evolvement of languages.