Free Wolfram Engine for Developers
blog.stephenwolfram.com
blog.stephenwolfram.com
It’s not open source.
Even if the engine is “free”, I don’t want to build an open source product with it and hope to be granted a “free production license.” If I build something on my own time I don’t want to ask my employer to purchase a “production license” as soon as it becomes useful.
Wolfram believes that mathematics software (or “computational knowledge” or whatever he calls his entire enterprise now) must be proprietary and paid-for in order to exist. Maybe it’s true; all of the successful and wildly popular computer algebra systems are closed source. (wxMaxima is rough to use, Axiom has 3 or 4 different forks, each with fewer than 10 developers, SymPy just isn’t there, Sage is absolutely wonderful but not polished or easy to deploy, ...) But that’s completely at odds with how most software engineers work these days. Most software is grounded in an open source development and deployment tool chain. There is a market for proprietary developer tools, but it had been dwindling since its prime-time in the 90s.
I think Wolfram needs to think quite hard about how he wants to get his technology in the hands of developers while maintaining a business. Not that my opinion matters, but if he can manage to do it by open sourcing Wolfram Language, Wolfram Engine, or something like that, while keeping his business intact, I might again consider him to be the genius he was lauded to be in his 20s.
Although, perhaps this step is kind of a result of stagnating growth, IDK.
The reason for its dismissal goes a bit deeper than the simple fact that it’s not open source. We pay for other software (like E&M solvers), why not this? Because its use is not compartmentalized. It’s a programming language with the world’s most expansive standard library. Just as is the case with—say—Python, folks using this have no end to what they would build, including company IP. The code would absolutely not be portable, and your tech stack would be vendor-tied. That’s a danger zone for any serious enterprise.
I learned this lesson (albeit from a distance) when Microsoft killed off Visual Basic 6 and replaced it with Visual Basic .Net.
A closed source solution, where all you have is documentation (potentially flawed), including manually authored change information, just feels archaic at this point.
Companies should derive that trust factor from other factors based on their unique circumstances. If you are Amazon's competitor for instance it is probably not wise to use AWS for anything, but if you are a startup it could be very wise to take a bit of lock-in to avoid rolling your own infrastructure. If you are an established company maybe use AWS but in a way that you could move to another provider without too much pain, but balance that against some of the goodies you get by staying locked in.
I guess the same nuanced considerations have to be made to decide to use Wolfram Engine or not. There is no clear answer that suits all end users.
I've been reading as much as I can on RMS's site recently because I want to expand my mind on these sorts of topics. I really want to understand how "free" software can work at a practical level, where you say "here is a piece of software, it's $1000 from me, and you are free to give it to your friends, modify it, and resell it, even to people who would have paid me $1000, but now they wont need to" and how that ties in with making a sustainable business. I think it takes some luck and good imagination to make such a business work by selling some by-product such as consulting services or whatever. But for a lot of companies non-free is required in my opinion to exist as a business. Happy to have my mind changed.
With AWS, you can pack up and go to a different cloud provider, and get the same Linux and the same gcc and the same TCP/IP stack. There's probably some other code you'd have to change, but the essential core is non-proprietary and nobody can take it away from you. Abstracting further, if Linux decided to go in a weird direction, you can get a POSIX-conformant Unix-like OS from other groups, like FreeBSD or Illumos. The Linux codebase can be forked as well, providing an even stronger insurance relative to what happens when some company's or business unit's incentives no longer align with yours.
And that part about aligning incentives is powerful. In the closed-source world, it's also fragile: One company being bought out can shift things tectonically for all of the software that company made. It becomes a treadmill, or a movie routine of constantly jumping from platform to platform as each of them dies off or is pulled out from under you as "corporate synergy" realigns strategic chakras feng shuis your old codebase into worthlessness.
If you are "seriously" using AWS: A lot. Value of AWS is not that it offers compute nodes. But a full catalogue of further services and tooling APIs and migrating of that can be a big project.
maxima has existed for ages, maple has very similar fatures
The parent said it doesn't compete "in the breadth or depth of Mathematica" and you responded with "it does compete because it's free!"
Your response does not refute the parent's argument.
Maxima is just a computer algebra system- one small part of what Wolfram does.
1. It is arguably the most sophisticated CAS available. Open source tooling has crept up in performance and completeness in recent years, but Mathematica still dwarfs every open source system in performance and feature availability. Competing proprietary systems like Maple are capable of beating Mathematica in certain specific domains (like PDEs), but that leads me to my second point.
2. Mathematica isn't just a CAS. It also supports sophisticated data analysis and ingestion, visualization, (some) machine learning, natural language processing, speech recognition, signal processing, climatology, meteorology, geography, financial analysis, and limited forms of convex optimization.
Doing it in one big jump would probably impact revenue so much that it would take too long for them to grow out of it. Hopefully this change will increase their growth rate without much change to revenue, making it faster to grow out of, and prepare the way for further changes.
My question is: do you use Google?
No one asked about programming languages or standard library (except you when you misunderstood my question).
Therefore you implied that a good reason not to use a technology is that it's not open source. Literally.
Then why are you using Google?
Really, with the kind of license proliferation that was going on due to every Tom and Harry that wanted to publish their own license, it was difficult to understand which license was really safe to use and which wasn't. FSF and OSI stepped in to bring some sanity to this situation by categorizing all the free and open source licenses by their permissiveness and restrictions. The majority of the open source development community adopted these licenses.
Any license that restricts making money would neither be considered a free license by FSF nor an open source license by OSI. The license could discourage making money without contributing back to the community and the GPL family of licenses do achieve that to some extent but they cannot outright restrict making money.
The OSD has its roots in Debian Free Software Guidelines which for a long time has been the community standard for what guarantees free software must provide. FSF's four freedoms of free software are also similar. OSD adopted Debian's guidelines to create the open source definition.
If a license does not allow us to run a software how we wish we lose freedom 0 to run the software how we wish. We lose the right to use the software for any field of endeavor. You might want to consider it "open source" because you can still see the source but widely accepted terms like "open source" do not get redefined so easily based on how some people feel about the term. The term's meaning still remains intact due to the meaning it holds for the vast majority of open source software developers.
There are other terms for source which is available but proprietary, such as "shared source".
and using an AGPL licence, there would be no danger for them!
TimescaleDB has a good blog post about why they went this route[0]
I do think that perhaps we need to stop being so snooty about OSS vs open source, and recognise that companies with open source products are allowed to make a profit while preventing the big cloud providers from scalping them.
[0] https://blog.timescale.com/how-we-are-building-an-open-sourc...
The problem of big cloud providers ripping off OSS works is a new one, but it is explicitly allowed by OSS licenses - really not sure what a "good" solution is here, but personally I like the route TimescaleDB has gone down.
Please explain how/why FOSS is human birthright?
Making good software requires significant effort (both up-front and on-going) and being compensated for that effort is reasonable
Azure and AWS already have competing stacks to Wolfram, it is just various and sometimes incompatible hodgepodges of R, Python, Jupyter, and so on and so forth.
If Wolfram open source their stuff and people use it, it won't necessarily be a vindication. At the moment they have people who are willing to part with cash to get what they make. That's a definite vindication for anyone who makes things.
Imagine saying this with a straight face. Maybe in web development, but the vast majority of programmers are using closed source tools to produce closed source software.
You're either thinking of a tiny picture vs the whole picture (web devs vs programming in general) or you honestly have zero concept of what programming looks like outside of web apps.
It's Excel for engineers.
The Matlab IDE is not bad though and is a lot like Python's Spyder IDE. Also, a lot of Matlab commands have fully browsable source provided I've been told.
Except for perhaps optimizers (which some of the best are closed source, e.g. Mosek), the entire rest of the stack is open source.
Neither is the hardware, nor is Intel’s or the Motherboard’s, etc. Would it be ideal? Sure. Is it possible to have every level be completely open source? Maybe, but you’d struggle.
I still believe the point is clear, though.
In my lab, we attempt to use as much open source software and parts as is possible without literally spending years waiting for RISC-V to become mainstream along with fully open source GPUs and computing cores, open motherboards, RAMs, etc... this doesn't even include fabrication or other useful software which runs our machines (do you want to have a several-million-dollar photolithography machine running on poorly maintained OSS?). Yes, should that machine be open in a perfect world? Of course, that would be incredible and in the spirit of verifiability. But right now it is not and there is little we can do about it.
It's clearly impossible (or completely and utterly impractical) to pretend that somehow everything can be done in a fully open source way, and it's easy to go down the rabbit hole pretending to be on the high horse of "our stuff is more open." My point is that what can be made with OSS, we almost always attempt to make with OSS, not everything we make is perfectly open and transparent, because it literally cannot be without so much effort as to render the entire thing completely useless.
So, sure we use Mathematica in some things when the OSS alternative is mostly unworkable or unusable, but by and large we attempt to be as open as possible such that people can verify our results without needing to spend thousands of dollars on software whose internals we don't generally know. Do we rely on Intel software and hardware which could have another floating point bug? Sure. But it's hard to be at all productive if you don't at least assume a bare minimum, even if that standard is not completely open.
Proprietary closed source has a built in mechanism for funding. That's a major plus.
Like Intellij?
What programming language stack do you (and a lot of other developers) use that’s closed source with no realistic open source alternative? It’s not C, Python, Java, Ruby, JavaScript, Lisp, Fortran, C++, PHP, Perl, Go, SQL, Rust, Objective-C, or Swift? (All of these, of course, not only have industrial strength FOSS implementations, but the first or second most popular implementation is the FOSS one.)
It seems like using the SDK in your language of choice would be a reasonable way to leverage the engine where it makes sense.
>What programming language stack do you use that’s closed source?
Verilog/System Verilog (generally HDL/FPGA/ASIC design/verification).
Yes, it's a niche (some may even say it's not software, it's hardware, but it is indeed a large code base that requires a software engineering environment/toolchain/practices/etc...). Again, just answering your question for the benefit of the discussion. It would be interesting to hear of others such closed source areas.
[0] https://en.m.wikipedia.org/wiki/Q_(programming_language_from...
Wikipedia has an article on Time series databases and they contain a short list of popular TSDBs [0]. On that list 11 are libre-software to some degree and 4 are commercial. Relational TSDBs are new to the open source space but they're still being built despite there being the existing kdb+. This shows that people will spend considerably more funds to engineer a replacement (and give that replacement away for free) to avoid using a closed source product for this use case.
[0] - https://en.wikipedia.org/wiki/Time_series_database#List_of_t...
Market adoption could be better, but the license costs around $100,000/year (probably the most expensive software per kilobyte). Fintech can afford it, other industries can’t.
They have a an SQLish interface, that allows non-specialists to get work done, but anything serious needs to move beyond that.
I haven't used it in a few years, but queries had to be carefully optimized -- swapping the order in a where clause could cause order of magnitude differences in performance. Also it is append-optimized. If you need to update or insert data, it is a nontrivial exercise.
This seems pretty much next generation k.
We can see how things goes.
Single machine, because it can't handle parallel queries, at all, and there are no options to scale it.
Every financial institution I've worked at is busily unwinding their investment in q/kdb. It's legacy tech.
I even met a programmer who hacked something together in Java using the same columnar kdb layout but, you know, multithreaded, so different basket optimization jobs could run simultaneously on the same store.
[0] https://www.reddit.com/r/FPGA/comments/a5pzs5/prediction_ope...
For my comment I was thinking about HDL simulators, which are very expensive/proprietary tools (vendors like Synopsys, Cadence, Mentor Graphics), with a lot of vendor lock-in, but yet are based on standard/open languages: Verilog/System Verilog. I know there are some open-source simulators that have been around for a while, but they aren't widely used, and the big 3 EDA vendors still seem to have a strangle hold on the HDL simulator market.
Simulation is generally more important for ASIC hardware than FPGA hardware, since you can quickly iterate on an FPGA design with logic/design fixes, whereas with ASICs design iteration can be prohibitively expensive and time consuming.
1) If there are some widely used open hardware devices or open standards. The fact that FPGAs are proprietary designs and can't be copied is a significant barrier. If there was an analogue of ARM in the FPGA world that could open up open source dev tools too.
2) DIY FPGA. This one is almost certainly much further down the road than any of the other options. But if fab and design tools of the chips themselves become a commodity then there will be open source dev tools. It used to be pretty difficult to make a custom PCB, but now with PCB as a service open tools are seeing more use. I think the reason this is so far down the line is because fpga offers cutting edge performance for specialized applications. If you wait several generations or are ok with reduced performance then you can stick with generic CPU/GPU. With Moore's law running down there may be more and more things that aren't possible without fpga. And I don't think it would be until then that open source dev tools follow more diy fpga.
There is an open FPGA hardware implementation:
https://github.com/haojunliu/OpenFPGA https://www.eecs.berkeley.edu/Pubs/TechRpts/2014/EECS-2014-4...
More resources:
But the IC/hardware toolchain is a separate issue from the design itself. It's largely proprietary, probably due to the niche market and large R&D costs involved in some of the tools.
https://riscv.org/ https://openrisc.io/ https://www.mips.com/mipsopen/ https://en.wikipedia.org/wiki/SPARC#Open_source_implementati...
http://iverilog.icarus.com/ https://www.veripool.org/wiki/verilator http://www.clifford.at/yosys/ https://symbiflow.github.io/ https://github.com/Qucs/ADMS http://www.myhdl.org/ https://chisel.eecs.berkeley.edu/ https://wiki.debian.org/FPGA
I’m aware of chisel used to verify some RISC-V cores that were fabricated, but that’s a research POC, not a volume/production ASIC.
We have chips shipping in volume.
I think Python definitely wins as a scripting language lingua franca though. It is free as in beer, open-source, available on any OS I care about, and most of the software I use has a built-in Python API.
Mathematica is big in academic math and physics programs, but I haven't seen it in industry as much as Matlab. Believe it or not, my company had a major accounting application written in Mathematica, so it does pop up in weird places.
IME even getting binaries from an antenna vendor can be like pulling teeth, are there some good open source solutions out there?
Matlab?
MATLAB
I suspect it was phrased strongly because the GP made the same claim in the opposite direction: "Most software is grounded in an open source development and deployment tool chain".
Are you serious? I don't do web apps. But almost 100% of our stack is based on open source technologies. Python, Twisted, Go, etc. Every single thing we use is open source.
It is ironic that you are accusing someone else of having zero concept of what programming looks like outside of web apps when one could easily think the same thing about you.
And even most Go software is proprietary, hidden behind Google's bar.
GCC was so revolutionary because it brought a pro-level (although not at the start) compiler toolchain for free and allowed developers who were so inclined to improve and modify it.
And lots of Python code is for things like machine learning, Go runs lots of DevOps/neo-infrastructure stuff, and I can’t comment on Twisted.
Admittedly I go out of my way to avoid including closed source components in my work but that's not just an ideological decision. As the parent points out, and especially when you're a developer, there's a massive amount of freedom and power to open source tools. Don't like something? You can tweak it any way you like. You don't have to worry about the IP owner pulling the rug from under you without notice. I want to use that code on my MIPS32 target? I can try to port it, I don't have to beg the vendor to release a version just for me.
If anything in my experience the archetypal "modern web dev" crowd (the one that got into programming through Javascript, basically) is the one that benefits the least from this because often they don't dare to patch their window manager or their shell to customize them. These days C is often considered a weird arcane language, something like the Latin of CS (including in this very forum) so people don't feel empowered to modify these applications. The fact that modern DEs like to treat their users like slow children instead of exposing the tools that could help them become "power users" probably doesn't help.
Then of course for people who don't actually try to read or modify the source of the programs they use "open source" is more of a political statement than anything else. There's no real benefit for them.
I'm making generalities of course, I'm not saying that all web devs fit this description.
I hope this trend will change as newer, more "friendly" languages like Go and Rust make forays in the system programming space. Hopefully that'll motivate the new generation to get over their fear of system programming and start embracing and customizing the tools their use.
Not at the GUI level. Xcode and Instruments make use of open source toolchains underneath, but aren't open source themselves, nor are the Apple frameworks they're built on.
To give some more pushback on this assertion... I've been developing software for 21 years now, and the only positions I had where there was negligible open-source software were in the first couple of years (in the automotive firmware space [OnStar], and a brief stint in some defense contracting). For the last 18-ish years--firmware, systems, enterprise, virtualization, demos, security--everything I've worked on has largely been based on open-source software, or the product was open-source itself. What I've never done professionally: Web app development.
Honestly, I think it would be hard to overstate the prevalence and impact of open-source software in the field of programming (and really, the entire tech field).
(No, being able to use a sandbox is not sufficient to properly learn any language because that's not how you use languages to build stuff)
And before anyone says how important Wolfram Engine is and that this is the going rate for specialized software: nobody cares. Because you are probably wrong if history is any guide. Lots of software used to be niche software and isn't today. Things change. If it's expensive and only available at a steep price, then only those who need it will buy it. The curious will get their kicks elsewhere.
There used to be a time when database professionals stomped their feet and yelled if you suggested Oracle might consider a Linux port of Oracle. "Impossible! People who use Linux aren't into paying for stuff!". And then it got released and then Linux became its most important platform.
Things change.
In order to get people to include it as an infrastructural component you probably have to ensure that it is free for non-commercial use. I'm not sure if you have to open source it. I use lots of stuff that is free for non commercial use - and then I use it commercially and pay for a license. Occasionally really expensive licenses.
I've looked at Wolfram Engine a few times, but in the end we never used it because it just didn't have a great enough following among programmers. I couldn't just tap into a talent pool when recruiting. It was hard to find experience.
I tend to choose tools based on the _people_ I can find to use them. In fact, usually the people I find choose the tools. That goes for how I choose languages, software, cameras, cars, motorcycles...you name it. No vibrant community means I don't buy in. And sure, there are lots and lots of cameras that are better than mine in that price range. But the cameras are not all that important. The people are. Who I can collaborate with, who I can learn from, who can help me solve problems.
Also, it tended to be a bit on the expensive side for what I wanted to use it for. Sure, I could have contacted Wolfram and said "look, we want to use it for this, but the licensing model doesn't quite fit", but how many developers do this?
(I remember thinking about buying Mathematica several times to tinker with it, get to know it and then perhaps see if I could use it for something. But it was expensive, and I'm not spending that amount of money for something I'll maybe going to play a bit with and then perhaps forget for a year. This too makes Wolfram Engine a bit of "interesting, but I'm not going to invest time in it".
And I can't say I've ever blamed Stephen Wolfram for it. He has a product that makes a bunch of users happy and him rich. Who am I to tell him that he should do things differently? So he exists over there and I exist over here and everyone is happy.
I'm excited about this change. I wish it had happened sooner so it could have had more of an impact. It certainly put Wolfram Engine back on my radar.
I'm not talking about the dollars, that's relatively minor. It's all the things around it, especially with licenses becoming more complex, including core counts, including all these weird provisions related to when and how and what features can be used in dev and staging and production, what versions of other software they can work with, etc...
The software that we can buy and just use without thinking about it is great, but it's really few and far between these days.
We can spend weeks or months analyzing the things surrounding the commercial licensing for a product, and that is spending one of our most valuable resources: attention.
That depends on the software development segment. If you are creating 3D games you would expect to build on top of Unity or Unreal because unless you are a major studio building the infrastructure yourself is expensive, slow and not as good. The question is "is computation" such a segment?
His response belittled the question, calling it naive. His smugness was astoundingly tone deaf.
Until he figures out how to answer questions like this without using shame to cow developers into line, I’m staying away.
Not to mention the fact that probably he doesn't own all rights for doing that. Software with such a history often contains third party licensed modules.
that is simply not true and a rather insular view. i build large complex systems, and all of it is done with proprietary software. in fact, it is practically impossible to do my job exclusively with open source software. most open source software is completely unreliable and ill-fitted for many domains. and just try getting good support for use cases only found in industrial use from most open source developers. i have tried, and it never works out. the response is usually "you figure it out and let us know".
furthermore, a lot of proprietary software is fairly open source in that you get access to a fair amount of source code. and it isn't dwindling at all.
“Source [partially] available” and “open source” are generally considered distinct concepts these days. See for instance [0] or even look up what Google’s dictionary says about the term.
[0] https://en.m.wikipedia.org/wiki/The_Open_Source_Definition
This alone makes your "uncommon" claim void, and there are other examples outside of the Windows ecosystem equally well-rooted in proprietory tools.
I would say Windows development in Visual Studio is by far uncommon when you compare with technologies like Python, C (with GCC or Clang), Java (OpenJDK), JavaScript, etc.
Now if MS had their own language (they did...) that was closed source (it was...), the argument would be more akin to this Wolfram debate. But MS learned that wouldn’t fly, and adopted an OSS strategy.
>> Visual studio
> I don't think that's a strong argument
Lovely talking to you.
WL is essentially just a bunch of useful functions collected into a common platform, and I think we already have the open source equivalent of that - it's called npm, and it's great, but it is very different, and it has some pretty big downsides which are the direct result of it being an open source project rather than a commercial product. I don't know if WL is as elegant or high-quality or deeply functional as Wolfram claims, but if it is, isn't that likely a result of it being built the way it's built?
It might be that there's a middle option - a way to open some core part of the language, while still keeping enough closed to make up a service layer that they can charge for, as you described - but today's announcement is pretty strong evidence that they considered that and rejected it. It seems pretty presumptuous to assume they got it wrong.
With that said, I don’t speak for everyone! If folks find this tool useful, love writing Wolfram code, have no expectations about the portability or maintainability of the code, trust Wolfram and the contract to which they’re agreeing, then by all means! More value for people is better!
I'm a bit puzzled about how strongly you seem to be feeling about this topic. Given your comments, you seem to be quite far from the target audience of Mathematica. It's not for software engineers. Most productive work done with Mathematica is not "building software" ...
But given all this hostility, have you downloaded it, and have you tried it? Or is all this just philosophical (i.e. the least interesting) criticism? There seems to be no experience backing your comments.
I hope folks aren’t finding my comments hostile. I have used the Mathematica product before in their GUI and at the command line, and some of my colleagues use it for various calculation tasks. I’ve opted to stick to open source alternatives like Sage, wxMaxima, GAP, and Axiom/Fricas.
The engine doesn’t give you a license to Mathematica, so I don’t presume the target audience is the collection of folks who want to do differential equations with plots. The article emphasizes lots of software things (languages, integrations, etc.), so actually I do believe they’re targeting software engineers.
You should note that I have not criticized their features, but rather restrictions on the use of the product in the first place . Maybe that would be interesting to read, but instead I have commented on the leading question in Wolfram’s article. I have not and will not download their Wolfram engine in its current state though for the reasons I’ve outlined. Do recall that using it means I’m bound to a legal contract, and that’s not one I’m willing to engage with.
[0] https://arxiv.org/abs/1904.10541
[1] https://github.com/rigetti/quilc/blob/master/src/compilers/a...
As an old Lisp programmer, it makes me feel good seeing CL applications.
I broadly agree with your points in this conversation but I am downloading the Engine right now. I also did a ten day free trial of Mathematica recently. I have a little time to spare to kick the tires.
BTW, in the same way that Keras has functionality to download some standard data sets and cache them locally, I would like to see more CL projects do the same. Julia has a few such packages. Having easy to access data is a selling point for Wolfram Language.
As such, this comment:
>But given all this hostility, have you downloaded it, and have you tried it? Or is all this just philosophical (i.e. the least interesting) criticism? There seems to be no experience backing your comments.
does not seem to apply
1 Fear of losing control (over their vision and centralized design of computation and representation of the Wolfram language).
This is just false, as they would be in control over their project even if open-sourced.
Forks would be possible but would not influence the original source (if not wanted).
I cannot see why this would be true.
I see how that could be a problem. One solution would be funding (s. point below)
to pay devs for the boring stuff.
Their main point (and probably a big issue of a lot of other companies
thinking about open-sourcing their software) and a very valid one indeed.
@Wolfram: The most important assets of Wolfram are the devs. working there, not the software itself. Given this huge knowledge base around the topics covered by the Wolfram language, the support-business-modell could very well work! Also from a philosophical point of view: Wolfram claims to unify disparate fields of all of science which kind of is a scientific achievement on its own. Scientific results should be available for all people of our society.
Having used the Wolfram Language and Mathematica professionally for over seven years I think this is much cooler than the people who greenlighted this within the company realize. If there is one thing I love about the Wolfram Language is how fast it is to prototype something with it.
Given the scope of the language (or what you call standard library), most things that would require finding some external dependency, then writing some shim, are there out of the box. Whenever I have a weekend project idea it's always very very fast to prototype in the Wolfram Language.
Now, you don't want to use it in production because it's not open-source, fine. This license doesn't even allow that use anyway. But if you want to do a prototype, some MVP for an investor demo, a hackathon, then it's free and it's extremely powerful.
Most of the complaints here are about why you wouldn't build a company on our tech stack or why non-libre software is bad in production, but building production software is not what is being given away here, all the rest is.
Actually, the cases you described, making an investor demo or the like can be argued to be prohibited by the license! Does an investor demo or MVP count as commercial use? I’d say so. Would an MVP potentially produce data that I might use in the production of a “real” system? Likely so. Both of these are expressly prohibited by the license, straight up in the first section.
“Yeah but you’ll get away with it fine.” Will I? I also must respond to Wolfram with a record of my use within 10 days of being asked.
How is this an attractive state of affairs to build anything, even for paltry testing of an idea?
I think your worries about what is kosher and what isn't under this license are warranted and I'll try to point this to people internally so that the licensing terms can be clarified.
If Wolfram adopted the Unity model I’d be much more willing to try it out. (free to cheap for hobbyists and small businesses, steep rise in price based on revenue per year)
That makes it a no-brainer to use--you pay little or no licensing fees until your game takes off. Unity makes their money off the unpredictable winners, while gifting a nearly free product to the hobbyist and startup ecosystem.
Wolfram Engine is more like the Epic Games (Unreal Engine) model: free to download and play around with, but steep licensing costs before you ship anything. No way to quickly iterate and try things, only paying up when an experiment works out.
It just seems so unnecessary when you have a language where you can start out in a highly interactive state that seems a lot like Python or Matlab but then you can seamlessly start optimizing or generalizing functions and end up with something that runs basically as fast as C but retains all the dynamic advantages from the prototyping phase.
Yes, Julia's namespace isn't as polluted as Mathematica's is and I think that's a good thing. It's got an amazingly vibrant package ecosystem and packages are treated on such a first class level that as soon as you load a (well made) package, it composes so well with everything else, including other packages that it feels built in. I've never really felt like I was 'writing some shim' to utilize code from a julia package.
Sorry, couldn't figure this out from your comment whether you prefer Julia or some other language for doing the prototype and full implementation. If you can clarify this explicity, it would be helpful.
I find this approach to be straight up superior to the usual pattern where one starts out in a slow dynamic language to build the prototype and then either replaces certain functions with interop calls to a fast language (losing all the features that brought you to your dynamic language in the first place!) or straight up replacing your entire prototype with a production version written in your fast language and providing bindings to your slow language.
My understanding though is that most of the statements I made also apply in CL though my impression at least from the point of view of scientific computation is that Julia's community is more energetic than CL's. Certainly Julia still has lessons to learn from CL though.
Source: I do computational biology with Julia, hobby projects in Common Lisp.
http://p-cos.blogspot.com/2014/07/a-lispers-first-impression...
I’d like to come back to CL at some point though and gain some proficiency as I think there’s a lot in CL left for Julia to learn from.
What I think is missing is a stripped down open source implementation / interpreter. What Gnu Octave is to Matlab. That stripped down variant could or could not share some code with the proprietary implementation (realistically, Wolfram would need to open some parts of their code).
I think octave is invaluable for helping Mathworks: Professional users will almost surely buy a license, but a lot of matlab/octave code can be run and hacked on without a mathworks license (albeit slower, and missing a lot of cool features).
The way it is now, all code written by scientists in the Wolfram language is essentially hostage to Wolfram. An octave equivalent would permit people to trust that they continue to meaningfully own their own code.
It is super unlikely that a stripped down slow but open implementation would ever improve to the point of being a meaningful competitor: The thing Wolfram has built is impossible to replicate in the open source world.
Sure, there are other computer algebra systems and other frameworks / languages, but these have very different strengths and weaknesses that make them appropriate for different niches. E.g. sage permits seamless interfacing with the entire python ecosystem (never write a parser or networking code in mathematica! Everybody and his dog publishes python bindings to their C++ libraries nowadays). Or julia with its multiple dispatch and late-AOT/JIT approach that permits permits to write super fast dynamic code that is Fortran / C / C++ level fast.
"You can use it to develop a product for yourself or your company."
“Audit
You will maintain accurate records of Your use of the Free Engine sufficient to show compliance with these Terms and Conditions, and Wolfram will have the right to audit such records to confirm compliance therewith. Upon written notice of an audit from Wolfram, You shall respond within ten (10) business days.”
“You can’t use this free thing to make other actually free things.”
I don't even know what either of those mean and I've been coding and on HN for years. I'm not even sure how to pronounce the first one. In Australia at least, 'free' means it doesn't cost money.
https://en.wikipedia.org/wiki/Gratis_versus_libre
Gratis: "Buy one, get one free."
Libre: "You are free to leave."
Read in a very stringent sense it is tantamount to keeping a "laboratory log", which is much much more complex than git.
(What about some computations you used to help somebody out of your project?).
"We're losing mindshare and customers to open-source alternatives."
Great open-source alternatives to Wolfram products can be found in the ecosystems of projects like Jupyter, Scientific Python, TensorFlow, PyTorch, and Julia, to name a few.
Major sponsors of such alternatives include Alphabet, Facebook, and Microsoft.
It's hard to compete against that.
When I was a grad student in economics, we had to solve really, really long algebra problems as homework. I used Mathematica to see if I was doing the right thing, getting more feedback, and more personalized feedback, earlier than anyone who had to wait for the next class.
Presumably this isn't intended to cannibalize Mathematica sales so I'd expect that many of the things I'm used to doing in Mathematica wouldn't work here but I don't really see any discussion of what it can't do.
Or is it that it's missing the Mathematica front end but has a full backend kernel implementation?
So I was curious and signed up for a developer license. I got to the confirmation page, which helpfully told me to run "WolframScript" to activate the license. But there was no download link, so I googled around and found this[1] page. They seem to only have packages for Fedora and Debian-based systems, but no biggie. I used `debtap` to convert it to a package that pacman can install, and then, moment of truth...
$ wolframscript
WolframKernel not found.
Use -configure to set WOLFRAMSCRIPT_KERNELPATH
Or export WolframKernel=/yourpath/WolframKernel
So... it seems you probably need a full Mathematica/Wolfram license before you can use this anyway?
Well, that's disappointing.
EDIT: OK, you can actually download it from [2]. My bad.
[1] https://account.wolfram.com/products/downloads/wolframscript
https://www.wolfram.com/developer/
Its linked from the article.
I feel silly now, but that was pretty confusing.
You get a file `WolframEngine_12.0.0_LINUX.sh` about 1 GiB.
If you look on their web site for Mathematica[1] it has several bullet points that includes the Wolfram Engine. One of the other separate points is "Wolfram Algorithmbase"[2], so presumably all those algorithms are not part of the engine and only available if you buy full Mathematica.
The Algorithmbase is 99.999% of what makes Mathematica useful compared to any language with a decent REPL or notebook setup.
I can't really imagine a use case for the Wolfram Language if I'm not going to use anything listed in http://www.wolfram.com/algorithmbase/
I actually believe the Algorithm Base is probably included, but it's definitely anything but clear from the website or any of the press release. The Mathematica website makes them seem like two completely separate unconnected components.
It's really unclear what is included in Wolfram Engine and what is included only in Mathematica... the above was just one obvious example. It would be very nice to have a concise list.
I personally hate programming in Mathematica, but it is interesting and deserving of an open implementation.
Note that this free version only includes the kernel, not the notebook interface. But there is nascent support for Jupyter, so productive use is very much possible.
"I'd expect that many of the things I'm used to doing in Mathematica wouldn't work here"
What's amazing is that this isn't true. There are no _technical_ restrictions. You can't do Manipulate because the notebook interface is no there (or rather: it's there but it's read-only). But all the computational power is available.
All this talk about data-scientists only using open-source is ridiculous. At my university, departments like medicine, biology, chemistry, and life-science make a huge part. The most commonly used programs there are Excel and SPSS. Other departments use Matlab extensively. In finance, SAP is a big player. All of them are closed source and cost money.
Why can't people just appreciate that it is a huge step for Wolfram to release a free version of its kernel and think that this is an opportunity?
Most people here are complaining about the license, not the software. They think the software is good but the license is holding it down. To me this looks like valuable feedback.
> They think the software is good but the license is holding it down
The issue I'm really trying to point out is
They think the software is cost free but the license is holding it down
Wolfram Engine has always been good, but it seems people are more in a huff because it's priced free but not open source.
I.e expecting that if something is given to you at no cost, it also must be open sourced.
One other reason why people might be so upset here is the naming of this product. "Free" is commonly used to describe libre software. This is at best an oversight by the marketing team and at worst deliberately set up to deceive developers.
You don't have to settle for the command line. It works with Jupyter, which seems to be the most pleasant way to use it.
Is there a way to access the database without the language?
It then originally has a large library of facts and rules for a large amount of mathematical domains. This has been expanded over time into lots of knowledge about the world (physics, biology, astronomy, ...).
Programming is often done with multimedia-rich notebooks.
https://reference.wolfram.com/language/ref/entity/Planet.htm...
So it's some kind of knowledge-based system for mathematical related domains,
The editor is very different as well: Mathematica pioneered the notebook concept that was copied by Jupyter, and the Mathematica user experience is still much more comprehensive and tightly integrated than anything else.
For linear algebra, they both use Intel MKL under the hood and get exactly the same performance.
For what it's worth, both Wikipedia and the official Clojure website call Clojure a dialect of Lisp (https://en.wikipedia.org/wiki/Lisp_(programming_language), https://clojure.org/)
Clojure needs a total and complete rewrite which doesn't only affect the syntax but program logic. Thus Clojure does not run Lisp code. How can it be a Lisp when it does not run Lisp code?
Lisp is a family of languages - within which Scheme and CL are just as syntactically incompatible as CL and Clojure.
Other Lisps in that main line are Portable Standard Lisp, Le-Lisp, Emacs Lisp, ISLisp, ...
There are quite a few branches with less (Scheme) or more incompatible languages (ML, Dylan, Clojure, ...).
You're welcome to draw the line wherever you want, maybe for you conses are mandatory in a Lisp language but I don't really understand what you hope to gain from this discussion. I might as well say "tail call optimization is absolutely mandatory in any self-respecting Lisp, therefore CL isn't a proper Lisp dialect".
This is effectively the same level of discussion as a Java programmer saying that C++ isn't "true OOP" or an Haskell enthusiast claiming that Scheme isn't a true functional language because it allows side-effects. It's just silly gatekeeping that doesn't lead anywhere interesting.
If you want TCO in CL then use one of the dozen implementations which supports it.
People btw. used to write some non-trivial code which ran in both Scheme and CL with the help of a Scheme on top CL, a compatibility layer or a translator. But that's now relatively rare.
Chance that it does not work is high.
Now change the code that it runs. Chance that you had to rewrite the code mostly is high.
It's a dialect of Lisp in the sense that it is an incompatible branch / fork with a Java runtime (it's a hosted language) and a bunch of newer functional data structures replacing old-fashioned lower-level stuff from Lisp.
https://stackoverflow.com/questions/34347985/clojure-no-cons...
[1]: You can see the implementation of Clojure's cons cell here: https://github.com/clojure/clojure/blob/clojure-1.9.0/src/jv...
In Lisp cons cells are the basic data type from which lists, trees, cyclic lists, etc. are created,
In Clojure it's not.
Second, in Clojure, you can certainly make lists, trees etc. from cons cells. It's just that vectors and maps are more common.
Third, Clojure is not only a Lisp (https://clojure.org/about/lisp), but an exceptionally good one at that. I'm amazed that some people find that controversial. I love Scheme and Clojure, and the thought that they're not both Lisps -- something immediately obvious to any long-time Lisper like me -- strikes me as patently bizarre. Clojure is not only a very good Lisp, but celebrated among Lispers for facilitating Lisp's rise in popularity in recent years.
Lisp, too, has vectors not made of cons cells.
> make lists, trees etc. from cons cells
It's just that they aren't. Clojure uses persistent lazy sequences not made of cons cells as its basic data structure. And it has strange behavior:
user=> (conj '(1 2) 0)
(0 1 2)
user=> (cons 0 '(1 2))
(0 1 2)
user=> (class (conj '(1 2) 0))
clojure.lang.PersistentList
user=> (class (cons 0 '(1 2)))
clojure.lang.Cons
user=> (class (cons 1 2))
IllegalArgumentException Don't know how to create ISeq from: java.lang.Long clojure.lang.RT.seqFrom (RT.java:542)
Does not look like Lisp to me.
> Clojure is not only a very good Lisp
It's a good programming language, but not a very good Lisp - since it is mostly incompatible and lacks a lot of the usual Lisp features.
Clojure requires that the second element in the pair be an ISeq.
> since it is mostly incompatible and lacks a lot of the usual Lisp features.
I and many others disagree, including Clojure's designers, who designed it as a Lisp. Homoiconicity, macros, S-expressions and FP make a language a Lisp. OCaml and SML are about as different as Scheme and Clojure, yet no one thinks they're not both MLs.
Lisp doesn't have such a requirement and does not have 'ISeqs'.
> I and many others disagree,
That does not make a convincing argument, since you have never used an actual Lisp - as you recently said.
> including Clojure's designers, who designed it as a Lisp.
Derived from Lisp mostly as a blend of FP, Java hosting/integration and Lisp ideas.
> Homoiconicity, macros, S-expressions and FP make a language a Lisp.
Lists are deprecated in Clojure (for maps, sets, vectors, ...), No interpreter, no Lisp down to the metal, no Lisp in Lisp, no images, core Lisp data structures look different, different API, different syntax, impoverished REPL, strange numerics, Java leaking in many places, lots of compromises because of implementing it on top of a not-Lisp-friendly VM, ...
Lisp derived, but Lisp looks & feels a bit different.
Don't think of Mathematica as a computer algebra system. It is much more than that, fully capable of numerical computation, and just the unique term rewriting programming language makes it worth checking out.
Yes, of course they do. For example, if they want to obtain a general, symbolic, solution to a problem, rather than estimates of particular numerical values. I'm sorry to sound a bit dismissive, but on HN it is common to hear people say stuff like "Oh, I find code much more helpful than math" and it's a bit embarrassing.
Just to give one example out of the entire universe of human mathematical activity, suppose you're doing statistical inference. You've developed a likelihood model for the data-generating process, and now it's time to implement the actual inference, say in a Bayesian MCMC, or a rejection sampler, or importance sampler, or whatever. Those are numerical algorithms of course; but they need to repeatedly evaluate the likelihood function at millions of different points in parameter space. Now, your likelihood function, was developed to model the real world. And perhaps the resulting equations are a little complicated. You may be able to achieve a vast speed-up of your numerical algorithm if you use a symbolic algebra system to find/confirm a symbolic simplification of your likelihood function.
Aside: You're commenting in a style that fits YouTube, or maybe Reddit, but this site has a different commenting culture/style.
You can also write a inline script. https://pastebin.com/TYWfS3gk
Is there a limitation of running only one kernel per machine? I had an instance of wolframscript running, and when I ran a script file, I got this error:
> ./test.wl
Connection closed by WolframKernel. This generally means the product is unregistered.
https://www.wolfram.com/engine/commercial-options/
How can I figure out if it's worth investing the time if it's impossible to price a production license?
Warning: it's ridiculously expensive. You need to be charging your users 4+ figures per license for your software in order to be able to pay Wolfram their cut.
The open/libre stuff is a huge red herring -- cost is the real bottleneck. It doesn't make any sense to use Wolfram/Mathematica unless there's a built-in function that you NEED, for which there is no alternative, and which requires a team of PhDs to re-implement.
E.g., even a non-production single user corporate desktop license is $3K.
1. It requires a significant time investment
2. I can't see how it will be in any way useful to me.
Can people using mathematica ( PhDs, pros, mathematicians, engineers... ) tell me what awesome things they do with it ?
- It's arcane/esoteric
- Its capabilities are largely unknown (I have mixed results with wolframalpha even for simple queries. Perhaps programmatic model is more deterministic)
- Its licensing model is murky and needlessly complicated
Even he admits to this ,
" What Kind of a Thing Is the Wolfram Language? I’ve sometimes found it a bit of a struggle to explain what the Wolfram Language really is."
https://blog.stephenwolfram.com/2019/05/what-weve-built-is-a...
Wolfram|Alpha is a natural language computational engine which takes queries and computes custom answers based on back-end knowledge databases and a large amount of Wolfram Language algorithms.
Wolfram Language is a computational (programming) language. There is a good 'fast introduction' for it here:
http://www.wolfram.com/language/fast-introduction-for-progra...
The full reference documentation for the Wolfram Language is located here:
https://reference.wolfram.com/language/
(It's extremely well-documented with extensive examples for every function).
Which means you get access to the full functionality that Mathematica offers, just without the GUI notebook interface.
The developer page says try it for free and integrate it. Ok. Then it says commercial options for various scenarios exists. Ok. It shows a few scenarios. Ok.
Doesn't show a price though. When searching for prices it suddenly becomes "Find out about full applications" or "Contact Us " ?
Just looking at the dev engine you offer for download. what is the price of that ? What IS Wolfram|One ? What is the difference to the other options ?
Instead of making an easy decision as to whether its worthwhile to use some downloaded tech (which I still have to integrate no less) I have to wade through the page and different products or contact the sales people ? I also don't have any info as to how self-contained the engine is. How self contained is it ? Etc.
I was thinking of integrating WA before but had the same issue. Not something I would just add as a potential feature without making it a larger project with a specific customer in mind to be worth it for me.
Perhaps it’s an issue of standardization inside the organization. In that case, perhaps one might make an exception for the founder & CEO.
Based on great comments and questions, we updated the "frequently anticipated questions" to "frequently asked questions" (at midnight last night, on Stephen's laptop).
We have a feeling this will continuously be updated - please let us know if you have any questions, if something isn't quite clear, or just what you're going to do with it.
https://www.wolfram.com/engine/faq/
Cheers!
However, I think, what they should have done is have an open-sourced language runtime, and closed source some subset of the libraries.
In other words, keep eco-system open-sourced (and also protected from patent abuse), while maintaining some libraries closed source.
Perhaps, Wolfram believes that the competitive/money making advantage is in the engine, not in the libraries.
But if that's the case, then the open source competition is closer to beating it, than we think.
- it's a linguistic engine
- it has a query language
- there is a cloud you can use [1] if you don't want to host it on-premise
- it has high level API's for creating language models from JSON documents (or in other ways formatted)
- low level API's for creating whatever 64-bit vector space you might want
- tools that help you in the analysis phase
- tools for creating and deploy HTTP endpoints for reading from/writing to your model
Next week I'm freezing the API's for I will have reached v0.4, because by then, at my day job, we will have completed our first "AI powered" closed-sourced product based on Resin.
For this project to have any bearing and to stay alive and well (and free forever) I need your help. I need a community of contributors. Chip in, it's for a good cause!
Edit, and here are the links:
[0] https://github.com/kreeben/resin
[1] https://didyougogo.com (currently down, b/c maintenance)
Wolfram Alpha is a symbolic computation engine. I'm sure it does some natural language parsing for queries on the website, but I doubt that is an important feature for most developers considering this engine for production applications.
That's a great piece of technology to have when you are trying to get machines to understand humans.
The reason Resin is not a symbolic computation engine is because that model hasn't been designed yet. Luckily Resin is a vector space framework that you can use to nest spaces together or transform into new spaces. Building on Resins capabilities for creating models from any 64-bit embedding I'm not quite sure if there is anything Resin cannot model.
But I hear you. Resin is not Wolfram but more of a framework that you can use to produce something like Wolfram.
> my MIT licensed open source project Resin [0] does pretty much of what WA does
Does it? Resin looks more like an NLP framework at a quick glance. WA is an actual answering engine with data included. I fail to see a comparison. Not to mention the website is down.
Resin is a vector space framework. Upon that base I also built a NLP engine. And a chat bot. A search engine. Also, a anonymous profiler.
So, yeah, it's more than an NLP engine. But it's not exactly Wolfram. You're right about that.
> Your data ends up being represented as nodes in a graph that can be traversed by comparing a query (which is also represented as a vector) to nodes from the graph and use their cosine angle as a guide as to what node to traverse to next and when to stop.
Could be... at least a page, with some diagrams. Each node... is a vector? Has a property that is the vector?
The documentation is very incomplete. I'll fix that ASAP.
As a reminder, nothing in the Wolfram universe is really unique, nor it is the best individual implementation.
The selling point of any Wolfram product and its underlying engine is that it can do all these things out of the box, in one notebook or WA query.
I am not trying to be an ass. It just really seems you misunderstand the "competition". There is a failure path for your project:
It COULD do anything, but it actually CAN'T do much out of the box. This limits your target audience to people who want to implement WA themselves, but with a framework. Please do consider this is not what WA offers. At all.
Wolfram Engine can apparently access the full set of Mathematica features, just without the Mathematica GUI.
docker run -it wolframengine/wolframenginehttps://rulebasedintegration.org/
It's a package for solving symbolic integrals that outperforms many systems. It has an extensive test-suite of over 72,000 integration problems and I encourage you to try how many of them can be solved by SymPy or Julia. Spoiler: I already helped porting it to Symja and if the python community can solve the problems with MatchPy, the port to SymPy can be finished as well.
Disclaimer: I'm one of its developers
https://www.wolfram.com/language/11/image-and-signal-process...
https://github.com/WolframResearch/WolframLanguageForJupyter
Additionally, many IDEs support Wolfram Language for syntax coloring, command completion, contextual help, etc.:
Maybe someone can hook this into Jupyter as a Wolfram kernel?
https://github.com/WolframResearch/WolframLanguageForJupyter
Additionally many IDEs have support for Wolfram Language, e.g.
Eclipse: https://www.wolfram.com/workbench/ IntelliJ IDEA: https://wlplugin.halirutan.de/