Launching Version 13.1 of Wolfram Language and Mathematica
writings.stephenwolfram.com
writings.stephenwolfram.com
It really is an astounding system. If you enjoy functional programming, the language is super expressive and productive. The integrated libraries are fantastic -- especially if you want to chain together different knowledge domains through a consistent interface and syntax. You can get the entire Wolfram Alpha knowledgebase and curated datasets to use in your programs immediately.
The front-end is just lightyears in front of Jupyter notebooks in just about every conceivable way.
This isn't to hide that there are some frustrating things about the language (like, machine learning development has just stopped dead after a couple of really great years of feature dev...why?) and, especially, the organisation and some of its personalities. But the product -- it really should get a lot more kudos and wow factor based on real accomplishments and features that are live, in the real world.
I love Wolfram stuff.
As a proprietary language and kernel, it can never compete long-term with open source alternatives.
It's one thing to have a proprietary product, but for decades now proprietary languages have been a no-go for practically everyone. Even formerly closed languages have been opened sourced, such as Java and C#.
There is no other use for Wolfram Language scripts outside of Mathematica, which comes with a "license server". That's... a dead end.
Can I publish Wolfram code in Docker Hub and expect it to work (legally)? No.
Can I throw some Wolfram code into an Azure Function and have it compute something for me on demand? Nope.
Can I embed Wolfram code into a C# app, publish it on GitHub, and have other people be able to use it without forking out $thousands for a Mathematica license? Nope!
And on and on...
Python, Julia, and Jupyter notebooks will simply wipe out all usage of Mathematica outside of a few esoteric fields. As you said, they're all markedly inferior in almost every way, except for one critical one: they're open and extensible.
You mentioned AI/ML having stopped dead in Mathematica. I noticed that too. I wanted to test some GPU-hosted ML stuff recently that's not the standard Pytorch/Tensorflow type of thing, checked Mathematica, gave up, and I'm now using Julia.
If Mathematica was more open, there would be no "dead end" there, I could simply extend it. Or more importantly, other people would have already.
The guy who was in charge of negotiating software licenses for the university said that it was a chicken and egg problem. Mathematica wasn't very available because it was expensive, Wolfram wasn't easy to negotiate with.
With people not learning Mathematica there never developed a demand for it - and because you couldn't expect to get your hands on a license it wasn't worth the investment both in time and money to learn mathematica, or worse yet, to make yourself dependent on it for getting work done.
Mathematica has always been a lovely product. But it has also always been impractical due to its pricing and restrictions. Whether you are in academia, a working professional or just a hobbyist. Which has made it a very niche piece of software. For 30+ years.
There is no reason to believe this will change. And that's fine. It is their software and they can do whatever they want with it. But it also means it is largely irrelevant software for most people, including the scientific community. That isn't a disparaging remark, it is an accurate representation of reality.
The hobbyist license is less than $200 per year. What kind of pricing would make it practical for you?
[Edit: The student license (non-expiring) was $139 twenty years ago, $176 today. That may be "expensive" but many textbooks cost more than that.]
Every time I use it, I have this mental image of using a 500 ton press to crack a walnut. It's ludicrous overkill, but it brings a certain satisfaction to be able to use arbitrary precision maths when I don't need to, and use nonlinear fits for graphs where nobody looking at the result will even begin to appreciate the difference it makes.
This is the problem -- there is a "long tail" of people like me that have used Mathematica at university that are loathe to let go, but can't really justify the ongoing price.
This is why there are free editions of many paid tools. IntelliJ IDEA and Visual Studio have free "community editions", for example. More importantly, the build tools are generally free.
Even eye-wateringly expensive enterprise products with "call us" pricing have free editions! For example, VMware ESXi, Oracle, DB2, and SQL Server all do.
Wolfram is one of the last all-proprietary, no-free option, no open-source holdouts, especially in the space of "general purpose languages".
Perhaps Wolfram Alpha is a "free option" for the once-in-a-blue-moon use case.
But you might lose any work at any moment, if Wolfram decides to turn it off.
I paid for the $200 license back in high school 10 years ago and it was absolutely amazing; Really ahead of its time and well worth the money. But today as a software engineer the only feature I’m missing in Python is the ability to run natural language expressions in the middle of my code. Besides that, Python is far superior thanks to the community investment and the ability to easily deploy my code.
Nowadays my daily workflow is mainly based on Python and Julia, I use Mathematica just for symbolic calculations (solving differentialequations, computing integrals...)
P.S. Once I had the chance to use Mathematica 12 on a server in my University, but I found that it offered nothing that I could need that wasn't already in version 5...
What can you do with a hobby license from Wolfram? Use the software. You can't really distribute it, put it in production, or anything else besides serve your own compute needs. They forbid you from using the Home versions for any non-personal use: you can't bootstrap your startup with it. You're not allowed to get reimbursed for it by your employer. You're not allowed to use it for academic purposes. The service plan lets you use your license on a second computer, but dual boot counts as a second computer. You can't upgrade your license, you can only buy a new one. It's almost as though they don't want you to use their software.
Why would anyone who doesn't already have experience with Mathematica pay for this license?
You can get a 15-day trial, by the way.
Why would anyone pay $100+ for a couple of games? Or for Photoshop? Or for a pair ski goggles? Or for a bottle of wine? Or for a ticket to a show? Or for a radial saw?
The difference with Mathematica is that if you don't know you like and need it already, there are numerous free and less expensive tools that do a great job, and they (usually) don't have restrictions on what you can do with them. I can make a Python notebook and start a business with it. I can use my hobby Julia code for academic research.
Some people find enough value in Mathematica, Matlab, Tableau, JMP or commercial IDEs, compilers, libraries, etc. to prefer them to the free unrestricted alternatives available.
Some people like iPhones and Macs, some people say that there are numerous less expensive devices that do a great job and don't have restrictions on what you can do with them.
But pricing isn't the only problem here. The licensing model would have to be far more permissive. Plus I think any language that hopes to be successful would at least require an open source compiler, runtime and standard library.
A perpetual license for Office Professional 2021 costs low double digits (depends on locale). They also don't really enforce checks for non-commercial use. As a result, almost every office uses Excel. It still doesn't replace python/C++ for deployment.
I'll have to disagree with your conclusion.
Excel has been the de facto standard for spreadsheets for a couple of decades so its user base is not because of how the office suite is priced right now, but because it is "what everyone uses".
This effect is even so powerful that despite Apple's suite (whatever it is called this year) being free, and various free online offerings exist that are adequate for a large chunk of users, Microsoft can still price licenses relatively high.
The hobbyist license wasn't priced by the year, just outright single charge. Is the by-the-year version you see one with continued upgrades?
[ Edit : the edit directly above answers this. thanks! ]
Yes. They call it Wolfram Engine
>Can I publish Wolfram code in Docker Hub and expect it to work (legally)? No.
Yes, they call it Wolfram Application Server (does require a license)
>Can I throw some Wolfram code into an Azure Function and have it compute something for me on demand? Nope.
Yes: https://reference.wolfram.com/language/ref/RemoteBatchSubmit...
Contrast with gcc.
Until there is an open source software that can match the raw symbolic power combined with the huge libraries nothing can touch it for a lot of people.
same deal with solvers more generally. the coin-or stuff (e.g. Cbc) is slow and buggy, Cplex and Gurobi are far better but very expensive. where are the PhDs in this field? what are they building?
Have you tried Maxima? It seems more ergonomic.
A very computer-science perspective with the obligatory dose of hubris.
Pencil and paper is continuing to serve a much older, much more consolidated discipline (mathematics) well for... ever since paper was invented.
It would be insane value for everyone if the symbolic niche could also be covered by a general purpose language...
I haven't worked with Mathematica in years, though, so this is mostly speculation: how strictly do they maintain backward compatibility?
> AbsoluteOptions has been reimplemented to be more accurate, and the form returned for a particular option may be different now.
They deprecate stuff, but almost never remove it:
> ValueQ has been redesigned to test for the presence of a definition regardless of whether the definition is used. Old behavior can be restored by specifying "Legacy" as the method.
They play more fast-and-loose with functions documented as "experimental".
Looking at how many buzzword bingo boards I could make with JavaScript frameworks de jour and even enterprise platforms like .NET I find this statement exactly backwards in practice.
> An open source language is inevitably going to attract some maintainers who care about (or are paid to care about) keeping legacy code working.
Over 20 years I’ve found this to be quite a mixed bag.
That said, I'm still a Mathematica person at heart.
I genuinely hope that Octave can take off and trade blows with MATLAB face to face, but not sure if that will ever happen simply because of the amount of money MathWorks is pumping into developing toolboxes.
No, its usage is just declining slower in those areas because ppl don't want unnecessary change introducing unnecessary defects, esp since safety and reliability matters a lot for some equipments, and also engineers spend time on smth else than learning new languages and frameworks.
In 20 years Matlab will be as legacy as Fortran is now, still some left but mostly forgone.
what are you talking about? There's a lot of numerical code written (and actively developed) in Fortran today. If you are anywhere near numerical mathematics, you are running algorithms written in Fortran that somebody is maintaining.
Not if MathWorks keep offering discounts to universities for putting MATLAB in the courses, gotta get those undergrads "hooked" early before graduating.
They're all exposed to Matlab (it's on every resume), but that could range from actually knowing how to program, to having been given some pre-written scripts to run in a class.
However, the ones who are inclined to program, want to learn a language that they perceive to be relevant to the software development job market. Some of them have gone so far as to take a handful of CS courses and are as up to date on good coding practices as the CS majors themselves. This even includes some students in traditionally non programming fields such as biology and chemistry.
Remember that it's usually easier to learn your second language, so if a student has the itch to program, there's a pretty good chance that they will have learned Python on the side by the time they graduate.
Matlab-class languages are <1 week for anyone smart to learn and usably prodactive at then it's a smooth learning curve up. They're not Scala or Haskell or enterprise Java frameworks...
When Julia gets all the advatanges currently in the Python ecosystem (and it's just a matter of time), it's game over. Ppl use Matlab instead of Python bc Python is weird and slow at many linear algebra stuff... AI/ML ppl are OK with Python bc they rarely write low level numerics code and when they do it has to run on stuff other than regular CPUs so it's C anyway.
If Matlab looses (fairly) we all win. But Mathematica/Wolfram is a different thing... there's all the symbolic computing stuff and the idea of integrating access to a general real-world-knowledge-DB into the language itself in there that will take decades to re-invent...
After raising their voices, Faculty finally switched from Matlab to Python for those courses because what matters was your number of hire after their master not to get a deal for a software nobody uses besides two old professors.
And in general, the more academia moves away from private solutions (be it STATA, ArcGIS, Matlab, SAS, etc), education will move from it also. (Belgian University)
Disappointingly because modern Fortran is a nice language for numerical computing.
This is a joke, right?
In many academic disciplines that involve numerical work, the amount of Fortran code in use today greatly exceeds that of any of the rivals.
Professors were forced to use Fortran by their advisors when they were in school, so most of their code is in it. These professors are not going to allow their students to reinvent any wheels. And the cycle continues. To give you an idea of how extreme this phenomenon is - almost all the Fortran code out there in academia is still in Fortran 77.
I'd wager that most of Mathematica's usage today, and in the past has been for those esoteric fields.
MATLAB always had higher market share for numerical work.
Mathematica's strength is in pure math. And nothing out there comes even close - not even SageMath. I wouldn't be surprised if all the pure math open source developers who are also math experts out there are fewer in number than those who contribute to Mathematica. You need detailed expertise in a math discipline. William Stein - founder of SageMath, wrote once on how impossibly difficult it is to get grants to support SageMath - most of them go to Mathematica or MATLAB. So if a math faculty member wants the extra income from grants, he/she is going to write a proposal targeting Mathematica, not SageMath.
Of course, once Stephen Wolfram dies, I don't know if Mathematica will continue to survive. But as long as he's alive, no open source pure math SW will overtake it.
What "open source alternatives"? There aren't any at this level of polish and maturity...
Meanwhile, whatever the "dustbin of history" does, we can continue keep using Mathematica just fine, for 20+ years, and 20+ more...
If their influence on that is their only contribution to the world, which it is not, then they have made their mark.
Since finishing up in university, I have sorely missed my free access to a fast and ergonomic symbolic equation solver. Sympy is an unsatisfactory substitute.
https://www.12000.org/my_notes/CAS_integration_tests/reports...
People have been saying this about Windows for the last 35 years.
Real time bare metal implementations, GUI tooling, 3rd party GUI components ecosystem, data analysis of runtimes in productions without code changes, architecture modeling tools on the IDEs,...
https://www.siriuserguide.com/what-is-wolfram-alpha/ https://www.siriuserguide.com/how-to-use-siri-knowledge/
"Siri Knowledge uses a combination of web searches, inbuilt apps, and Wolfram Alpha to find the answers to a fantastic variety of questions."
If you ask Wolfram Alpha for more information about Siri: https://www.wolframalpha.com/input/?i=Siri
It returns:
"Siri is a personal assistant application for iOS. The application was first available from the App Store, then came standard on Apple's mobile devices starting with iPhone 4S. Siri uses natural language processing to answer questions and perform actions by delegating requests to an expanding set of web services, including Wolfram|Alpha."
Yup, and all that's needed for the floodgates to open is for someone to write some sort of converter.
And no, "just run pip ..." will not work - who worked on these facilities probably knows how some of the smartest people in the world could be extremely dumb with the tech stuff.
Regarding Wolfram Language, at the beginning (when it was just a "Mathematica"), I hated it as I came from the C/C++ world. But after I embraced lisp et al., I found Wolfram Language very expressive and easier to grasp than before. Moreover, if I'm not mistaken, Wolfram Language is the only widespread implementation of M-expressions [1], the original form of LISP how John McCarthy wanted it to look.
> The front-end is just lightyears in front of Jupyter notebooks in just about every conceivable way.
Absolutely :)
I'm with you 100% here, but I'm also 100% with sibling jiggawatts.
To me, Mathematica is a computation environment that conveys a Lisp Machine feeling of "the machine and I are working on this problem".
You know, that "assembling things live in the sky" Lisp feeling (Yegge's phrase, not mine).
The only other computation environment that is right there en par in flexibility and conveyance of the same trippy feeling is, of course, Emacs.
The company can still make money from academic and professional licensing and support contracts, and everyone else gets to have access to an awesome thinking tool as a matter of fact.
They've already gone that direction a bit with the Raspberry release, what's left now is just the final push.
So, if Stephen Wolfram ever reads this:
Open source Mathematica and it will have a chance at immortality.
Just like Lisp and just like Emacs, and the people will rejoice.
Disclaimer: I started with Mathematica 4.0 at age 14 (a pirate copy too, sorry!), turned on by that marvellous column in Quantum. But I was put off precisely due to the proprietary nature, and switched to C and Lisp. Consequently I became a CS guy rather than a Physics guy, because C and Lisp were accessible early on, while Mathematica wasn't (legitimately).
Agreed. That's the main thing that tends to get lost when people make comparisons between MATLAB and Mathematica. Mathematica is conceptually elegant and often just a joy to work with as an intellectual tool. Its core problem is just that it isn't more widely available. MATLAB on the other hand is just an inelegant, obvious implementation of a numerical environment. Its strength is just the variety of toolkits you can license, but once your domains get equivalent open source toolkits, there's no reason not to bail on MATLAB.
>I started with Mathematica 4.0 at age 14 (a pirate copy too, sorry!)
The nice thing these days is that the full version of Mathematica is available for free on the Raspberry Pi. Wolfram deserves some kudos for that.
I feel like the other drug dealers in history might be offended at not getting at least some credit here for inventing this method.
I stand by the fact that the comparison to drug dealers is not true. There's a very, very long path from legal but shady (to me) business practices to things like engaging in all out war with rival dealers, getting people hooked on stuff that in many cases renders them zombies, torturing and killing people that owe you money or that get in your way, forcing rural people to plant what you want or getting them killed or displaces, which are all part of the things drug dealers do. Not even the Microsoft from the 90s was comparable to that.
So, to try and restate my original reply in a hopefully clearer way: I agree with the point you're trying to make, but I think the analogy you chose may go against it for some readers.
Do you know Pharo? The experience you describe is also typical in the Smalltalk family. See https://pharo.org/
Got a source on that? It sounds intriguing.
which column?
From https://reference.wolfram.com/language/guide/SummaryOfNewFea...
New in machine learning in 13.1 ...
ContentDetectorFunction (updated) — support for Information DimensionReducerFunction(updated) ▪ FeatureExtractorFunction(updated) FindClusters (updated) — support for fixed number of clusters and UpTo ClusterClassify(updated) ▪ ClusteringComponents(updated) Interpretable Machine Learning FeatureValueImpactPlot — plots the impact of a feature on a model result FeatureImpactPlot — plots the impact of each feature together CumulativeFeatureImpactPlot — plots the cumulative impact of each feature FeatureValueDependencyPlot — plots the result dependency on a feature value Network Layers » ReplicateLayer (updated) — support for integer arrays RandomArrayLayer (updated) — support for more statistical distribution AttentionLayer (updated) — support for dropout and local masking ElementwiseLayer (updated) — new activations "Mish" and "GELU" ThreadingLayer(updated) ▪ FunctionLayer(updated) Network Training » NetTrain (updated), LossFunction (updated) — support for multi-output and nonscalar loss Encoders & Decoders » "Image" (updated) — resampling and padding support "Class" (updated) — support for top-k and top-p sampling (nucleus sampling) Formats "ONNX" (updated) — export support for net operators
I would say in 2018-2019 the ML / Deep learning stack was actually very impressive compared with what was available in FOSS. Now -- it's languishing. Badly.
I was offering a specific counter example to your observation that he was possibly hurting those closest to him.
> His puffery essentially hurts nobody besides perhaps those close to him
I think if he was genuinely hurting the people closest to him, like his family through his brash personality, they wouldn’t want to collaborate with him on long, extended projects. Especially considering how old and intelligent his son is.
> The front-end is just lightyears in front of Jupyter notebooks in just about every conceivable way.
I had the opposite experience, but it's a very broad statement and I suspect we took different interpretations of "front-end"
A few pain points for me:
- No Markdown support. Yes, there's rich input, but I find it more natural to write prose in a markup language rather than with a rich editor.
- Single "kernel" support. This isn't a criticism of Mathematica per-se: it doesn't care about other languages. But, it's nice to be able to use Jupyter Notebooks with C++, Python, etc.
- Limited UX w.r.t layout. JupyterLab lets me pin outputs, split the view, run a terminal alongside my notebook etc.
- Restricted ecosystem. This is a big one - it's not trivial to write an extension for Mathematica to extend its UX / rich output mechanism. With Jupyter, this is fairly trivial.
Don't get me wrong, they're different tools, and that's why I'm reluctant to engage with "X is better than Y" discussions. Mathematica is vastly unsuited to the kind of analysis / work that I do, whilst I'm sure the same is true of those who swear by Mathematica.
If you like Jupyter more than Mathematica as a front-end you can use wolframscript
https://www.wolfram.com/wolframscript/
as a Jupyter kernel:
https://github.com/WolframResearch/WolframLanguageForJupyter
You can use it with the free (for non-production use) Wolfram Engine:
Interesting that both are commercial languages.
There's basically zero widely used programming languages that are not open-source, get to grips with this ffs. Esp. since Wolfram strives to be somewhat-general-purpose in a way (it's not smth like eg. K who's niche anyway) and having an open-source version is crucial in this segment.
Hire some ppl (sales, mgmt, product etc.) who know how to make money from open-source (get some from RedHat, IBM etc.) and make this technology accessible to not have all this effort practically wasted, eg. I'd love to use Wolfram instead of Python, but non-opensource is just a no-go for any foundational technology (language, framework, server).
Wasted as in providing a continuously improved product to the thousands of paying customers that fund this effort?
Mathematica is a very niche product. It isn't even very relevant in academia or in engineering. But it could have been if Wolfram hadn't hobbled it with unproductive restrictions. It could have had an audience of millions, and that audience would have brought it more value than a single company is capable of creating through a community.
Just look at Python. It is just a language. And a not particularly good one at that. ALL of its value comes from the community. Compared to Python, Mathematica isn't even a rounding error in terms of value created.
Imagine if Mathematica had been at the core of the last 15 years of data science, machine learning and whatnot? Imagine if the work and the value that went into the Python ecosystem had instead gone into Mathematica. Imagine if even just one of the many things Mathematica can potentially do well had become the go-to way for doing things.
But it didn't. Because Mathematica is fundamentally incompatible with the way communities work.
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.)
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.
> 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.
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.
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)
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.
Excel deserves to have the label of programming language even if it shuns that label due to it's target audience.
But it's still a bit like saying "Eclipse" is a programming language. You can do programming in Eclipse, that is true, but you can also do other things that are not programming, which makes Eclipse a programming environment. Just like with Excel.
https://docs.microsoft.com/en-us/office/vba/api/overview/exc...
They avoid that label because of their target audience but the label absolutely applies.
This also made the area palatable for other commercial competitors to enter the space - Google-sheets drive A TON of enterprise org work nowadays.
You could say that open-source alternatives immensely popularized spreadsheets and resulted in the very nice ecosystem we have now.
Sure, heave finance user stick to MS Excell because MS is pressured to cater very well to their needs, else they will move away to other free or paid alternatives.
Also, there's a reason why multi-dimensional spreadheets are not more popular despite solving so many problems of regular spreadheets: all are proprietary and very different one from another - you probably pick smth like Quantrix (https://quantrix.com/products/quantrix-modeler/), and you'd get insane prices and 100% lock-in... better stick to Excell and/or its open-source and/or free alternatives despite being a worse tool :)
- Is "Wolfram Language" the language used in Mathematica notebooks? Or is Mathematica a separate language, implemented using Wolfram Language? What does Mathematica add to Wolfram Language?
- I assume the Mathematica language is interpreted (not compiled) so it can be used in interactive notebooks. Any info about what its interpreter is like? I'm guessing it is compiled to byte code prior to being interpreted?
- How are symbolic expressions represented? Are symbolic expressions a distinct data type? Can you write a function that takes a symbolic expression and computes the derivative (I'm sure such a function is built in, but does the language let you implement a thing like this yourself?)
- Is there any kind of static typing, or is everything dynamically typed?
2: It is usually interpreted but can be compiled. If you RTFA there’s plenty of information about new compiler functions.
3: All expressions in Mathematica have the same form. For example 1+2 is just shorthand for Add[1, 2]. Think of them as M-expressions from LISP (kind of). These can be evaluated or manipulated. Symbolic expressions are not fundamentally different from other types of expressions. Indeed everything is a “symbolic expression”.
4: Wolfram Language/Mathematica goes to great lengths to hide this from you. Indeed again if RTFA you’d have read mentions of this with reference to interfacing with C code.
The symbolic evaluation is pretty novel. I assume it's not _just_ an AST. What do those structures look like?
What is the scoping? It feels like the emphasis is on global variables everywhere, but is it more subtle than that?
Are the data structures what we expect? Just in this post, Threaded implies some abstractions there. I would assume that some kind of "deferred" values are pretty typical throughout, is there a formal notion of that? A lot of it is deliberately hidden in the language, but I assume you can write code that handles that stuff directly.
Speaking of derivatives, I assume you can indicate how to take the derivative of new kinds of functions. How does that work? Generic functions, object oriented, ad hoc registries, or something else?
Data structures: you have special syntax for lists and "associations" (dictionaries/maps/hashtables). Those are immutable objects, but in at least some cases the implementation has an optimization where it'll directly mutate the object if there is only one reference to it. There are other data structures with no special syntax in the language, for example numeric and sparse arrays. A number of mutable data structures have also been recently introduced: https://reference.wolfram.com/language/guide/DataStructures....
One thing that you might expect to be a special data structure but actually isn't are "pure functions" (anonymous functions). There are actually just the unevaluated expression, so you could programmatically inspect the body if you so wanted to.
Deferred values: You can apply the HoldFirst/HoldRest/HoldAll/HoldAllComplete attributes so during evaluation they receive the corresponding arguments unevaluated. You might think this would make metaprogramming be easy, but it's actually tricky because of the "infinite evaluation" (it keeps evaluating until a fixed point is reached) of the language.
Derivatives: It's a term rewriting language, so you just provide the rewrite rules like you would with any other user function. f /: D[f[x_]] := x^2 will define the derivative of f(x) to be x^2, and associates that definition with f so that rule won't have to be checked for all usages of D (this also saves you from having to unprotect D to add the rule).
Mathematica is the Wolfram Language plus a user interface similar to the Symbolics Dynamic Listener that acted as your command line front end. Jupyter Notebooks are quite similar since the idea of a scientist’s or engineer’s notebook where content is “live” is a pretty common one.
That can be seen by the clumsy implementation of lexical scope (renaming vars, etc.) in Mathematica or the limited compilation of the Mathematica language.
Mathematica is the star of the show. Its a large collection of specialty libraries and tools, with (mostly) very nice documentation, that all interoperate together well.
You can literally take a screenshot of something on your computer and copy paste it into a Mathematica function for image recognition or whatever and it will take it. It's a lot like a lisp machine in some ways. You can do advanced symbolic calculus, optimization, ML, 3D visualizations, audio processing, geographic visualizations, it has an import function that can handle practically anything, connect to databases...etc etc, all in a consistent way. Worth a look.
Also nitpick but you can run Wolfram code without Mathematica directly using the Wolfram Engine.
Correct me if I’m wrong but it held that this specific case was fair use, not that structure, function name, etc are not copyrightable. While it does give a huge precedent case, code in itself is still under copyright by default.
But IANAL.
(I am a lawyer, but not your lawyer. Not legal advice, etc.)
Hard to rationalize "unprecedented" with a lack of a Git-repo link for scientific software.
In R, packages are developed by separate authors. Similar functions don't have similar interfaces. There's no unity of style.
In Mathematica, much more careful thought was given to everything, including at a very basic level: names of functions.
Now I'm a big fan of the Tidyverse, and the fact that such a post-hoc language cleanup was possible (and done) is amazing... but the fact that it was necessary [1] is not.
[1] Really not intending flame-bait. This is an opinion that many people disagree with. Perhaps like systemd. It isn't the substance of this comment, it's just the context for my remarks.
I'm sure Mathematica could be great too, but I'm not sure how big of a community it has.
I’m going to be honest, even RStudio sucks compared to PyCharm. Like really sucks. I almost believe people who love RStudio have never used a better IDE or don’t have serious software development backgrounds to know that it sucks.
For data science, R is probably better, just because of the wide range of common and niche statistics software.