My experience was having used Mathematica years before I ever saw LISP, or really knew anything about programming beyond C & F77. A REPL, functional programming, lists, etc. -- it was pretty mind-blowing.

Now I know that none of those things were invented by Wolfram (the company or the man), but they were put into productive use, in a very slick and beautiful application with a slew of symbolic and numerical math libraries which were world class.

I guess to a large extent, you're not missing something, but the libraries are comprehensive, well designed, well documented, very consistent and reasonably intuitive.

Similar experience here. I didn't do CS in college but used MMA a fair bit. Then ended up programming for a living in mainstream 90s languages. So when FP started to make a comeback recently it just hit me that "Hey this is just like Mathematica". But even then the Mathematica environment was better in ways than what you get with some FP languages now. I don't get all the retro fetish. I know my vi but I've no wish to use it over a good IDE. Hopefully Light table can do it for a functional language.

I don't know, but to me most of the power of Mathematica is basically the wide-ranging and compatible utilities. Not having to write my own basic math functions, nor spending hours trying to get some C++ package working, is huge.

Yeah, but wasn't this sold as something qualitatively new?

Yes. The language in itself isn't that interesting, but the collection of libraries is vast and mostly world class.

> To me this looks like a Lisp variant with a large set of utility libraries.

I feel like I'm missing something because I read this a lot, but don't see it when I look at Mathematica. The language seems to be a higher-order, functional programming language with dynamic (?) typing. That part sounds like lisp, but syntactically it looks nothing like lisp to me. Is there a portion of the language that I'm overlooking?

Technically the language is a Term Rewriting System[1]. You can use it as a TRS by directly manipulating transformation rules, in a functional way, in an imperative way, and of course as pure symbolic mathematics.

It does naturally suit functional thinking, so that becomes the default 'best' way of engaging with it.

[1] http://en.wikipedia.org/wiki/Rewriting#Term_rewriting_system...

Thanks. I think I knew this years ago while spending my off-work hours delving deeper into programming language history and theory, but most of that info is now lost from disuse. Like I said to your sibling post, I see the semantic comparisons, I just don't get calling it a "lisp variant", unless we're going to call every language with somewhat similar or derivative semantics but wildly different syntactical structures and additional semantic constructs lisp variants as well. With that, distinction between languages (primarily for conversation and discussions) becomes virtually non-existent as we could probably come up with a half dozen categories that all languages fall under.

Interesting. And after looking at Mathematica (the language) more this morning, I can see the influence of Lisp and other languages. I think my definition of "lisp variant" is stricter than others' definition. I wouldn't consider Rebol, TCL or Ruby "lisp variants", even though they both derive a lot of language concepts from the lisp family. So I can't really consider Mathematica a lisp variant either.

Put it in any bucket you like, but don't ignore it. Mathematica is absolutely worth studying. If you've never used a general purpose term rewriting system before, you're missing out on some mind-altering stuff.

I'm not ignoring it, I used it years ago in grad school, it was fantastic. It just has no relevance (as a tool) to my current work or sideprojects. My question was strictly about calling it a lisp variant.

i think you're right that the "essense" is not lisp. Mathematica is more abstract than lisp, and it has lisp-like features built on top of it. that said, the analogy can be useful because things like "macros" are completely natural to the language:

    In[1]:= FullForm[a + b]
    Out[1]= Plus[a, b]

    In[2]:= a + b /. Plus -> Times
    Out[2]= a b