The main difference between Lisp and most other languages out there is that Lisp has been designed for computing with symbolic data.

    (+ a b)  is a Lisp expression

    '(+ a b)  is Lisp data

Some languages have similar capabilities that can be used easily (Prolog, Mathematica, ...). Some have it in difficult variants, where one has to deal with complex representations. Others simply represent programs as strings and not more.

Perhaps by 2059, we'll have languages with macros and regular syntax.

Boo has macros ... http://boo.codehaus.org/Language+Guide (at the end, under 'advanced features'.

The implicit other stuff is "everything else."

    Yesterday we saw an awesome game.

    The sound of the new stereo is awesome.

    The view from that skyscraper is awesome.

    Yesterday I saw the most awesome game.

Green is forever.

http://www.ausmotive.com/2009/03/20/porsche-917-celebrates-4...

You would not find that Porsche 917 from 1970 awesome?

http://www.ausmotive.com/images/Porsche-917-01.jpg

'The Grand Canyon is awesome' - how does that depend on WHEN I see it. As long as there is a Grand Canyon, it is awesome. It is of no concern if there are things less or more awesome. The Grand Canyon is just 'awesome'.

Lisp has for some people also timeless qualities. One of these people is Alan Kay (of Smalltalk, Dynabook, etc.) fame. Check some day what Alan thinks about Lisp: http://bc.tech.coop/blog/060224.html

"Most people who graduate with CS degrees don't understand the significance of Lisp. Lisp is the most important idea in computer science."

The Grand Canyon is in no way exempt from time -- millions of years ago it was just another unremarkable course of the Colorado River, and millions of years from now it will have eroded to nothingness. The Himalayas used to be an unremarkable coastline, and the Appalachians hills were once taller than Everest is now.

As long as there is a GRAND CANYON (a label for an observable geological feature given by man) the GRAND CANYON will be awesome. Your father found the Grand Canyon awesome and and your children will find it awesome, too. For us humans the Grand Canyon, as long it is there and as long we are there, is 'awesome'.

'Awesome' is an impression that humans have of something. It has nothing to do with geological timescales.

Redwoods are awesome trees because of their size. If all other trees died out and Redwoods were the only tree, they wouldn't be awesome, they would be "normal tree size".

Unless you are high you don't go around being awe inspired by everyday things. Awesome is implicitly comparing with "everything else". Different things aren't awesome, but awesome things are different - but only while they are different.

> a Porsche from 1970 is still awesome

Not to me. A Veyron, now that's awesome. Spitfires are awesome, but only anachronistically - for their time and their reputation at the time - they don't hold a candle to a modern fighter.

Sure, there might be cars with less fantastic engineering, those I might not find awesome. But it says nothing about that there is only a single thing of a certain type that I can find awesome or that other things are less or more awesome. 'Just awesome' stands for it alone.

No, I don't find the Veyron awesome. That's just butt ugly.

These are awesome cars:

http://www.ausmotive.com/images/Porsche-917-01.jpg

Especially the one in the front.

After a few days or so, I saw many, many more Kachina dolls, such that I could start seeing differences in quality. Those first ones I saw? They really weren't all that awesome. They were actually sort of crappy, once I saw some truly awesome handiwork.

Whether or not something inspires awe really does depend on previous experience.

Now, everything does X. Showing someone Lisp doing X will get the response of 'So what?'. Therefore, Lisp is no longer awesome because of feature X.

Almost none of the mainstream scripting languages uses simple code as data as Lisp does. Not Ruby. Not Python. Not PHP. Not JavaScript.

None of them have the roots in a meta-circular interpreter that fits on a page.

http://arcfn.com/2008/07/maxwells-equations-of-software-exam...

None of those allow me to write symbolic computations in a simple and straight forward way like I can do it in Lisp.

I find that awesome.

What (someone) up the chain was saying was exactly that. Lisp is interesting because of those things that it alone does. Not because it is capable of things that other languages do.

A DSL family based on a flexible core (with a lispish intermediate language even) might be a viable approach.

In many situations, simplicity and restrictions (constraints) in DSLs is better than flexibility and expressiveness in a general purpose language, because it can offer new possibilities for domain specific optimizations due to domain specific constraints.

Just like new notations in math led to breakthroughs in many math branches, new syntax can bring new life to software in many specific domains.

The key to such systems seems to be making DSLs easy to build and optimize using a suite of common building blocks (human (cs people) friendly intermediate languages (like lisp as opposed to VM byte codes) and libraries.)

Examples for "high-level" languages on top of Lisp:

Macsyma, Axiom, Refine, AP5, RacerPro, CycL, NESL, Reduce, PVS, the original ML, ...

For a Lisp-like example see PDDL (Planning Domain Definition Language):

    (define (domain hanoi-domain)
            (:requirements :equality)
            (:predicates (disk ?x) (smaller ?x ?y) (on ?x ?y) (clear ?x))
            (:action move-disk
             :parameters (?disk ?below-disk ?new-below-disk)
             :precondition (and (disk ?disk)
                                (smaller ?disk ?new-below-disk)
                                (not (= ?new-below-disk ?below-disk))
                                (not (= ?new-below-disk ?disk))
                                (not (= ?below-disk ?disk))
                                (on ?disk ?below-disk)
                                (clear ?disk)
                                (clear ?new-below-disk))
             :effect (and (clear ?below-disk)
                          (on ?disk ?new-below-disk)
                          (not (on ?disk ?below-disk))
                          (not (clear ?new-below-disk)))))

For a non-s-expression domain specific language on top of Lisp see for example PWGL. It uses a graphical language. Also Macsyma/Maxima, and many many many others.

From the outside, my interpretation of that is "I don't value my own opinion enough to make it accessible to users of other extremely common browsers."

I assume you blog because you feel like you have something to say that's worth reading. Making that content inaccessible to a very large segment of the browsers/users in the world works contrary to that. (I do sympathize with the PITA factor.)

I've got a few places where I simply block IE with stylesheets myself.

  <!--[if IE]>
  <link rel="stylesheet" href="http://atomized.org/wp-content/themes/atomized2/ie.css type="text/css" media="screen">
  <![endif]-->

switch (var) {

    case "foo":
        printf("foo block.");
        break;

    case "bar":
        printf("bar block.");
        break;

    default:
        printf("Default case")
}

$ cat foo.c

    #include <stdio.h>
    main() {
        const char *foo = "bar";
        switch (foo) {
            case "foo":
                printf("foo\n");
        }
    }

    foo.c: In function ‘main’:
    foo.c:4: error: switch quantity not an integer
    foo.c:5: error: case label does not reduce to an integer constant

I'm aware that you can't do this.

I guess my sarcasm didn't translate:)

XML is full of prefix, nested syntax.

'Water':

    <defmethod test_true source=required="ek_string"> 
     <try <if> source.<execute_string/>.<not/>   
                 <concat "Busted: "source/>.<print/>
               else “OK”
          </if>
    
       >
      <concat "Errored: " source/>.<print/>
     </try>
   </defmethod>

Whether or not the people who wrote (sorry, I guess "designed" is the more appropriate word) these languages were serious, I do believe they are a dead-end.

[1]: http://www.lispworks.com/documentation/HyperSpec/Body/m_case...

This article is a pretty nice down to earth point by point explanation why list is so cool. My question is: is that it ? lambdas, data is code, dynamic programing.. I mean those features are cool, but could someone post some more clear examples of why lisp is awesome?

The claim is that Lisp is a language at a higher level of abstraction. You will have to study hard to be able to appreciate that level, but it cannot be explained in another way.

Imagine explaining Calculus to a high school Physics student. You're likely to get back: "But I can find the acceleration of an object by using normal algebra and subtracting its position at two different times!" Calculus is hard, its benefits are not clearly better than approximation or high school algebra until you reach a level at which you brain thinks of Calculus as fundamental and sees the old equations as merely derived, less-powerful versions.

Why would you expect a mind-expanding language to be any easier to explain?

http://wiki.alu.org/RtL_Highlight_Film

http://www.defmacro.org/ramblings/lisp.html

"""What would you rather do? Learn 16 different languages and frameworks in order to do "simple" log-file and configuration-file processing? Or just buckle down, learn Lisp, and have all of these problems go away forever?"""

http://steve.yegge.googlepages.com/the-emacs-problem