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.
One would expect 37 years would be enough to create such alternative.
Jupiter notebooks aren't the same.
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!)
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).
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.
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.
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)
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.
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!
It's $195/year for a personal license. And only $75/year for students. Their licensing model is pretty broad.
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.
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.
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?
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)
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.
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)
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’m using xcas now, it’s working pretty well for my humble needs.
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.
Mathematica is way, way under appreciated in industry, and even in the sciences.
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.
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.
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.
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.
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.
Not everyone is keen doing scripting from command line with vi.
Someone has to pay the bills for development effort, and when it based on volunteer work, it is mostly followers and not innovators.
Maybe it will someday be good enough, but not today, and probably not for at least 5 years.
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, ...).
Obviously. Since software is as much vital to the modern world as water, making people who deal with it disclose implementation details is a very small ask.
Access to the market is not a right but a privilege. If you want to sell things we can demand things of you.
I can't tell if you're saying that as if it's a good thing, or a bad thing.
https://gitlab.freedesktop.org/xkeyboard-config/xkeyboard-co...
Now, I really could've used something like this on macOS…
Karabiner to the rescue https://genesy.github.io/karabiner-complex-rules-generator/#...
Some of those tools aren't yet fully there, but also aren't completely dumb, they get more done in a day, than trying to do the same workflows with classical programming.
Workato, Boomi, Powerapps, Opal,...
So as great as Mathematica sounds for interactive math and science computations, sounds like a poor tool for building systems that will be deployed and used by many people.
Infringing on that should be justified in terms of protecting the rights of those involved, such as ensuring the quality of goods, enforcement of reasonable contract terms and such. We are involved in the process as participants in the market, and that’s the basis of any legitimacy we have to impose any rules in the market. That includes an obligation to fair treatment of other participants.
If someone writes notes, procedures, a diary, software etc for their own use they are under no obligation to publish it, ever. That’s basic privacy protection. Whether an executable was written from scratch in an assembler or is compiled from high level source code isn’t anyone else’s business. It should meet quality standards for commercial transactions and that’s it. There’s no more obligation to publish source than there is to publish design documents, early versions, or unpublished material. That would be an overreaching invasion of privacy.
The analogy would be ever-so-slightly more accurate if you said "software is as much vital to the modern world as beverages".
It would also be more accurate if all water was free.
Neither of which is the case.
That said, the parent was talking about it being expensive for use in industry. Personal and student licenses aren't relevant there.
But it seems like the proprietary languages have all withered, regardless of price. Even $195 for Mathematica is an obvious concession to this trend. I don't ever remember it being that cheap.
I could write an essay on the benefits of free tooling, but enough has already been written. I'll spare you the slop. ;-)
Incidentally, Mathematica + LLMs make a great combination. If you take what is pretty much the biggest mathematical routine library in the world and combine it with interactive visualization tools, and then use an LLM to accelerate things, it becomes an incredible tool. Almost ridiculously powerful for trying things out, teaching, visualizing things, etc.
(I've been using Mathematica since 1992 or so, so I'm familiar with the language, but it's still so much faster to just tell Claude to visualize this or that)
People shouldn’t lose their rights to what they own, just because they do so through a company.
I do think reasonable taxation and regulation is justifiable but on the understanding that it is an imposition. There is a give and take when it comes to rights and obligations, but this seems like overreach.
Matlab and Python are in the same ballpark. Easy syntax and large standard library. Matlab provides a lot more dedicated libraries for niche areas but the overall experience feels the same.
Mathematica doesn't really have a standard counterpart. Jupyter notebooks try to capture the experience but the support for symbolic expressions makes the Mathematica experience very different.
Same about your criticism of error handling and control flow: https://reference.wolfram.com/language/guide/RobustnessAndEr...