Yeah, I've used it quite a bit and would consider myself an intermediate user. It's a very pleasant language to use (everything is an S-expression underneath, and computation happens via "term rewriting") once you get used to it, but it's declarative nature of programming makes it similar to eg. Haskell/Lisp and quite different from eg. Python/Matlab. It's basically unmatched for symbolic manipulation and algebra, so it's very popular among theoretical physicists (that's how I encountered it).

My only gripe with it is that it's not open/free (as in freedom), so the platform is limited by Wolfram's imagination (and different pieces don't always compose nicely, unlike say, in Julia) and I don't want to become dependent on a computing platform whose future is murky (bus factor of one, at least from what Wolfram takes credit for). Otherwise, I wouldn't mind paying for a personal use license and using it more.

Played with it during Advent of Code. It really disappointed me. The first 10 minutes of discovering the language were great--in theory it had so much potential between how errors automatically propagate up, the extensive library, and metaprogramming abilities of the language. The syntax is unconventional and to a certain degree off-putting (coming from a person who doesn't mind Erlang, Prolog, Lisp, Forth, Haskell, ...) but usable. The novelty starts to fade when you realize how poorly suited it is for general purpose programming. Despite having features for everything, it's hard to make them all connect. I spent hours trying to figure out how to use the DFS functionality in remarkably simple ways, for example. Maybe it was the documentation that failed me, but that doesn't really help sell the language either if that's the case. I think if Wolfram actually cared to "come down to earth" and think about users it could be a great language--the potential is definitely there--but right now it really looks like he jumped the gun with marketing and left out a lot of the important groundwork.

It really is well-designed and pleasant to use for the sort of programming that scientists and (real) engineers do. Not just symbolic math, but any kind of technical computing, done at least partly interactively, on a single powerful machine.

Stephen Wolfram actually is very good at designing a programming language and standard library (and he does personally oversee most of it). A lot of work has gone into picking the right set of functions to provide at the right level of abstraction.

Tools are provided to avoid a lot of bullshit; like there are just functions "Import" and "Export" which mostly work automatically and can read and write to all kinds of bizarre file formats. You don't need to go dig for an unmaintained library on pypi.

It's also probably the most visually pretty programming environment you can use, which ended up being more important to me than I would have expected.

The licensing cost doesn't seem like such a big downside to me, because it is probably worth $115/month for someone who would use it. Obviously much cheaper for academia.

The closed-source aspect is a bigger problem; if it doesn't do quite what you want, you really are out of luck, and there's no way to crack it open and make a small change or see what's happening. On the other hand, most of the target market (engineers and scientists who only write code to produce something else they want) would never do that anyway.

Support for machine learning used to be nonexistent but is now pretty good although a little more opaque to the end user than it ought to be. Somewhat separate from that, they have a set of Keras-esque neural network facilities which is extremely good in terms of design and usability.

As for the gee-whiz features, mostly they aren't that useful, unsurprisingly. The feature to translate inline natural language input to expressions of code (done with Ctrl-=) is surprisingly nice for small things, however, because it can handle dates and times really easily.

I like to play with the subset implemented in Mathics. It's not a bad language. As people have said, it is basically Lisp written in bracketed M-expressions rather than S-expressions.

Yes, I've taught with it in a multivariable calculus class. It's pretty easy to learn, and by the end of the semester the engaged students are doing amazing things. The notebooks are very useful, and will feel familiar to anyone who's used Jupyter notebooks. The language itself is what you would get if Python and all of the popular libraries were programmed by a single person with a common syntax and good documentation.

I probably wouldn't use it for "big data" analysis, but you can use it for just about anything else that is math or even slightly related to math- fluid dynamics, solving systems of equations, statistics, optimization, stock market charts, plotting values on a map, etc.

If you can get someone else to pay for it then it's absolutely worth the money- basically, if you're just a hobbyist then you probably don't need to buy it, but if you need to calculate integrals for your job then you need it.

I realize I've said mean things about Wolfram's attitude before and that his isn't actually revolutionary, but it's still a great product. Kind of like how you can't really call an iPhone X revolutionary, but it's still really good if you can pay the sticker price.

A little bit, but fresh. Parroting some things too.

Pros:

(1) At surface it's mostly M-expressions variant, but underneath is term-rewriting system. This makes it, well, anything. Multi-paradigm is an understatement. Feels like a better layer of abstraction to float in than "code is data".

(2) That TRS has possibly biggest rule set in existence. I doubt anyone but Stephen has good idea of the breadth of it, but it just works.

(3) It's been around for 30 years (40, if you count SMP). Most notebooks from 30 years ago will run just fine on latest. This means it has good foundations. They're gonna add a LLVM compiler in there soon and so far they make it seem like just another day at the office.

(4) Did I mention the giant rule set? It had function for anything that came up on my plate, well integrated with everything else, and well documented (color-coded!), runnable examples and all.

(5) Notebooks and other facilities in the language/environment encourage exploration. I've barely begun working with it but I already used it thrice to solve some tricky problems. Porting that to whatever I use in production seemed trivial so far, once I groked it with a .nb first.

(6) You can simply reach out to curated datasets, and they're really impressive. I feel like they covered beginner level pretty well, as well as a lot of specialist areas, but there are holes in the "middle". This doesn't sound like intractable problem and it's only getting better. Playing with their neural net repository is something I look forward too.

(7) A lot of what would usually be boring boilerplate elsewhere (unit conversions, plotting parameters, etc.), here can be done via natural language input.

(8) Makes math look nice and readable.

Cons:

(a) Some areas grow neglected at times (i.e. graphs atm). But that sounds natural - this is a tree or a forest, not a flower.

(b) It looks usable for production as live system, but you better prepare budget.

(c) It's not open-source. You'll be hard pressed to know what's exactly happening under your code. As I grow older, I care increasingly less.

(d) You have to wait for updates for fixes/features.

(e) I'm afraid that if you don't have at least some inclinations towards science (vs. "programming"), you're not going to enjoy it. This is not a tool to maximize CRUD app output.

Remarks:

(I) After watching some streams by Stephen, I feel it harder and harder to justify attacks on his ego. He sounds like a really smart and sensible guy with enthusiasm of a child and huge ideas that may or may not pan out.

(II) "Computational" thing he's pushing for makes perfect sense to me. At even rudimentary level, I feel like end-game for math notation (or music, for that matter) isn't some prescriptions of Royal Society of Mathematical Notation, but exactly something like Wolfram Language is. And on high level, "mining computational universe" for actual practical stuff also makes sense. But we'll see. Feels right but far away.

It's great for experimental mathematics. Not so much for software engineering. Easy to write, hard to read/maintain, poor performance.

I came across Mathematica via Wolfram Alpha while studying for a Maths degree. I was quite astonished by its capabilities, and have been playing with it ever since.

For context I work full time in an industry unrelated to software, and have kids and all the chaos that goes with them, so have relatively little time to devote to programming. I need something that 'just works'.

I've always felt that I should enjoy programming, and have had several false starts including HyperCard and Eiffel back in the day. But Mathematica / Wolfram Language is the first time programming has actually clicked.

There are various aspects to the Wolfram Language that make it work for me;

- The documentation is enormous, comprehensive and even editable and executable (desktop install). I haven't seen anything that comes close in any other language (Racket would probably be a distant second). In the snatches of time I have, all the information I need can be found using the F1 key, I don't have to waste time going to Stack Exchange and asking others for help

- The concept of everything being an M-expression makes the language very logical. Sub-expressions can themselves be evaluated and understood, larger expressions built out of smaller ones etc

- Lots of syntactic sugar IMO makes the M-Expressions more readable than Lisp S-Expressions, while retaining their usefulness in making code understandable

- Very powerful pattern matching and structural operations on expressions, which are great tools for manipulating expressions and extracting code or data

- Strong support for functional programming, which I find to be more enjoyable than procedural programming

- The language is symbolic, which often allows you to 'play' with programs and understand how they will work in an abstract way before using with real data. As a toy example you can literally fold an abstract function with abstract expressions, e.g. inputting Fold[f,x,{a,b,c,d}] returns f[f[f[f[x,a],b],c],d].

- a huge standard library built in, all working in a way that is remarkably consistent for such a wide diversity of domains, and a language that has been in development for 30+ years

- interactive notebook programming allows me to document my notes and progress along with the code

I did try a few FLOSS options primarily for access to their communities and also ease of deployment (e.g. F#, Clojure, Java) but haven't found anything comes close for my particular needs. I suspect that Racket would be the next best thing.

I think the Wolfram Language does suffer from the Lisp curse, in that it is sufficiently powerful and well documented that individual developers can go a long way without recourse to a community, which in turn hence hinders the establishment and growth of such communities.

I would strongly recommend spending some time learning the fundamentals of the language. My favourite resource is Paul Wellin's An Introduction to Programming with Mathematica (2013). I suspect a lot of the criticism of Mathematica comes from those who haven't learnt the fundamentals, and expect it to work like Python or Java etc, when in fact it is more like a cousin of Lisp.

I had never heard that explanation of the Lisp curse and it is very insightful; thank you!