Mathematica 14 | Hacker News Reader

Mathematica 14

writings.stephenwolfram.com

201 pointsyurivish144 comments

Mathematica is probably one of the biggest and most complex commercially available applications that still has an artisanal/craftsman made quality about it.

It’s something special. Maybe a bit of a relic in its distribution (not open source, not that SaaSy), but it’s so well thought out.

I enjoyed using Mathematica at work and grew quite fond of it. After the project concluded, I was keen to continue using it for personal projects, so I invested in the "Home" edition. Although it was not inexpensive, I quickly discovered it had certain limitations, such as a restricted number of computational kernels. There was also a limitation on how many personal computers I could use it on (even one at a time!). Another annoyance was the license manager, which required an internet connection – so I wasn't able to use it on an international flight (this was a while ago). I once suggested that a company I worked for should adopt it, but the license cost was prohibitively high, at over $3,000 per user.

To sum up, it's a great tool, but you'll need to invest considerable time to master it. Then there's the risk that this time could be wasted due to its expense.

Buy a Raspberry Pi. The Pi OS comes with a free copy.

Mathematica is what I thought a computer would be like before I could really use one: A tool for arithmetics and math. Instead we get text processing, kitten photos and porn videos. Not that I have anything against either of these, but it was still a mild shock to find that the `ln` command does not, by a long shot, compute the natural logarithm in Unix. OK, even Mathematica makes me alias `Ln` to `Log`. So much for the principle of least surprise. Still, given that you need extra software to make your computer actually compute, Mathematica is my tool of choice.

`Ln` isn't a built-in (and is syntax-highlighted as "undefined"), and searching the docs for "Ln" (or looking up the symbol with F12) gives as the first hit "Log: Log[z] gives the natural logarithm of z (logarithm to base e)". Given that in my experience mathematicians use "log" rather than "ln" (who uses base-10 logs in mathematics anyway?), is there any possible way they could have made this less surprising?

> Who uses base-10 logs in mathematics anyway?

Any applied mathematician working with decibels (as in acoustics, electronics, optics, ...), for example.

>Given that in my experience mathematicians use "log" rather than "ln"

I really don't know anyone but statisticians who do that. Everyone in my department (mathematics) and ever I've ever worked with has always used just "ln" for the natural logarithm. Why wouldn't you, it's one less character?

When it’s about Mathematica I want to share this excellent codegolf question that seems to imply that Mathematica has a built-in IsGoat function: [1]

[1] https://codegolf.stackexchange.com/questions/71631/upgoat-or...

More accurately: Mathematica has built in and/or automatic access to object data like animals, geographic info, and statistical figures of various things. You can then use these objects in other functions to answer questions like "How similar() is this to a ${goat}" (actual syntax very different) without having to manually code the glue for similar to understand things like animal objects yourself.

That the symbolic nature of the program carries past the pure mathematics is one of the most useful things about it.

All: Please let's not do Wolfram Derangement Syndrome in HN threads. It was already a cliché here a decade ago: https://hn.algolia.com/?dateRange=all&page=0&prefix=true&que... (and off HN, long before then). I've done the "stub for offtopicness" thing and moved the existing subthreads here: https://news.ycombinator.com/item?id=38972599. Please don't add more.

What is Wolfram Derangement Syndrome?

He's a polarizing figure for some. Some people like to use the news about Mathematica to debate some of Wolfram's other work in physics or whatever. He's done quite a bit of work so there's lots to debate.

> What is Wolfram Derangement Syndrome?

He writes a lot about himself in every article and makes claims that others find excessive. Commenters get triggered by this and post about how annoying it is. These reactions are just as predictable and just as fixated on Wolfram himself as he is, and in that sense are guilty of the same thing. This repetitive dynamic is what I mean by Wolfram Derangement Syndrome. It has been tedious—and therefore off topic—for many years. Here are a few past explanations in case helpful:

https://news.ycombinator.com/item?id=10978871 (Jan 2016)

https://news.ycombinator.com/item?id=10723588 (Dec 2015)

https://news.ycombinator.com/item?id=20071283 (June 2019)

There's often a lot that's interesting and thoughtful in Wolfram's pieces, stuff that's worth discussing on HN, so this is really a test for the community: can we mask out the predictable bits and focus on the interesting ones?

A few years ago, we added a guideline to https://news.ycombinator.com/newsguidelines.html to cover cases like this: "Please don't pick the most provocative thing in an article or post to complain about in the thread. Find something interesting to respond to instead."

> Commenters get triggered by this and post about how annoying it is. These reactions are just as predictable and just as fixated on Wolfram himself as he is, and in that sense are guilty of the same

I agree with the gist of your position, but the wording here is inflammatory (suggesting people are “triggered” rather than justifiably angry) and are obsessing over a man when in my experience his history of similar behavior goes back far longer and is exaggerated a lot more by his much stronger influence than the average hn commenter. I agree that it’s not interesting discussion, but people are largely trying to practice skepticism with a man who makes very exciting claims and sometimes isn’t being entirely honest about those claims or where they originated.

Basically, there is missing context that hn comments aren’t capturing that can help to understand this resentment towards him and your post here seems to be ignoring some of that context and equating the two sides when there is a large power disparity between them.

Edit: Also the choice to coin this phrase as a “derangement” feels inflammatory as well.

Yup, I get how my comment could feel inflammatory to those who feel that way about Wolfram, and how the words 'triggered' and 'derangement' might push on sore spots. I'm sorry if it rubs the wrong way—I know these things can land in unpleasant ways, and that's not what I mean to do.

I do mean to exhort the community a bit when I post like that. From the HN point of view, it's not interesting to talk about Wolfram's egoic tics because there's nothing new to say or learn about it. It's simply a recitation of old resentments that have been circulating since before HN existed. We ought to be able to recognize this and turn our attention to more interesting things—and Wolfram does usually have more interesting things to say.

This is by far the most detailed announcement I have ever seen.

I find impressive the breadth and depth of Wolfram's writing. I wish I could be that productive and write that much. Nevertheless, it's exhausting to read him because his texts are full of hubris.

This man needs to learn to edit himself.

Honestly someone should just suggest to him to feed his work through an LLM to dial it down. He might actually go for it.

With kindness and nonzero envy: Should we expect any less from a man who affixes a laptop to himself so he doesn’t have to stop typing to go for a walk?

(I am really really hoping Apple Vision Pro makes this easier, and that someone gets round to keyboard-gloves so that you can type with your arms by your sides! I saw a project for this just today, called "wandering.computer", but seems very early-stage.)

I wonder how many people actually use many of the newer features. It seems there’s always new data sources and niche features, but I imagine it’s not deep enough if you work in the field [e.g., chemistry or astronomy].

For me it’s such a shame as I would definitely use it much more often if the language and environment were closer to a typical coding workflow. It’s just such a hassle to have to use a standalone desktop engine, a weird editor, and a quirky language [at least at first] with few 3rd party libraries.

I remember Mathematica was included with the distribution of the OS for Raspberry Pi. I also remember it being so slow as to being unusable. I guess, you get what you pay for…

You can install a free (as in beer) Wolfram engine on any computer, e.g. a beefy virtual machine: https://www.wolfram.com/engine/

Yada yada yada - can you straightforwardly create LLMs with it?

just in time for my subscription to have expired, too.

stephenwolfram.com

Ask HN: I've never met someone who uses Mathematica, I imagine its users are even rarer outside the academic circles. I've met many who use Matlab, R, Python, Excel, etc.

If you're using it, what are you using it for exactly? In what way is it irreplaceable by other tools out there, if at all?

Symbolic computation. Yeah, I guess you can do it in SymPy, but it's more painful.

It's a really pleasant environment for certain type of work.

The only thing missing is better type systems.

How does it compare to Lisp for symbolic programming?

A lot of Lisp constructs like map and apply and macros have dedicated syntax in Mathematica, so they feel more like a fluent language. And the standard library is very large and impressively self-consistent. The default format is notebooks which helps make your work presentable.

Mathematica is basically the M-Expression version of lisp that never developed. The real power isn't just in the symbolic capabilities but the mathematical library.

My understanding (from people who properly learnt Mathematica, and understood the language) is it is a lisp, but it's never taught that way, never explained, you're just searching for the magical function that does the thing you want.

When people speak of "symbolic computation" in the context of mathematica, it's usually not about the Mathematica programming language itself, but rather about using Mathematica to do symbolical mathematics. A bit like how you did math with pen and paper in high school or university, except having Mathematica do all the hard stuff.

Lisp is at its core an evaluator for expressions. The routine for that is called EVAL.

Mathematica is a computer algebra system at its core and is a rule-based rewrite system for expressions.

An example in Lisp notation:

In a computer algebra system (CAS) one may enter 5a - 2a

  > (- (* 5 a) (* 2 a))

The CAS would answer with:

  (* 3 a)

It has used rules to simplify the expression and uses some default form. It could have printed a + a + a or 3 * a. It sees that it can't further simplify it, because a has no value and thus returns this simplified expression as it is.

In Lisp things are differently. It takes an expression and tries to compute a value:

   > (- (* 5 a) (* 2 a))

The result in Lisp is "Error: unbound variable a". It can't compute a value, because during evaluation it sees that the variable a has no value. Evaluation of the unbound variable a is an error.

Now you could write an expression simplifier in Lisp: let's call it simplify. Lisp has a quote operator, which returns the embedded thing as it is -> it is not evaluated. We can embed an expression inside quote and thus call simplify with that unevaluated expression as an argument.

   > (simplify (quote (- (* 5 a) (* 2 a))))

The result then could be

   (* 3 a)

One then could write a input loop in Lisp

   (loop (print (simplify (read)))

which then would not be a read-eval-print-loop, but a read-simplify-print-loop.

   (defun read-simplify-print-loop ()
     (loop (print (simplify (read))))

This interactive loop would read expressions and print simplified expressions...

Actually something like that has been done with computer algebra systems written in Lisp, like Macsyma/Maxima and Reduce. But they also then switched to infix syntax for input/output to make it easier for humans to enter mathematical expressions.

Peter Norvig gave in his book "Paradigms of AI Programming, Case Studies in Common Lisp" extensive examples how to implement such a thing in Lisp:

https://github.com/norvig/paip-lisp/blob/main/docs/chapter8....

and

https://github.com/norvig/paip-lisp/blob/main/docs/chapter15...

The advantage of the Mathematica language compared to Lisp is that it can compute with expressions via rules out of the box. Additionally Mathematica is so much more than that: it is an environment, a collection of mathematical knowledge, a cloud service, a specific product on can buy/rent, ...

The drawback is that the semantics are murky and Mathematica is a two-language system: the fast internal code (and much of the environment) is written in C++ and the expressive language is on top.

Lisp OTOH is often much more efficiently compiled with clear(er) semantics.

> In a computer algebra system (CAS) one may enter 5a - 2a

> > (- (* 5 a) (* 2 a))

> The CAS would answer with:

> (* 2 a)

Not sure I'd want to use such a CAS. Hint: 5-2 != 2. ;-)

Thanks, edited!

I’m big on types and am sympathetic to your last point, but wouldn’t introducing types in any nontrivial way break compatibility on a catastrophic scale?

I mean it can be gradual. There already are ways of compiling functions which require type annotations, just make those less of a pain in the ass.

Find it pretty helpful as a math-adjacent academic. It's great at coming up with counterexamples to inequalities with FindInstance. I don't know how irreplaceable it is, but in general I find the UI for manipulating symbolic equations nicer to use than anything else I've tried.

It’s certainly the best of the symbolic computational tools that I’ve tried. However, my problem with such tools is that that they work great for simple examples in my experience but scaling them to work with non-trivial systems is rough. It may be user error on my part, but the path between simple and complex is non-obvious.

I wonder if LLMs will provide a robust path from the solid symbolic computation of Mathematica to production or productionizable code. I've seen stories show up on HN about using LLMs to e.g. transform Cobol -> Java, and have my suspicions about how and where that kind of translation could fall down with today's LLMs.

Nevertheless, I assume LLM enabled translators will improve rapidly, and that a product like Mathematica could be very well suited for translating from a prototype to a robust implementation for e.g. HPC.

Its "batteries included" philosophy (well, more like the entire power plant) – for example, very convenient and broad visualization and declarative UI libraries; very good online documentation as well; of course, the OG interactive notebook interface, too.

If the cost of that is shining Stephen Wolfram's dome, well, what can you do.

I'm a software developer and use it for one-off tasks like image processing (create an SVG from a folder of images), quick visualization of data (read a giant JSON file and create bar charts from certain keys), file preparation, and much more. It's taken me several years to really feel like a power user, where I intuitively know which functions to use and how to compose/customize them. When I worked at Wolfram Research (over a decade ago), I even made a proof-of-concept for programming Arduino microcontrollers and controlling them directly from the notebook interface.

It's a powerful tool with a steep learning curve - hopefully the LLM assistant will help with this.

I used to use it when I was at University and I kept a copy around for nostalgic reasons. Once in a blue moon I get an excuse to use it for work related reasons, and then I gleefully spin it up just so I can pretend to be a real mathematician / scientist type person. Generally this is superfluous, but I do it anyway, otherwise my tertiary education feels like a waste of time and money.

Other times I use it as a replacement for a calculator app, which feels exactly like cracking a walnut with a 500-ton industrial press.

It does have some reasonably unique capabilities that I did use more heavily in the past. E.g.:

- Simplifying the vector/matrix mathematics used in 3D graphics. It can eliminate redundant expressions, which is especially useful when you know that some of the inputs are constants such as 0 or 1.

- Non-linear curve fitting. If you have some complicated mathematical model you want to fit to noisy data, Mathematica will "just do it". With every other tool out there, this is... sss... hard.

- It missed the AI boat, but it has mostly caught up and could now be a viable alternative to the Python-based AI ecosystem, especially for certain areas of research.

- Complicated plotting requirements where I just can't be bothered spinning up some dedicated log analytics "tool" or subscribing to a "cloud service" and learning an entire query language just to draw a 3D histogram or whatever.

I've seen some people use it like you would use Matlab, R or Python (I wouldn't recommend it...), but it can (mostly) do symbolic stuff quite easily. I've seen it used in maths and physics, mostly by theorists. If you've made it part of your workflow, I suspect it's irreplaceable, but the best way to think about it is its one of those tools that gets used because the topic is small/bespoke enough that it's hard to build a replacement without having all the existing features (there a number of these in physics/engineering).

Its biggest flaw is how much it wants to act as a black box, which means when something goes wrong, or isn't exactly what you want, you spend more time trying to fix it than solving the original problem.

I do.

I started using Mathematica in middle school and continued from there. My initial use case was simply double-checking I did my math homework correctly. A lot of Solve, DSolve, FindInstance, Reduce, FullSimplify, etc. I did a lot of plotting to visualize things: not just plotting functions of one variable, but parametric curves, inequalities, functions of multiple variables. When I studied linear algebra, I implemented Gaussian elimination myself as a learning exercise and I was very proud of it: the nice thing was that although the algorithm worked on matrices containing known numbers, it automatically worked for matrices containing unknowns thanks to its symbolic computation. When I studied basic image processing tasks like edge detection or the like, it was again of great help. When I got into personal investing, I did yet more calculations using the FinancialData function to retrieve financial time series and backtested many kinds of portfolio. When I got into trading options, it was of tremendous help to learn options from first principles, starting from the log-normal distributions, implementing Black–Scholes modeling, and then implemented the option greeks (delta, gamma, theta, etc) from scratch. Even as a regular software engineer, when I needed to work on algorithms, Mathematica is great help when I needed to do complexities analysis more sophisticated than interview-level big-O notations. I even used it as a SAT solver in a pinch, or a linear programming solver, when I knew there are other tools, but they won't be as nice as Mathematica or have higher learning curves than Mathematica's builtin documentation.

I used a bit of Mathematica but settled on Waterloo Maple because it had a cheaper academic license. Mathematica has stronger algorithms than Maple (like cylindrical algebraic decomposition), but for what I was using it for, they were both equally capable.

I was working on mathematical models (large scale optimization). These are usually solved numerically, and in numerical mathematics, how you write an equation matters tremendously (for instance, the equality x/y = z is much worse than x = y * z for solvers especially if y is a variable that can take on 0 as a value because during iteration this might create a lot of NaNs in your Jacobian or Hessian matrices).

I was using symbolic math to find better (but mathematically equivalent) ways to pose equations that would be numerically expedient. One example is using Groebner bases to do the equivalent of Gaussian elimination on a system of polynomial, which produces a row-echelon form and has many nice properties.

I use it for hobby tinkering, it's quite fun to play around with. Excellent documentation, best-in-class symbolic capabilities, great visualizations/charting, everything you need is in the box (no fussing with dependencies). And once you get the hang of it, you feel very crafty doing complex functional-style transformations with minimal code.

For example, my house experienced some flooding last year after exceptionally heavy rainfall. But how exceptional was it, really? I pulled out Mathematica and in a few minutes I had an interactive chart showing historical rainfall stats for my city over different time periods. The charting, interactivity, and weather APIs were all just built in.

Can you post a code snippet for that plot, if you still happen to have it?

I don't have that one handy right this minute, but I just remembered that I did a different weather exploration with Mathematica about a year ago.

I had a hunch that Ironman triathlon was advertising their races as having cooler weather than they actually do. Turns out I was right -- here's my [slowtwitch post](https://forum.slowtwitch.com/forum/Slowtwitch_Forums_C1/Tria...), and the [associated code](https://gist.github.com/latkin/470a2f06056ee0a8e3f4da837af10...).

It is a very integrated environment with access to lots of mathematical tools. It is just a very nice and polished tool. I often just start it up to use it as a calculator!

AFAIK physicists use it very heavily, but I barely know any mathematicians use it. To me this is a great tool for people who use Math heavily as a tool but not study Math itself.

I use it for symbolic calculation, solve differential equations, and many complicated integrals, and its visualizaion build upon those with easy parametrize support is very nice. Starting from my ungrad sophomore year as physics major, we have courses require us to finish some homeworks with Mathematica.

I can hardly find any other tool to replace mathematica in terms of symbolic calculation and doing complicated integrals (there is a joke by calling mathematica "large-scale integral table")

Agree, Wolfram Alpha is heavily used by some students of physics to do their homework. We sometimes joked that was the main purpose of the service.

Mathematicians probably have trust issues and use tools with a code base that is 3 orders of magnitude smaller.

Imagine jupyter notebooks with a nice lispish language and the most complete standard library ever developed. Haven’t used it for almost 15 years, it was great back then, nowadays when I need something more than a simple calculator I go to wolframalpha - it’s basically Mathematica, but with one line of input instead of a notebook.

It's noteworthy that Mathematica invented the notebook UI that Jupyter ended up popularizing.

It has some strengths, but since its syntax highlighting is coupled to the kernel state it didn't have an undo function for the longest time. Also as big vim fan it's disappointing to not being able to use your favorite editor.

Emacs has EIN which allows you to edit and run Jupyter Notebooks. Combining that with a vim keybindings mode like Evil, you can use vim bindings on notebooks.

Edit: The github page for EIN says that development has stopped. Despite this, I was able to edit a notebook with only minor inconveniences very recently.

An actively developed alternative is emacs-jupyter, which allows you to use an org file similarly to a notebook.

No. Incorrect. There was a precursor that had the idea Of notebook but didn’t call it that. By your logic Wolfram invented symbolic computation, Computational complexity and many other things. Let’s Not go down that route please.

Mathcad has the notebook metaphor (calculations embedded in live formatted documents) by 1986. Mathcad predates Mathematica by 1 year. [1]

[1] Mathcad 2.0 Ad from 1987, the oldest I have found in 10 min. https://books.google.es/books?id=sc4TnHAYBSUC&pg=PA42

Thanks for looking into it. Yes this is correct. Knowing what I hear about wolfram, even if there is a record in history wolfram claims He is the first.

I may have been incorrect because it's hard to know about everything and I have no issue to stand corrected, but please do not attack my logic by building strawmen. You could have simply stated the name of that predecessor, ideally with a link.

The basis my comment for this was this thread: https://news.ycombinator.com/item?id=22278637

Unfortunately the Atlantic article is now paywalled.

Archive from 20220805:

https://archive.is/4l509

Don’t trust the PR coming out of Wolfram. His wiki entry was paid for, his puppets on the net do the rest propogating disinformation And misinformation. He has connection to writers from New York Times and others.

It's a great tool when you are a jack of all trades, master of none, though oftentimes better than master of one. You can use to decode phase-modulated signals, calculate stress distribution in some mechanical part, get an idea of how the orbit of a particular asteroid will look two hundred years for now, or just make a diagram of a set of events, among many, many other things.

Background: I did a PhD in computational physics.

Starting as an undergrad, I extensively used mathematica to help or double check homework problems, plotting functions etc. For more "numerical" type of work, we extensively used matlab, so typically we used mathematica for more symbolical type problems. Later on, when working in physics, I often used mathematica, again mostly for doing things like symbolical integration, or things like quickly calculating symbolical gradients that I could copy-paste into some numerical software etc.

I no longer work in academia so I don't have access to a mathematica license, but similar free tools are Sympy, Maxima, which are good for basic stuff but in my experience are not nearly as good as Mathematica for more complicated stuff. Or just the online wolframalpha.

Wolfram would like to say that he invented Mathematica all by himself, but in its core, it is basically a lisp: everything is an expression, and mathematics are just transformations of the expressions. Afaik this makes it the best tool (conceptually and practically) for generic symbolic manipulations. For example, `1 + 1` in Mathematica is just syntactic sugar for `Plus[1, 1]`, and `a = 1` is `Set[a, 1]`.

I am a PhD student in theoretical physics and almost everyone in our field has no choice but to use it (I do know one or two people that use maple, but the overwhelming majority chooses mathematica).

Despite its elegant design, many people hate it with a passion, as it has grown to be a huge bloated mess that takes forever to run. Also, due to the closed source nature, it is very hard to debug when something goes wrong. For example, it is quite often for the basic functions like `Simplify` and `Integrate` to get stuck running forever, but there is no way to keep track of the internal transformations that mathematica is doing, since everything is sealed up.

Re "it is a lisp" and "everything is an expression", I would like to add a bit of clarification.Or, given that you use Mathematica regularly while I was just reading surface docs (for purposes of doing some stuff with Wolfram Alpha), rather a question if my perspective is well-founded.

Based on my understanding of how expression evaluation works, the slightly more revealing statements would be "it is a lot of lisp macros" and "everything is an s-expression". Which means, a big mess. Let me expand:

As a functional programmer, "everything is an expression" sounds comforting, and I would expect there are clear transformation rules on how expressions are evaluated (and, maaybe, type signatures).

Instead, what you get is, "you can throw in some random form of expressions into this function, and it will do something with them". As in, it takes an AST input, and transforms them in some loosely specified way. There doesn't seem to be a type system, so you don't have types to guide you, rather you likely need to figure what kind of expressions work with which functions.

Now, if I'm wrong about this, and the functions behave consistently in what they take and how they transform it, then I'm more than open to be corrected. It is just that my high expectations (based on marketing of the lang) and the subsequent realization left me a bit bitter.

These are all valid criticisms. There is no type system, although some safeguards can be implemented through pattern matching and conditions (see the answer by @derf_ above). For quick and dirty transforms on symbolic math expressions, these are often good enough, but it is indeed a mess to use as a full fledge programming language.

I do like that the lispy language itself closely mirrors math expressions, and it is consistently accessible throughout the user interface. For example, the mathematica notebook frontend (IDE) is simply some `MakeBoxes[]` of the expressions, which are all valid mathematica code themselves. I tried sympy a while ago, which I believe took an object-oriented approach, and it was very clumsy when compared to mathematica.

Still, I would not recommend using mathematica for general programming, precisely because of the mentioned shortcomings. By default, it is also impure and not lazy (eager eval, although it can be forced to be lazy on a case by case basis using `Hold` or `Unevaluated`).

It is possible to put filters on function arguments, e.g., the definition

    f[x_Integer] := ...

will define a rule for f[] that only matches expressions where the argument to f[] has the head "Integer". It is even possible to use arbitrary predicates:

    vec3Q[v_] := VectorQ[v, NumberQ]&&Length[v]==3
    f[v_?vec3Q] := ...

This lets you sort-of have type-checking. This is entirely opt-in, so you have to be somewhat rigorous about its use or it does not do any good. Also, in practice if any invocation of f[] does not have arguments which match the types for which you have defined it, the expression just remains unevaluated, which can create a mess (but maybe less of a mess than evaluating the function on input of the wrong form). The performance impact (particularly of the predicate version) is also non-zero, but my experience is that the biggest performance limitations come from trying to keep your machine from grinding to a halt when a runaway expression applied to the wrong thing explodes in complexity and eats all of your RAM... and this helps avoid that.

While I have found this to be very helpful for writing and debugging hairy expressions, I used Mathematica for years before I even knew this was a thing. In reality almost no one does this, certainly not with any consistency, and the situation is as bad as you fear it would be.

The language is a term rewriting language. https://reference.wolfram.com/language/tutorial/Evaluation.h... covers most of the evaluation process. The documentation for functions lists out the different forms they expect.

Lisp-style macros are actually difficult to write because of the infinite evaluation of the language. I was able to write a quasiquote package for myself to help with that that though.

It's really, really difficult to come up with a type system for mathematics. Let's just talk about Plus, the symbol for using the plus sign. What's its type? You might say it takes a few numbers and returns a new number. But what kind of number does it return? It is capable of returning machine precision numbers or their custom high precision numbers. It can return integers, rational numbers, real numbers or complex numbers, as the case may be. It is capable of working on lists of numbers and matrices of numbers, and it returns lists of numbers or matrices of numbers. But wait Mathematica doesn't require a list's elements' types to be homogeneous, so it can return different types of numbers for each element of the returned list. It is capable of working on completely undefined symbols, much like in real mathematics you expect a teenager to be able to reason about the expression `x+x+x` and simplify it to `3x` without knowing what `x` might be. It could very well leave everything the same, for example when you add two undefined symbols `x+y` and get back `x+y`.

So I personally think it is perhaps not productive to think about type systems and type signatures when working with Mathematica. But you can definitively think in terms of transformation rules. And Mathematica either documents these rules or makes these rules intuitive.

> I am a PhD student in theoretical physics and almost everyone in our field has no choice but to use it

I got my theoretical physics Ph.D. in 1987. I’ve never met anyone who uses Mathematica, except to try it out a bit out of curiosity. Perhaps you’re referring to a particular research group?

Ah, to be more precise, I work in high energy theory (hep-th): https://arxiv.org/archive/hep-th. I shouldn't have spoken for theoretical physics in general, but in hep-th, mathematica is basically a requirement (nowadays, can't say for 1987). I believe the same applies to high energy phenomenology (hep-ph) in which some fundamental packages (e.g. feyncalc) are written in mathematica.

That’s not one of the areas I’ve worked in, so that’s interesting to know.

You could replace the symbolic solving capabilities with wxmaxima[1] (which is free and opensource) and you would also find the linear algebra is waaay faster than mathematica, but the downside is maxima is weird and a bit user-hostile and its visualisation capabilities are kinda janky by comparison to mathematica which produces really nice visualisations.

[1] https://wxmaxima-developers.github.io/wxmaxima/download.html

I know that Citibank's foreign exchange market making desk was using Mathematica, at least they were 15 years ago.

It's unusual in the quant world though. I think they had hired a bunch of PhDs who had spent too much time in academia.

For solving math symbolically when Sympy and Maxima fail. I don't like it at all though.

I used it a lot in maths grad school for manipulating wretchedly large algebraic expressions. Just maths notation being well-supported and the interface for editing everything being nice made it the best tool for me. And it wasn't hard to use, not at all - bearing in mind I was just doing algebra. (This was all more than ten years ago).

The MIT Mystery Hunt starts today, and Mathematica is my go-to language and environment for puzzle hunts. As the saying goes, it's the second-best tool for everything. Fast iteration on ill-specified problems, trivial visualisation and interactivity and so on, an unparalleled range of built-ins to perform extremely complex tasks, building up huge blobs of personal state that you're going to throw away entirely in an hour.

I love Mathematica and I use it a lot. It's like what happens if you take Matlab, R, or Python (ie any programming language primarily used for math), and turn it into a real functional programming language. It's not irreplaceable at all, but it's a lot nicer than the alternatives.

It's generally pretty nice for any sort of mathematical programming, from designing control systems to statistics to simple graphing. It's also a pretty good language for basic scripting and data manipulation. Most of the mathematical work on my blog is done in Mathematica.

[stub for offtopicness]

> In the arc of intellectual history it defines a broad, new, computational paradigm for formalizing the world.

I am in awe of what Wolfram achieved with Mathematica. And also the size of their ego.

Are they wrong :) ?

I was honestly expecting Wolfram himself to have claimed the invention of LLMs or transformers, probably by saying it’s really a scaled up implementation of some other function in Mathematica.

Joking aside, he sort of implies this in his essay explaining GPT models[1]

    At some level this reminds one of the idea of universal computation (and my Principle of Computational Equivalence), but, as I’ll discuss later...

And his "Principle of Computational Equivalence" is [2]

    "There are various ways to state the Principle of Computational Equivalence, but probably the most general is just to say that almost all processes which are not obviously simple can be viewed as computations of equivalent sophistication."

Which a cynic might say is mighty convenient, because this is non-specific enough that you can apply it to basically anything and say you invented it and/or it's equivalent to something you invented and if it doesn't quite fit, you can use the "various ways to state" clause to weasel-word your way into something which does.

I find Stephen Wolfram frustrating for this reason. Benoit Mandelbrot is another guy who constantly seems to claim he invented everything, eg the Efficient Markets Hypothesis (which Mandelbrot basically claims he invented because he gave Eugene Fama some advice about the price process for stocks when Fama was a PhD student even though Fama/French was after that and Mandelbrot's idea of the price process for stocks is very obviously and demonstrably wrong if you know about market microstructure and/or look at trade marketdata[3]).

[1] https://writings.stephenwolfram.com/2023/02/what-is-chatgpt-...

[2] https://www.wolframscience.com/nks/p716--outline-of-the-prin...

[3] At a microstructure level price movements are made up of individual trades which jump around wildly with gaps in both the time and price dimension, and it has a base level beyond which you can't "zoom in" any more- it isn't some kind of fractal scaling in time and/or volatility which is what Mandelbrot wants it to be.

And the penny drops!

Thanks, I didn’t know he already did it. Totally on brand though.

Every mention of Stephen Wolfram deserves a link to Cosma Shalizi's epic take-down of a review ("A Rare Blend of Monster Raving Egomania and Utter Batshit Insanity"): http://bactra.org/reviews/wolfram/

What an amazing review-Thanks for that. It really brings together a lot of sad threads in my mind from that time. Having been the kind of guy who waited patiently for hours for home-made CAs to wiggle about on my VGA monitor and/or wrote little artificial life simulations etc for years in lonely isolation I bought "A New Kind of Science" with great expectation when it was in huge piles in every bookshop and was kind of devastated by how empty it was. I had really hoped for so much.

This is absurd and cannot be true.

Shmidhuber beat both of these guys easily with his paper from decades before these amateurs even claimed to start working on it.

And tehy didn't cite him. It's a travesty.

So what if he likes to put things that way, there is hardly any competition to Mathematica, in what it is capable delivering.

Yet many of those that complain about Wolfram, will idolatrate Steve Jobs, and they aren't (weren't) that different in praising themselves.

> It’s only recently that I’ve begun to properly internalize just how broad the implications of having a computational language really are—even though, ironically, I’ve spent much of my life engaged precisely in the consuming task of building the world’s only large-scale computational language.

Exemplar of humility.

It sounds like once you get the zen of Mathematica, it’s a truly exceptional tool to work with.

It’s a shame that the only person it seems has get the zen of Mathematica is Stephen Wolfram himself.

I mean, it really is good software. It's by far the best CAS around and the "standard library" is extremely impressive.

But like all software it involves tradeoffs. Fanatics of any technology or idea are never the easiest people to reason with.

Agreed, but what are the tradeoffs for Mathematica?

Mathematica has the best CAD capabilities for many/most tasks, but the language is rather horrible. E.g. code can not be commented, the program state is difficult to manage or even reset, it's very tied to the Mathematica "notebook". And it's quite idiosyncratic.

I sometimes have to use it where Sympy fails, and every time it's almost constant WTF.

And it's very proprietary and very expensive.

Note it's free on the raspberry pi!

https://www.wolfram.com/raspberry-pi/

If you have one collecting dust in a drawer, I'd heartily recommend checking it out.

check the license, though.

https://www.wolfram.com/legal/agreements/wolfram-mathematica...

> code can not be commented

Mathematica has a C-like syntax for comments

    (* this is a comment *)

but it doesn't have C++ style comments

    // This is a C++ comment

Actually those are Pascal-like comments. Pascal uses (* ... *) for arbitrary comments as well as { ... } for single line comments.

I stand corrected. For some reason I hadn't figured this out earlier even though I tried to find it.

> And it's very proprietary and very expensive

get free kernel and wljs notebook

Comes as a big monolithical block that's much harder to work with if you have to develop bigger systems, language tooling is lacking even compared to something like Python that's already mediocre, in many aspects (data analysis/data engineering, machine learning, etc.) isn't as good as other options like Python or R.

It's also not great as a general purpose language. It was never meant as such of course, but working in a real language where I can take stuff off a notebook and have it become a script has its advantages.

Finally, I'm willing to use open-source software that's slightly worse if the difference isn't huge, and for many use cases the difference isn't huge. For some it is, and that's where Mathematica is great.

It is a bit Zen, but if you don't use it for a few months you forget everything because the syntax is so different.

In his case the zen of mathematica is that people will write a slick function for whatever he is interested in at the moment.

Everyone else needs to deal with stuff like '#1 + #2 & @@@ # &/ @'.

Wolfram should get a dedicated title tag (Wolfram) and hn rules should be amended with ‘this dude is a bit full of himself, everybody knows that, no need to bring it up’

Saying that as someone who’s consistently surprised by just how big his ego seems to be, getting bigger each year, didn’t think it’s possible.

The admin has already decreed exactly that. People just love to whine.

Or, for that matter, just come together in community and crack jokes we can all agree on, at the expense of someone we all know. Call it A New Kind of Socializing.

When you've done as much as him any kind of ego that you may possess becomes justified.

This could be covered if there was a principle to respect the man in the arena. That should also discourage you-reinvented-the-wheel pile-ons.

The Ratatouille critic put this well - "We risk very little, yet enjoy a position over those who offer up their work and their selves to our judgement. We thrive on negative criticism, which is fun to write and to read."

Why are people getting hung up on his hubris? If his megalomania gives us Mathematica who cares. It's a phenomenal accomplishment. It can, out of the box, do hundreds of things that'd take you weeks in python/julia/etc or would be entirely impossible for most in other systems.

> Why are people getting hung up on his hubris? If his megalomania gives us Mathematica who cares.

We've had some bad results taking that approach recently - which we really should have anticipated, with millenia-old stories warning us about it. For one thing, megalomaniacs tend to be frauds (perhaps because, to be a megalomaniac, it's necessary to lie to yourself); maybe Mathematica will turn out to be the FTX, or Tesla auto-pilot, or ..., of mathematical software/languages.

No way - how could that happen? All those people at Mathematica would just go along with it, right? There's no evidence! It would be too brazen!

> We've had some bad results taking that approach recently

I'm struggling to believe that Wolfram's hubris is anything like that of Trump or Musk or SBF etc. Wolfram seems like a genuinely smart person who knows he's smart, but is probably too aware of it. But he's not done anything majorly bad - and arguably has done good in creating tools for scientists and engineers. I think we need to give him a break. I certainly think that the perennial discussion of his ego is tiresome and distracting.

> megalomaniacs tend to be frauds

Eeeh. Scott Aaronson review [0] and Cosma Shali's review [1] of NKS kinds of points to this direction, so he may well be a fraud. The plagiarism case regarding rule 110 (and attempts to hide this through NDA and lawsuits [2]) doesn't do him any favors, either. Indeed maybe the biggest problem of Wolfram isn't the megalomany per se, but the total unwillingness to give credit to others and cite their damn papers. Wolfram simply isn't in the business of sharing his bibliography, which is problematic for a scientist.

However, the newer Wolfram Physics [3] [4] looks so damn promising that I'm willing to entertain possible quackery. I mean it surely has many ideas regarding how a digital universe would look like; he may be all wrong in the details but his ideas look important contributions to me. I sometimes think what's like to be at the frontier of science; today we take relativity (for example) for granted but there was a time when it was up in the air. When I read Wolfram's stuff stuff I just think this could very well be true, and while there's absolutely no evidence for it the conjectures all make sense.

[0] https://arxiv.org/abs/quant-ph/0206089

[1] http://bactra.org/reviews/wolfram/

[2] https://news.ycombinator.com/item?id=13961947

[3] https://www.wolframphysics.org/

[4] https://writings.stephenwolfram.com/2020/04/finally-we-may-h...

Thanks for introducing some knowledge and fact to the discussion.

> However, the newer Wolfram Physics [3] [4] looks so damn promising that I'm willing to entertain possible quackery.

I don't know him, and clearly you know quite a bit. Still, that tradeoff is exactly where we've made our mistakes - the temptation of that payoff.

> maybe Mathematica will turn out to be the FTX, or Tesla auto-pilot, or ..., of mathematical software/languages.

You can install Mathematica at any time. It produces graphical output. You can see for yourself what it does, and what it does not do.

If Wolfram were making claims about a future unreleased version of Mathematica, sure, I would absolutely weigh his ego against those claims. But they are largely irrelevant when it comes to a currently existing and available product. If he were to claim that Mathematica 14 cures cancer, that would deserve eyerolls but it wouldn't tarnish the quality of the software.

Mathematica has been publicly available for 35 years now, this is the 14th release. The tool has worked extremely well and been tangible for decades, with the value during that period being in the customer's direct use. In what ways does this remind you of FTX or Tesla auto-pilot?

Well, he claimed that Mathematica, particularly cellular automata implemented in Mathematica, would bring about "A New Kind of Science" as described in his thick book of that name. It didn't of course -- people like to still play with cellular automata like The Game of Life (or my favorite, Wireworld), but no revolution in science involving CAs has occurred. The whole thing was a marketing ploy for Mathematica disguised as science. Not mention that the only truly new thing mentioned in the book (that CAs can be Turing complete) wasn't even Wolfram's finding, but rather Matthew Cook's (who sued him for not crediting it to him, although they have since settled).

That's still not very adequate comparison.

Musk has been promising self driving for... what 10 years now?

Hyping a working tool like Mathematica that will bring a revolution is a vague hope rather than a concrete promise of outcome.

Musk doesn't do this for you.

Notice the pattern, he does it to attract the kind of engineers attracted to solving 'unsolvable' problems.

Whether that's a good strategy is up in the air.

ah yes mastermind musk defense.

He is not 'lying' he is 'envisioning future to motivate engineers'.

He’s totally lying, just not to you.

Good engineers in specialized fields are really difficult to hire, this might not be apparent to people in the software industry.

Wolfram does lots of wacky stuff but how does it make Mathematica any less tangibly useful today? He can want to use Mathematica as part of eradicating cancer using toilet brushes and it would still not change that Mathematica is and has been an extremely useful piece of software for decades. The point isn't every single thought he has is gospel revolution it's that Mathematica is already a delivered value.

I heard this before, but never asked, what is so special about Mathematica that cannot be done by other softwares?

You should give it a spin. It’s an incredibly comprehensive Computer Algebra System with all the batteries included…. No, with a small nuclear reactor in the box.

I’m just sad that I don’t have access anymore after college, being too cheap to pay for a license.

It comes free with a Raspberry Pi.

https://www.wolfram.com/raspberry-pi/

For trying and basic work can also use a free Wolfram Cloud account.

Get then free kernel and WLJS notebook

I'm basing this on my experience a few years back.

It's not that you can't do it with other software, Mathematica just has all of it included by default, with very comprehensive documentation. And a slick UI.

Sure you can probably do most of it in python, but you'll find yourself chasing some obscure modules to get some things working. Even just to get arbitrary precision calculations for just about everything, for example. And don't forget the importance of a documentation that explains every option with examples (barring some obscure stuff, which can be quite annoying if you encounter it).

Since it's all integrated Mathematica allows you to go from calculating Sin[2] to arbitrary precision, to calculating the derivative of Sin[2x], to showing the first 10 terms of its Taylor series. All using the same sine function.

This does have some downsides. For one it's a pretty heavy program to run. And because they want to include everything they need to be quite opinionated about certain things. There are multiple ways to define fractional derivatives for instance, since they include a function for it they must have picked one of them. And then there are the name clashes, I once had to laugh quite loudly when I tried "Rotate[{0,1}, 45deg]" and got back an image of {0,1} at a 45 degree angle.

It is an impressive piece of engineering. Which could have had much more of an impact if it was a bit more open, but oh well...

- Far better language design, actually designed from ground up to write Mathematics in, rather than hacked in later.

- Specially, the language supports symbolic computation natively. In a lot of software, you have to declare symbols as symbolic variables before using them. In Mathematica, you don't have to deal with this nonsense.

- A library of both symbolic and numerical algorithms that is far far far better than any other library out there. Especially its outstanding how much symbolic computation algorithms are built in. Fairly fast numerical algorithms as well. Best of all, Mathematica guesses the best algorithm to use in a particular situation with frightening accuracy.

- A lot of Maths is just built in. Example: A number of common Groups are just there for you to immediately start playing with.

I had thought of him as megalomaniac, but I recently heard him do a two hour podcast on the Joe Walker Podcast (formerly Jolly Swagman). He came off as relatively normal for someone who earned a Ph.D. in particle physics from Caltech at the ripe age of 20.

It maybe be irrational, but the absolute arrogance of the author is off-putting and makes me reluctant to use any of his creations (which may be great I don't deny). I may have developed a heuristic that tells me to be very suspicious of people that are so sure and full of themselves as to become dangerous because they can be spectacularly wrong. It may have stemmed from the pandemic...

So, sure, you are smart and clever, but no.

I never really got what made people so allergic to Wolfram. After the many outrages online I tried to dig and I never found anything shocking. There's not too many mention of "I" or too many self flattering hyperboles.. so I don't know.

> I never really got what made people so allergic to Wolfram. After the many outrages online I tried to dig and I never found anything shocking

For me it was trying to pass his employees work as if it were his own, through NDAs and lawsuits, like happened in this case:

https://en.m.wikipedia.org/wiki/Rule_110 https://www.complex-systems.com/abstracts/v15_i01_a01/

We only know this case because the employee fought back. Makes one wonder how many similar cases happened but never surfaced.

Oh interesting.

Previous discussion: https://news.ycombinator.com/item?id=13961947

I don't care about arrogance, but closed source languages have no place in the 21th century IMO. I could use it if they open sourced at least the compiler

Well, there is https://github.com/WolframResearch/codeparser

I'm happy that wolfram research decided to open source a few libraries, and it would be awesome if they eventually followed the steps of .NET Core and other formely closed ecosystems and opened up the whole toolchain

There's Mathics, a subset of the language implemented in Python, but unfortunately after the main author of that was hired by Wolfram, the project seems to have basically died. Still fun for what it is.

https://mathics.org/

Arrogance is not only annoying, but also indicative that the person isn't as good as they appear. Wolfram is different, however. Yeah, he's probably insecure due to some childhood-related reason, but don't let this trick you into believing he's just some random Internet person full of hot air. This guy is a genius and a fantastic explainer. His arrogance is just one of his well-documented personality quirks.

Just look the other way and try to learn something from him.

He's actually very intelligent and has a record of producing a very successful and well loved product by many. He did things on his own terms and I can respect him for it, even if he would probably annoy the hell out of me in real life if we were just grabbing dinner.

I recommend to watch some of his regular livestreams on Twitch [1], where I have learned that he is also a quite humble, honest and kind person. Albeit one who likes to hear himself talk (and is aware of that), but I also really enjoy his ramblings on science somehow.

With all the things he has accomplished and his competence across different fields, I don’t mind him being arrogant sometimes. He is working in the area of fundamentals of science, so of course there will be bold claims made - anyone can judge for themself if they hold water.

Science in institutions is often stuck in its entrenched paths and few people dare (or cannot afford) to step outside and try new things, especially across different fields. I believe people like Wolfram, who have earned the knowledge and experience to be able to make a serious attempt on advancing science in new and different ways, are a very valuable resource for humanity, even if they may not succeed.

[1]: https://livestreams.stephenwolfram.com

Reply on news.ycombinator.com