You could. But as one of the Mathematica devout, it works be a massive pain in the as compared to other languages better suited for it. Assuming languages are equivalently expressive (in the Turing complete sense), the difference is in what they make easy.
It’s easier to make a small web API in python than assembly, even though they can do the same things. Mathematica is designed to make (symbolic) mathematics easiest. It excelled there at the expense of weirdness elsewhere.
The answer unfortunately reduces to “I dunno, try it and see.”
It's "fine" for imperative programming if you never make a mistake: the problem is that it is extremely permissive and won't stop execution on errors. I usually add my own error checking and default cases to cause programs to halt, and these help a lot, but there are still a number of footguns.
One example is what happens if you map a function f over a list lst: f /@ list. Oh, the variable was called lst and not list? Mathematica will happily evaluate this and result in list, assuming list has not been defined. This is because what /@ does is apply f to each part of the expression, and a Symbol has no parts. If Mathematica had a way to declare which global symbols can be used in local expressions, it might help prevent this class of bugs.
Shell is good for creating Unix systems because of the tools it provides. ... It's hard to explain, but if you work in that area, you'll very quickly see it.
I think many people have learned one language, or 3 languages that are similar, and they think all languages do roughly the same thing.
That's incorrect on all counts: in terms of the core data model, the operators, and the libraries.
If you do a lot of work in a specific domain, you'll start to see all the differences. Shell is the best tool for bringing up machines, which happens a lot in both the cloud/web and embedded spaces.
----
Ditto for R. R makes a lot of tasks really easy, and a lot of other ones really hard (like being 10x slower than Python, or 1000x slower than C, for many tasks). That sounds horrifying, but it really helps you get a lot of work done.
Another thing people have trouble appreciating is the difference between R and Matlab, and Matlab and Mathematica. Those 3 languages are drastically different because of both their core data model and who uses them.
The assembly analogy is a very faulty analogy. The reason assembly is harder is because it's a lower level language and requires significantly more code to accomplish the same. Most term re-writing languages are actually higher level than python. And so in theory would take fewer lines.
The real difference is noone has created a set of libraries for the web api domain space in a term re-writing language. If they did, it'd be easy.
And similar to others in this thread, I think term re-writing languages will be prominent in programming future. The same way many years back people could see functional programming over the horizon in programming future.
It’s easier to make a small web API in python than assembly, even though they can do the same things. Mathematica is designed to make (symbolic) mathematics easiest. It excelled there at the expense of weirdness elsewhere.
The answer unfortunately reduces to “I dunno, try it and see.”