tl;dr: The Wolfram Language is an ok 30-year-old language with a huge standard library. You can do really amazing things in a single line of code... as long as there's a built-in function to do that thing. Hmm.
I actually really like Mathematica as a tool for symbolic/mathematical stuff – they're the best at what they do best. But all this Wolfram Language stuff is just way overblown, and realistically a proprietary standard library – however huge – just can't compete with the open source ecosystems of Python and friends.
Agreed. Although I would not fully agree on Wolfram Language being fully "ok". As a long-time lisper (Clojure, previously Common Lisp) and a heavy Mathematica user I do appreciate the lispy aspects of WL. Yes, you can even write macros, although the syntax is painful.
I use Mathematica to solve specific kinds of problems. If there is lots of math involved, for immediate visualization, for data and problem exploration. But I always find it needlessly painful. The most important drawbacks are:
* The language syntax isn't as good as a sexp-based lisp. Editing complex expressions is needlessly complex and doesn't even compare to structured editing with paredit in Emacs.
* The interpreter is slow. Really slow. Sure, if you call a matrix math routine, it will be OK, but try rearranging large data structures and you'll end up waiting a lot.
* The editor is a disaster. I seriously don't know how people can stand it and how come the company invests so little in it. A single mismatched bracket can mean ten minutes of hunting for the problem. Code jumps around on screen all the time, seemingly with no logic to it. Syntax highlighting is nearly non-existent. It's a complete trainwreck and I don't understand why this isn't seen by the company as a huge problem.
* Debugging support: what debugging support?
* Hash-maps: these were only added recently (!!!) and they are not what I'd expect in a modern language. For example, if you want to do a map lookup, and your keys aren't strings, you need to wrap them in Key[]. Come on.
I also found that it's very difficult to achieve any kind of code reuse. The process of getting from a prototype to a library has so much friction that people tend to avoid it.
I find that I use Mathematica for a limited range of problems. If I could have Mathematica's library in Clojure with a graphical REPL, I'd pick that any day (Clojuratica is a project aiming for that).
Also, I don't really get the whole "Wolfram Language" vs Mathematica distinction. All the demos I see are demos of Mathematica, mostly of its huge and useful library.
> * The language syntax isn't as good as a sexp-based lisp. Editing complex expressions is needlessly complex and doesn't even compare to structured editing with paredit in Emacs.
Did you know that the frontend lets you double/triple/etc click to select outward up the AST? You can also press ctrl+period to do this. It's indeed not paredit, but you can do most paredity things using this single primitive and copy/paste, and it's not too painful (and it would only take a weekend to make a package that implements paredit).
Other than the lack of paredit, could you be more specific about the syntax isn't good? You can always use FullForm if you want to write things in an sexp way.
I think the equivalence between prefix form (f /@ x, f @ x, f @@ x), and FullForm (Map[x, y], f[x], Apply[f, x]), and postfix form (x // f) is a nice degree of freedom when beatifying code. Sames goes for composition (f /* g, or g @* f).
Functions tell a story and having to write that story in exactly one austere syntactic way is in my view a disadvantage for making the story clear and satisfying.
> * The interpreter is slow. Really slow. Sure, if you call a matrix math routine, it will be OK, but try rearranging large data structures and you'll end up waiting a lot.
I haven't done benchmarks recently but we're probably in the same ballpark as (C)Python. Maybe a bit slower. But if you'd consider using Python for a task it's also likely to be handled by Mathematica just fine. In many cases there is plenty-optimized C code doing the heavy lifting, like if you use our machine learning functions or anything with matrices (or vectors/lists, or tensors, or ByteArrays, or Images, or Graphs, or ... :) ).
As usual, interpreted languages can even win when they allow you to describe a computation at a high level, and have that be executed by some smart JIT compiler. Julia leads the way, of course, but we're working on similar things ourselves, particularly for Dataset (http://reference.wolfram.com/language/ref/Dataset.html).
> * Debugging support: what debugging support?
There is a built-in debugger in the frontend, under the "Debug" menu, that actually does a fair job of showing where in your expression the evaluator is at. I admit that I don't use it much, partly because I've got a much more ambitious prototype of a thing that produces a browseable execution history. Hopefully that's only a few point versions away, I just have such a crazy number of projects.. sigh.
> * The editor is a disaster. I seriously don't know how people can stand it and how come the company invests so little in it. A single mismatched bracket can mean ten minutes of hunting for the problem. Code jumps around on screen all the time, seemingly with no logic to it.
That's because you're probably using Input cells. Input cells are for one- or two-line inputs. Use Code cells for large bodies of code. They don't do automatic indenting and won't jump around. If you wish to complain that this isn't obvious enough, I entirely agree with you! It takes too long to discover the 'right way of doing things', which is a UX and design failing. And simple stuff like Tab on a selection of multiple lines doesn't work.
I use Eclipse (for which there is a plugin), or Sublime Text.
> Syntax highlighting is nearly non-existent.
Syntax highlighting isn't non-existent, at all. I'm not sure where you get that from. Some examples of things that are highlighted:
* Misspelled functions (functions without definitions are blue)
* Invalid numbers of function args
* Invalid options to functions (options=keyword parameters)
* Symbol shadowing (a variable in a Module shadowing another module, etc)
* Invalid graphics and typesetting and GUI elements
And beyond that, various little red arrows appear when you write something that couldn't parse.
> It's a complete trainwreck and I don't understand why this isn't seen by the company as a huge problem.
"Trainwreck" really seems hyperbolic. Whatever our faults, one of the things people tend to agree about is that we've innovated with the frontend, and others are only now catching up with IPython, Light table, etc.
And they have a long way to go. The frontend has reflow, a box language, cascading stylesheets, and something resembling FRP (though a bit less clean, perhaps). It's really not far off from HTML in its flexibility and power.
> Hash-maps: these were only added recently (!!!) and they are not what I'd expect in a modern language. For example, if you want to do a map lookup, and your keys aren't strings, you need to wrap them in Key[]. Come on.
Good thing we waited, though, if we had added associative arrays 15 years ago we wouldn't have had datastructures like HAMTs to achieve both immutability and efficiency.
I'm puzzled. Both the subvalue lookup (assoc[x]) and the Lookup function (Lookup[assoc, key, default]) don't require a Key wrapper, and those are the dominant ways to use associations. Key wrappers are only required when using e.g. Part, to distinguish e.g. the key All from the part spec All. What other behavior would you have wanted?
And design-wise, I actually think we nailed the design. There are all sorts of nice equivalences of the form Values[f[assoc]] === f[Values[assoc]] that give an association a well-defined 'kinematics' -- they are like ordinary numerically-indexed expressions (e.g. Part[f[a,b,c],2] is b), but the indices are now arbitrary expressions. That essentially forces your hand with respect to many existing functions, like Sort, Map, Partition, Take, Drop, and so on.
And that makes them seem cleaner than in many other languages, which mostly treat associative arrays as little more than bags of tuples (e.g. mapping over a hashmap in Clojure is not terribly useful or efficient).
Plus, the order-preserving is just nice, even if there is a performance cost.
> I find that I use Mathematica for a limited range of problems. If I could have Mathematica's library in Clojure with a graphical REPL, I'd pick that any day (Clojuratica is a project aiming for that).
If you're a big Clojure user you may be interested in Session -- https://medium.com/@kovasb/session-1a12997a5f70 -- that's a project by another friend of mine who used to work at Wolfram and now is an active member of the Clojure community.
> I think the equivalence between prefix form (f /@ x, f @ x, f @@ x), and FullForm (Map[x, y], f[x], Apply[f, x]), and postfix form (x // f) is a nice degree of freedom when beatifying code.
> tl;dr: The Wolfram Language is an ok 30-year-old language
I don't think it is just 'OK'. It is lispy, with a HEAVY emphasis on symbolic computation.
I have yet to see anything even remotely similar to it.
EDIT:
There's also the visualization aspect. Things like Jupyter (formerly iPython) come close, but still can't do things like render video.
If you don't want to read the article, there's this video: https://youtu.be/_P9HqHVPeik?t=67 (initial ego trip skipped)
>Things like Jupyter (formerly iPython) come close, but still can't do things like render video.
This isn't actually true, you can render video in the notebook with matplotlib, although it can be pretty cumbersome. We've been developing a library called HoloViews (http://ioam.github.io/holoviews/), which makes generating complex visualizations and animations in the notebook a breeze. We support video output, widgets, gifs etc.
The language agnostic Jupyter with its interactive notebook comes close to Mathematica's environment. http://jupyter.org/
Jupyter supports Python and other languages like Julia (https://github.com/JuliaLang/IJulia.jl ). I don't know if there are JS and Lua bindings but both would lend themself because of their first class functions and functional language features.
I think you would appreciate the language better if you understood that it is just Lisp with a slightly different syntax. They do everything using symbols, and all functions are decomposed into symbols for head and arguments. In my point of view, Wolfram language is a combination of many of the great concepts from Lisp and Prolog, which makes it very useful for knowledge representation.
Mathematica has lisp essentially as a subset built on top of its rewrite system. In other words its rewrite system is so powerful that lisp can be naturally threaded into it.
In particular the symbolic nature of the language means that everything is first class, functions and function constructions ("functional programming") and expressions in general ("macros") being just basic cases.
> Mathematica has lisp essentially as a subset built on top of its rewrite system.
Right.
> In other words its rewrite system is so powerful that lisp can be naturally threaded into it.
a) lots of systems (turing machines, ...) can implement Lisp.
b) it's not that natural in Mathematica. The natural part comes from its symbolic nature. But if you look at the documentation and read about how they implement lexical closures, it's all vague and not that pretty. The implementation actually needs to rewrite variable names, IIRC.
I wonder why their documentation is so vague? They don't want independent implementations of their language?
> b) it's not that natural in Mathematica. The natural part comes from its symbolic nature. But if you look at the documentation and read about how they implement lexical closures, it's all vague and not that pretty. The implementation actually needs to rewrite variable names, IIRC.
That's indeed what Module does, and it is indeed ugly and slow. When we add parse-time macros it'll be trivial to fix this.
For now, many people use Block instead, which does dynamic scoping and is a bit cheaper. I actually really like Block, because it gives you the convenience of a couple of globals that you don't require you to keep passing them along among your backend functions, but they're properly bound to the lifetime of your function (and are re-entrant etc).
i think you're thinking that Lispification is some kind of goal for the language, but it's not. the lispininess is just one aspect of the language, which is why i think calling it a lisp isn't fair to Mathematica -- it's more powerful/abstract/general than that (in particular because everything is essentially quoted by default - though in their raw forms i suppose both lisp and Mathematica are essentially equivalently capable). the precise character of the lispy aspects of the language (eg the language not "really" having safe-locked closures) is imo just an implementation detail.
the concept of "macros" in Mathematica doesn't really exist as its own concept because the whole system is based on rewriting structure. for example, the ReplaceAll function[1] which is commonly used in idiomatic code is basically an in-place macro definition and execution, yet it wouldn't occur to most people that it's anything special.
if you're trying to make a traditional macro, you would implement it as a function with the HoldFirst et al attribute.
an important thing to know is that ReplaceAll uses arbitrary structural patterns. it's not a simple "turn every a into b". you can say things like "turn every application of the symbol F on an even number into an application of G on that number divided by two".
'macros' don't buy you much in that case. you'll need a few functions, too.
But that's not the point anyway - you can implement lots of things on top of Lisp.
Lisp is based on a specific evaluation model. Not term rewriting. The way macros are computed is slightly related (since they take source and return source), but that's all.
"a proprietary standard library – however huge – just can't compete with the open source ecosystems of Python and friends."
Depends on what one needs. If data crunching ala R and Pandas is all one needs - maybe. But I've not found an open source platform that would do all Mathematica does as efficiently (as measured by development time). Also, if a software package brings value to a company, there is no reason they would not pay to use it if it brings obvious value above it's fixed cost.
> realistically a proprietary standard library – however huge – just can't compete with the open source ecosystems of Python and friends.
It's not competing with Python, it's language as a service. Instead of downloading dependencies, you just have them. They're hooked to live data sources, zero configuration.
This has a lot of potential, and it doesn't need to be its own language, but it doesn't hurt much.
The Mathematica I know (v5, v6) were usable completely offline. Can one use the recent Mathematica version in an offline mode? How many parts are really part of the online service? I guess the WolframAlpha style data sources (country, city, etc. db sources).
No, you are missing the point, as I did before. This is really a LANGUAGE - in the sense that the symbols themselves can rely on account the vast knowledge base to determine their meaning.
When you and I speak in the English language, many times our terms come together to make sense in a certain way that relies not just on the context in the text but also background knowledge. Those who don't have this background knowledge won't understand what the sentence MEANS.
Yes, you can think of the semantics of the typed expressions as "the language" and the rest as a standard library. But that will still leave you in the mindset of programming computers using long programs of esoteric text when you need something done - and that is over 30 years old.
Consider this - calling this a language encourages regular people to learn it, much like English, with its vocabulary, and use it.
(Compulsive editors ourselves, we welcome anyone being driven crazy by a frozen typo or solecism in their comment to obtain relief by emailing hn@ycombinator.com.)
This is exactly how I feel. I want to know "how it works", what makes this language so great as they characterize it, but I don't understand, because they don't explain.
In short, it's a term-rewriting language with a particularly complex (although carefully crafted) rewrite strategy. Rewriting and evaluation strategies have a rich base of history and literature to read up on too.
But really, the best way to get the flavor of Mathematica is to play with it. I recommend downloading a free trial, since the desktop application is much more responsive and interactive than the online version.
It's pretty fun and, once you get the hang of it, surprisingly useful. And I mean that both ways: 1) It's surprising how useful it is and 2) It's often surprising when it's useful. It was a pleasant surprise when I discovered how useful it can be and it's always pleasant when I'm surprised by an opportunity to use it.
Thanks for the reference. The language tutorial seems readable, indeed.
But it requires more time than 1 hour to study. Maybe I fill find time some day to read it.
If would be nice if during presentation the explained at least one feature which is absent in other languages and makes it possible to build models more compact yet more widely applicable than other languages allow. Just one language feature, but understandable for programmers.
Because the hocus-pocuses with selecting something from internet and printing on screen doesn't help to understand.
Or even better: demostrate some impressive real world application (other than Mathematica itself)
It's hard to point to a particular "language feature" because all the differences stem from the differing evaluation strategy. Any given feature on its own may be interesting, but you can always come up with some alternative approach/representation/encoding/whatever in $YOUR_FAVORITE_LANGUAGE to diminish the feature's value. You really do need to understand term rewriting to understand the language.
This is all to say nothing of the standard library, but beyond evaluation strategy, what parts are "library" and what parts are "language" is so blurry as to be practically meaningless.
Ok, thanks. I am studying logic now, so I think I am starting to understand things related to term-rewriting. Maybe will look at Wolfram Language some day.
Do you know interesting programs/systems developed with WL?
I'm sure there are some, but think of its use cases to be more like Excel than like a typical programming environment. Most interesting Mathematica "Notebooks" are only ever used by a single person.
The Wolfram Language is quite cool. Sure, it's a shame it's proprietary - but it has a lot to offer, a few neat ideas, and makes for great, visual demos such as the ones featured in that talk. The fact that you can get cool things running in a few lines of code, like the 3D stack of edges, is appealing - I don't think there are many languages out there that allow you to do things like this in a few lines of code, and with such flexibility.
(it is quite a shame that Wolfram always has to assert how great they are, how revolutionary it is, how they invented everything, how unlike anything else ever done before their work is. It's off putting. Let your work speak for itself, and leave the meta comments out. But I digress.)
I like the "tweet a program" concept. One issue with kids growing up mostly on mobile phones is that it makes them less likely to try to see what's inside and program it themselves. One solution some have attempted is to have IDEs directly running on tablets/phones, but those tend to be fairly clunky. Allowing people to experiment with computation in unconventional manners, e.g. over Twitter, strikes me as an interesting path.
I had a similar project a couple years ago where you would tweet concise instructions to a bot that ran them into a virtual machine, for which the output was a 32x32 pixel image buffer and would get tweeted back to you. If you've played with forth salon or shadertoy, it's the same idea but with a language optimized so as to get cool results in <140 characters. Sadly, like many of my other bots, Twitter shut it down.
But yeah, given their aspirations for education etc., some open source components would be nice. It strikes me as a great exploratory/prototyping language, although it'd probably be hard to maintain large codebases of it due to the fuzziness of the instructions and a certain opacity in the backend.
All that being said, the tail end of the talk (about immortality and the singularity and the box of trillion souls - basically, when the paragraphs don't have code examples anymore) does fall into the standard techno-religious singularity crackpot speculation where things sound vaguely scientific - just enough to give them an air of credibility - but where the terms used are fuzzy and slippery enough to be manipulated into whatever direction the speaker wishes while maintaining an illusion of rigorous reasoning.
>Very much agree. And Wolfram used to be a university professor; he darned well knows how to give credit to others when it is due.
And he should know that science is supposed to be done by collaboration, transparently sharing information, not by peddling proprietary libraries. But he doesn't care, and he never has.
That's a good point! I also started programming on a graphing calculator.
One difference is that calculators were very limited in what they could do. No camera, no GPS, no internet connection, the screen was monochrome and 80x80 or so pixels... so the very limited language and input methods worked fine.
But on modern day devices, you want to build complex apps that can interact over the network, use the various sensors on the device, display rich media, manipulate video/images in real time, etc. The programming environment has to allow for all of this, which is the tricky part.
Has anyone here used the Wolfram Language? How discoverable is it? How does debugging work? What about state management? All the demos are small, stateless calculations. What is it look like when you want to build long-lived, stateful systems - say a robot that builds an internal map as it moves.
It's OK. Debugging is doable, but it's a bit awkward IMO. In terms of discoverability, well generally the documentation is among the best you will find anywhere and it's all inter-linked and full of examples, so that's a strong point. You can build programs with state, it mostly a functional language but it doesn't enforce purity or anything.
It is certainly capable enough that building something like what you're describing wouldn't be hard, but my experience is that it really isn't that great for that kind of usage (part of this is the readability, more on that in a sec). I think of it more as a "query" language... I tend to find that it works best if you use it by building up a few fundamental entities (say, symbolic equations or data) and then analyze them (transform data, plot, solve equations etc). In this usage it's pretty amazing, but whenever I try to do something like in a "real" programming language it is miserable. For instance, I once implemented GMRES in it and jeez it was absolutely miserable. On the other hand, I can do pure wizardry with stuff like data processing and visualization.
Basically, as long as you stick to composition of built-in functions, it's wonderful. When you want to do something from scratch though, that's when the suffering starts. It's also really easy to shoot yourself in the foot performance-wise... the language is very flexible in terms of allowing many different programming styles. Typically, however, only the functional-style implementation is really performant. For instance, you can use traditional indexed loops just fine, but their performance is generally at least an order of magnitude slower.
One other thing that drives me nuts about it is readability. It suffers from the same issue as Lisps with parenthesis overload, except for WL it's all braces and square brackets. If you put in good spacing and let the autoindent do its thing then it is pretty readable, but a lot of people don't. Somebody elsewhere linked this image http://indiegames.com/2014/03/10/wolfram%20example.jpg , which is a pretty good example of how it can be really awful. And writing code that looks like that is pretty widespread in the community, though it has gotten better in the past couple years.
Tl;dr I think it's pretty sweet, but I wouldn't use it for what you ask for. Your tastes may differ, though.
From what was shown it is really cool. Not because of the language itself, but for integration with data (from W|A?). It's like a CSI SQL.
Also, Wolfram is all nice for how he did this all by himself and how he let us use big tower of ideas and technology he built, also by himself, over the past 40 years.
edit:
on a related note, how does it compare with IPython/Jupyter?
It's not like the Wolfram Language examples you see are independent of the Wolfram KnowledgeBase or their other cloud services, and you have to leverage it from some deployed product (like Mathematica) you're paying for. This detail is sort of glossed over.
You can do some of it from free-to-use services like Alpha.
Also, good god does he love to take credit. There's whole teams of people who work on the underlying technology that powers it, although he does credit the guys who come up with algorithms that they use, especially when documenting them, but you have to dig for that... and then there's the people that gather, purchase and curate data sets that power the Knowledge Base, and even the SMP engine that became Mathematica was a group effort...
Which is why I'll never pay for a Wolfram Research product, as interesting as or powerful as it could be.
All it does it serve to support the legacy of an egomaniac.
It's super weird to me how Hackernews is extremely skeptical of Stephen Wolfram's god-genius persona, while simultaneously being generally very receptive to Elon Musk's similarly ginormous ego-tripping.
They ego-trip in different ways. [EDIT: With the implication here being that Musk's variety is far more palatable to us.]
Wolfram talks about how personally incredible he is, and how his work is revolutionary, and how he's this Great Mind who's laboring away on some perfect thing. Musk talks about how incredible his companies are, and how they'll change the world, without ascribing all progress to himself personally.
It seems like to be equivalent, Musk would have to stand up on a stage and give a talk about he personally invented rockets, or at least how he's doing great things based on his own theories about rockets.
Not sure about Elon Musk, but Apple comes across this way. They constantly talk about how they "reinvented" everything, "re-imagined" everything, "went back to the drawing board" etc while presenting new products. Kinda off-putting. But to be fair these people/companies do amazing work, so I guess some amount of ego is to be expected. Top athletes, musicians and pretty much top people from most industries have huge egos. Comes with the territory, I suppose.
Ditto. I respect Musk as a skilled and successful engineering manager, but remain amazed by how much credit he's given for things that are clearly the product of some luck and a hugely talented team. I think a mark of a good manager is someone who will go out of their way to correctly credit their team.
Likewise, Wolfram has published some interesting papers on CA and Mathematica is great for it's problem domains, but ever since NKS I think he's forgotten the maxim cautioning to not get high on one's own supply.
Maybe not you, personally, but there's plenty of that around here:
"the man is pure inspiration. 10 years ago, i was asked who i admired, and couldn't think of a single answer. Maybe that's sad on my part, but when asked now, he's at the top of my list." https://news.ycombinator.com/item?id=9546353
It does seem like maybe the pendulum is finally swinging back a bit, though.
That's what I never understood either. I understand the concept of two interesting and inspiring stories behind companies he runs (spaceX especially so) though. However, the image I have in my mind is that Tesla is still a Segway of cars, toys for rich people and SpaceX is good at extracting government money (both companies are good at it). I will have to re-think my thinking if SpaceX gets to Mars before China or NASA does.
Wait, what? "...how he let us use big tower of ideas and technology he built, also by himself..." —this is very far from the truth: there are a lot of people working on these things.
Mathematica is very powerful, but it's also very expensive and based on a proprietary code base. For me, this is unacceptable and the only solution in my judgement is to build our own.
I have been working really hard on exactly that, and in the past 3 weeks have made the most amazing progress. I don't want to spill the beans just yet, but this is my second attempt at building a better mathematica, and this time around I am using python, the scipy stack, and sage.
I will be releasing the project quite soon, as free open source software, along with a website that is 100% free for everyone. I am really hopeful that I will be able to find like minded programmers who are excited about working on this project together.
If this sounds interesting to you, please reply in comments below, or else reach out to me @calhoun137 on twitter.
What's the business model of Wolfram? Do they make most of their reveue from Mathematica or do other things like Wolfram Alpha and Wolfram Language bring a significant chunk of it?
I've been trying to implement a open source version of the Wolfram language for FenixEdu but is extremely hard. For the most part is possible as long you don't use stuff that depends of proprietary data sets. Also, after 30 years working on it, it is quite faster than anything else.
I truly would like to see the community come up with a open source version of it, but with such a huge size, the language would be near impossible for one single individual to implement a compatible version.
Maxima seems very similar to Mathematica in principle. What does Mathematica have in favor? Far more mathematician/engineer-hours invested due to early (and then compounded) financial success?
Mathematica is adequate for prototyping or detailed Science/Engineering etc analysis provided datasets aren't large and the codebase is small.
Mathematica is very fast for your initial development, but you run into massive bottlenecks when you jump from your small test cases to real world data. In other words you get something up and running quickly, then spend a massive amount of time manually (there is no proper debug environment) debugging edge cases and trying to optimize it for real world cases. The time savings aren't really there for many projects, as you end up spending more time than if you had used something like C++.
The last version of Mathematica (v10) was released over a year ago without an update to the Eclipse plugin, making an already pretty archaic development experience impossible.
The front end debugger isn't a 'fair' debugger. When it works (which isn't often) you are limiting to only running through small code snippets as its impossible to trace anything.
There is no profiler.
The number of builtin functions is huge but many are effectively deprecated in terms of their performance or existing bugs. Many of the functions like Map (/@) aren't optimized. The irony is that once you have optimized your code it ends up looking like that from any other language i.e. you have moved a lot of Wolfram's high end functions.
I totally agree with others comments that code re-use is really difficult. Many of Wolfram's comparisons compare code size with code complexity. Its not always to the case, but 20 lines of Wolfram language can often be very difficult to trace and understand.
Access to curated data is nice, but in many cases there is no information on the accuracy or tolerances for data and it has been truncated (rounded to the point of irrelevancy) or is missing elements. So like anything you still need to verify it or access it directly from other sources. Things like units cannot be used in functions/loops as it slows runtime to a crawl.
But horses for courses, the language is exciting for small projects and maybe a jumping off point for people moving into full development of something.
One of the biggest issues facing Mathematica is simply that Wolfram Research's focus is no longer Science and Engineering but rather the Internet of Things.
I'd like to use it commercially but it seems so expensive. $300 for only 3000 API calls.
I'd be happy to pay but it would need to be a marginal increment over the CPU + data costs. If that was the case they could get some serious volume and momentum.
With only 3000 API calls any cool little prototype you made would hit the limit within minutes of hitting the HN front page.
At first I balked at a computer language being so "big" instead of being, say, a functional language that can import yont of functions in a standard library.
But then I realized, this bridges the gap between computer languages and human languages, which we all use to communicate. Although "keeping things organized" in a regular computer language might be done more neatly in some "computer oriented" way, when it comes to actually USING IT to EXPRESS YOURSELF you'd need a professional to write he program for you.
Well, there still has to be clear, unambiguous documentation.
I wonder if a purely functional language would have been more appropriate, given the fact that programs written in such languages are more amenable to automatic rewriting and reasoning.
I actually really like Mathematica as a tool for symbolic/mathematical stuff – they're the best at what they do best. But all this Wolfram Language stuff is just way overblown, and realistically a proprietary standard library – however huge – just can't compete with the open source ecosystems of Python and friends.