If Mathematica had been open-sourced twenty years ago it wouldn't have taken the place of Python. It probably would be even more niche today - and worse.
Maybe, but a better successor would've evolved out of it.
Matlab had Octave as an open source alternative. Not used much, but it inspired the creation of Julia. Based on how fast it's evolving Julia will be the superpowered-grandson-of-Matlab :)
The Mathematica/Wolfram bloodline will unfortunately die off at some point... lots of ideas will be lost and time will have to be spent to reinvent them from scratch atop a different platform... sigh...
(Kind of reminds of the Smalltalk story... in the 80-90s Java won bc. all the practically usable Smalltalk implementations were closed-source and had very bad pricing... We could've had much better OO+interactive languages instead if an open-and-free alternative of it existed... Instead we have ugly Java/C# or slow Ruby in that space.)
> Matlab had Octave as an open source alternative. Not used much, but it inspired the creation of Julia. Based on how fast it's evolving Julia will be the superpowered-grandson-of-Matlab :)
That's a very contrived argument!
If Matlab has inspired the development of other products without ceasing to exist so can (maybe has) Mathematica.
Including the JIT and GC that powers OpenJDK, which was only made freely available on Java 6 version.
Also that Sun went bankrupt trying to push Java everywhere, while the other Java vendors (and Microsoft with .NET Core), learned to only open the core part, while the crown jewels are kept commercial.
Difficult for Java to win in the 80s!
> … Smalltalk implementations were closed-source and had very bad pricing…
Compared to $0 all pricing is bad pricing.
I've been there during the Python take over and world and it's not my recollection of how it went.
Which are those superior languages that you are talking about?
An important property of Python is that while it may not excel at many things, it's good or decent at everything. Unlike specialized languages like R for example which sucks at everything which is not operations on numbers.
Lush was a lispy open-source language - implemented in C - that deserved a better outcome.
And of course there were other scripting languages around like Perl, Tcl and Lua. Torch was built on top of the latter, by the way.
A few examples, there were countless articles like these:
2000 Eric Raymond (!) - Why Python?
> It was at this point I realized I was probably leaving Perl behind. ... For anything larger or more complex, I have come to prefer the subtle virtues of Python—and I think you will, too.
https://www.linuxjournal.com/article/3882
2002 What's wrong with Perl:
http://lush.sourceforge.net/news.html
2003-02-19: Rejoice, rejoice! Thanks to Leon, the CVS version now compiles and runs on Windoze under Cygwin. Be sure to read the README.cygwin before installing. What works: the interpreter, the compiler, the dynamic loader, X11 graphics and events. What doesn't (yet) work: external packages such as GSL, SDL, OpenGL...
A library written in a language usable for implementing whole applications is far more useful than, say, a Matlab project, which you then have to translate into some language before you can actually use it in software.
Python is indeed such a language.
(That being said, Python is a poor language choice from a software engineering point of view because it doesn't have a decent path-of-least-resistance to properly distributing software without burdening the user. I do a fair bit of embedded programming, and it has lead me to the conclusion that Python is a terrible tooling language. I've also had colleagues struggle with what happens when data scientists who are more scientist than software engineer write stuff in Python. It is messy, time consuming and frustrating to actually use the resulting software.
But from a language perspective, yes, Python is a better solution than languages that are narrowly scoped)
This is largely the same audience as for tools like Matlab and Mathematica.
And to serve that market it didn't have to be a good programming language. You won't find most data scientists discussing the finer points of functional programming or OO. They'll be discussing what mathematical techniques to use or what stages to string together in order to achieve the computation they want. If you have ever worked with typical data scientists, most of them aren't even half way competent software engineers.
What Python shows is that community beats technical excellence. By orders of magnitude.
Whether or not Mathematica is a better language is irrelevant as it doesn't have the properties required a large community contributing value for free.
We can't know if Mathematica could have taken the place of Python if it was open sourced, because it wasn't open sourced. But it given that it had a more potent programming model, it could have led to a very different path from model to running software, for instance. And it could have made distributed computation arrive a lot earlier.
But it is actually quite a bit more challenging for Mathematica than that since its licensing terms are stricter than products you might compare it to, like Matlab. I don't think Mathematica would even have to be open sourced to be more successful - it would just have to be a less unattractive value proposition. Compare the revenue of Mathworks vs Wolfram Research, for instance. And then take into account that Mathematica has a much more potent programming model that could have far wider applicability than Matlab.
And keep in mind: Matlab doesn't even have a programming model as potent as Mathematica.
I think that the smartest thing Wolfram could have done would have been to open source the language, the runtime, and a reasonable standard library. Then they could have built a business on top of that of reasonably priced interactive software with GUIs, visualization tools, developer tools to make stand-alone applications, server applications for distributed computation and a SaaS solution for customers who want to run computation in the cloud.
And it isn't like Mathworks didn't miss the boat too. But they are still an order of magnitude more successful than Wolfram Research. Which still makes Wolfram Research the slowest kid in the class in terms of unrealized potential.
The issue is that other languages which were better and more appropriate for scientific computing _had_ those properties. Or maybe these properties are very specific to python and then an open-source mathematica wouldn't have made a difference either.
> And it isn't like Mathworks didn't miss the boat too. But they are still an order of magnitude more successful than Wolfram Research.
Depends on your definition of success, of course. You focus on adoption but that's not the only goal. The company is an order of magnitude larger but that doesn't make the product an order of magnitude better.
In terms of adoption Mathematica is even less of a success than if you measure financially. And adoption is a key factor when evaluating whether or not you want to use a programming language for non-trivial projects. It impacts your ability to recruit, access to knowledge (books, forums, evolved practices), usable solutions to common problems (libraries) and even more or less existential questions like whether or not the language will be maintained. Python ticks all of those boxes. Mathematica partially ticks perhaps one of those boxes. And note that this is before we even consider if Python is any good as a language.
If you were to invest in developing a non-trivial system in Mathematica, how enthusiastic do you think investors would be if you nailed your flag to the Mathematica ship? It would not represent good risk management.
Then there's where things are heading. The number of jobs as "data scientist" or "statistician" of some description is growing sharply. It may gain Mathematica a trickle of new users. But the really big gains have been for languages like Python or Julia. Worse still, people tend to move away from software like Mathematica or Matlab, moving to languages like Python and Julia. In fact, it wouldn't surprise me if just the growth in Julia alone over the past couple of years is greater than the total paying userbase of Mathematica.
Single digit, or even low double digit growth in a field that has doubled a few times in the same period isn't success. It is everyone else outrunning you. Fast. And I have seen up close and personal how people who find themselves in that situation will rationalize it with "but we're growing".
Is it a success that it is "good"? For some value of good? Well, a lot of people think Lisp is good. And yet after being around for many decades it is still so hard to find developers to maintain Lisp codebases. I've seen about half a dozen major systems written in Lisp being scrapped once one or two key employees leave. Sure, the systems may qualify as good, even great - but that doesn't help when it becomes a business liability? In the real world it doesn't.
I would have loved for Mathematica to succeed. But it hasn't. And I suspect it won't. Even if it were open sourced right now, I seriously doubt it would bear much fruit the first decade or so. If at all, since the big audiences are focused elsewhere.
I'm pretty sure it wouldn't have, not with it's current lispy syntax. There is ton of empirical evidence that overt functional style is unnatural for the human mind, especially beginners. Which is why there is no large scale use of any such language.
> Clearly, there is an obstacle to the acceptance of FP. I think I know what it is. The functional paradigm is an unnatural way for human beings to think. People normally view the world as comprising objects. Nobody views the world as comprising functions, unless he is trained to do so.
https://richardeng.medium.com/fp-is-for-nerds-6ed1ca43bb34
> When it comes to functional programming, a lot of people start with, “But that’s totally unnatural!” Functional programming is compared to working “backwards” and some complain that it’s more about solving puzzles rather than working with code.
https://bulldogjob.pl/readme/functional-programming-does-it-...
It took me reading Practical common lisp to appreciate the Lisp origins of Python (down to documentation strings and a lot of other details).
As a counter datapoint, I have seen people responsible for designing custom parts in Autocad (back in the day when you had to issue commands) master the lisp syntax without giving it a second thought. I found it weird for 5 minutes when I was maybe 12-14 (we had some course about it in school, I don't remember exactly)