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.
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.
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.
Reminds me of the “Stop writing Dead Programs” talk. https://news.ycombinator.com/item?id=33270235
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.
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,...
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.
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.
It's $195/year for a personal license. And only $75/year for students. Their licensing model is pretty broad.
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 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.
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/#...
I’m using xcas now, it’s working pretty well for my humble needs.
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. ;-)
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, ...).
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.
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.
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.
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.
(Mathematica is of course much better than Python at symbolic math, but this isn't what you are asking about)
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 way, way under appreciated in industry, and even in the sciences.
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)
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!
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.
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.
500 Internal Server Error