Nowadays I'd probably just ask Claude to figure it out for me, but pre LLMs, WL was the highest value tool for thought in my toolbox.
(Edit: and they actually offer perpetual licenses!)
If this was open sourced, it had the potential to severely change the software/IT industry. As an expensive proprietary software however, it is deemed to stay a niche product mainly for academia.
Not everyone is keen doing scripting from command line with vi.
Ugly os software at least has potential to grow internally. Long lived commercial software is a totting carcass with fresh coat of paint every now and then.
Someone has to pay the bills for development effort, and when it based on volunteer work, it is mostly followers and not innovators.
In many cases, people are free to write their own implementation. Your claim " Source code should enter public domain in a decade at most." means that every software vendor shall be obliged after some time to hand out their source code, which is something very strong to ask for.
What is the true crime are the laws that in some cases make such an own implementation illegal (software patents, probitions of reverse-engineering, ...).
As an engineering undergrad I had a similar feeling about Matlab & Mathematica.
Matlab especially had 'tool boxes' that you bought as add-ons to do specific engineering calcs and simulations and it was great, but I almost always found myself recreating things in python just because it felt slightly more sane to handle data and glue code.
Pandas and Matplotlib and SciPy all used via an ipython notebook were almost a replacement.
It's $195/year for a personal license. And only $75/year for students. Their licensing model is pretty broad.
I don't remember what the pricing has been throughout the years. But I do remember that for some of the time I couldn't really afford Mathematica. And the license I wanted was also a bit too expensive to justify for a piece of software that only I would be using within an organization.
Because it is also about enough other people around you not being able to justify the expense. And about companies not wanting to pay a lot of money for licenses so they can lock their computations into an ecosystem that is very small.
Mathematica is, in the computing world, pretty irrelevant. And I'm being generous when I say "pretty": I have never encountered it in any job or even in academia. People know of it. They just don't use it for work.
It would have been nice if the language and the runtime had been open source. But Wolfram didn't want to go in that direction. That's a perfectly fine choice to make. But it does mean that as a language, Mathematica will never be important. Nor will knowing how to program in it be a marketable skill.
(To Stephen Wolfram it really doesn't matter. He obviously makes a good living. I'm not sure I'd bother with the noise and stress coming from open sourcing something)
To my knowledge, at least in academia, Wolfram (Mathematica) seems to be used quite a bit by physicists. Also in some areas of mathematics it is used (but many mathematicians seems to prefer Maple). Concerning mathematical research, I want to mention that by now also some open-source (and often more specialized) CASs seem to have become more widespread, such as SageMath, SymPy, Macaulay2, GP/PARI or GAP.
Plus you buy a version of it, and then someone else is on another version, and you don't have the same features, and the tiny community is fragmented.
I’m using xcas now, it’s working pretty well for my humble needs.
Mathematica seems a little pricey but maybe it would motivate me to learn more math.
I would love to read what non-mathematicians use MatLab, Mathematica, and Maple for.
In retrospect, doing the work in mathematica would have probably stretched my brain more (in a good way!) since it provides a different and powerful way of solving problems vs other languages...maybe I'll have to revisit it. Perhaps even try advent of code with it?
While python did get the job done, it feels like the ceiling (especially for power users) is so much higher in mathematica.
(Mathematica is of course much better than Python at symbolic math, but this isn't what you are asking about)
Mathematica is way, way under appreciated in industry, and even in the sciences.
Yes this is all a bit quirky and nuanced but when you get into it these things are really good. It’s refreshing to see some really smart folks just focused on doing great things without blinding from VCs and MBAs pushing another hacky quick way to make a buck and cash out.
One would expect 37 years would be enough to create such alternative.
Jupiter notebooks aren't the same.
The notebooks are also difficult to version control (unreadable diffs for minor changes), and unit testing is clearly just an afterthought. Also the GUI performance is bad. Put more than a hand full of plots on a page, and everything slows to a crawl. What keeps me coming back is the comprehensive function library, and the formula inputs. I find it quite difficult to spot mistakes in mathematical expressions written in Python syntax.
Different languages are better at different things, so it rarely makes much sense to say that one language is better than another in general. Python is definitely much better than Mathematica for "typical" imperative programming tasks (web servers, CLI programs, CRUD apps, etc.), but Mathematica is much better at data processing, symbolic manipulation, drawing plots, and other similar tasks.
> there is no real scoping (even different notebooks share all variables, Module[] is incredibly clumsy)
Scoping is indeed an absolute mess, and the thing that I personally find the most irritating about the language.
> no real control flow (If[] is just a function)
You're meant to program Mathematica by using patterns and operating on lists as a whole, so you should rarely need to use branching/control flow/If[]. It's a very different style of programming that takes quite a while to get used to, but it works really well for some tasks.
> no real error handling
For input validation, you should use the pattern features to make it impossible to even call the function with invalid input. And for errors in computation, it often makes the most sense to return "Undefined", "Null", "Infinity", or something similar, and then propagate that through the rest of the expression.
> The notebooks are also difficult to version control (unreadable diffs for minor changes)
Mathematica notebooks tend to do slightly better with version control than Jupyter Notebooks, although they're both terrible. You can work around this with Git clean/smudge filters, or you can just use ".wls"/".py" files directly.
Good for product: not so good for people.
I am told that he gave a great deal of agency to people he trusted, though.
In my career, I ran into two [brilliant] individuals that had, at one time, worked with Jobs.
They both hated him.
Typical example of a extraction/exploitation mentality where innovation would be better. Wolfram is in an amazingly good spot to spin up better "simulation as a service" if they would look at fine-tuning LLMs for compiling natural language (or academic papers) into mathematica semi-autonomously and very reliably. Mathworld is potentially a huge asset for that sort of thing too.
I played around with RemoteKernel some time ago (https://taoofmac.com/space/blog/2016/08/10/0830) but this is “better”, although I wish they’d make it hostable in your own cloud provider like materials simulation software and other things we see running in HPC clusters. (I also ran Mathematica in a 512GB/128core VM once for kicks, but it’s just not cost-effective).
I do notice that they have an "Application Server" for Kubernetes, which is pretty curious: https://github.com/WolframResearch/WAS-Kubernetes (though not updated in over a year)
The reality is that by now we should already be at a level where common programming would be like Wolfram everywhere.
Maybe agents and LLM driven code generation is how we eventually get into the next abstraction level, sadly won't be without casualties with smaller team sizes, when so much can be automated away.
What aspects of the Wolfram language should be everywhere? The easy access to lots of datasets? The easy access to lots of mathematical functions? CAS in general?
Basically the ideas of Smalltalk and Lisp Machine variations, that are still only partially available in modern IDEs, and proudly ignored by the "vt100 rules and vi first" minded devs.
Jokes and sales pitches aside. We kinda have that already, we platforms that allow us to run the same code on, x86, arm, wasm… and so on. It’s just there is no consensus on which platform to use. Nor should there be since that would slow progress of new and better ways to program.
We will never have one language to span graphics, full stack, embedded, scientific, high performance, etc without excessive bloat.
Maybe it will someday be good enough, but not today, and probably not for at least 5 years.
I started working on an implementation in Rust called Woxi (https://github.com/ad-si/Woxi) and I hope to find some contributors, as it is such a gargantuan task!