As others have pointed out, Mathics is missing features relative to Mathematica, so it is an alternative provided you can work within Mathics' subset of features. So if you are doing anything but tinkering it is still best to buy Mathematica.
But Mathics is great for exploring the concepts in the Mathematica programming language, a language that does not get the attention it deserves. If you are not familiar with Mathematica as a language and and are curious, see this comparison of Mathematica with other programming languages such as C, APL, and Lisp, from the first edition of the Mathematica book: http://reference.wolfram.com/legacy/v1/contents/4.2.html (this fourth section was dropped from the second edition and beyond).
As an avid user of Mathematica, I have been also partly annoyed by the language. I find that getting something (complex) to work takes much longer than ideally needed due to complex syntax. It would take still longer with other tools for mathematical problems, so I cannot really be complaining.
I "may" have discovered a language that seems better Mathematica: Modelica [1]. It turns out that Wolfram itself recently purchased a Modelica add-on to Mathematica, which it now markets as its new SystemModeler product [2].
Note that while the Modelica language is not intended towards general-purpose computations, I find the core concepts behind the language to be valid beyond its intended purposes.
This is something that has bugged me for a long time: how do people consider a "language reference" as a good documentation? Maybe it's because I'm not a programmer, so I'm not used to reading language references, but when I'm picking up a new language or a new tool, the most important things is to have examples on how to use the language to get things done. Take the unix manual for instance. The first thing I do when checking the manual is to search for example. Reading the list of switches is useless to me unless I have a working example of how the thing works.
So a good thing is a tutorial that guides people to the main parts of the language, explains the pitfalls, etc. I had to use mathematica to check some derivations about 6 months ago, and I spent a whole day trying to figure out how to work with it, and honestly, I nearly drowned under the documentation. There seems to be many ways to do the same thing (take the derivative of a function) and it is not always clear how/why should we use one method over the other.
Another problem I have with mathematica is that although the different functions are extensively referenced (I won't use the word documented), the language itself is not very well explained, and by language I mean how to piece all the functions together and more into one coherent piece of software.
Now I haven't spent enough time with it for my judgment to be definitive, but I found it harder to pick up than most languages / tools I've used.
i'm not sure what language you're talking about... the Mathematica Help docs are full of examples. check this Histogram page[1] and scroll down, check the Options section, Applications section, etc. that is a typical level of exemplification for a function like Histogram, and other functions are detailed as appropriate and the examples regularly showcase how to use various functions/functionality together.
i think what may have happened in your case is that you believed Mathematica was a math-specific tool (which it isn't) and so you didn't pay enough attention to the non-math aspects of the language, such as the basic API (for which there is replete documentation/examples in the Help docs, see for example [2]).
the most useful key in Mathematica is F1. click on anything, any symbol or function, and hit F1 to see the Help page for that item
"how do people consider a "language reference" as a good documentation?"
"when I'm picking up a new language or a new tool, the most important things is to have examples on how to use the language to get things done"
You look for different things when you think about how to implement the language. In a sense, the implementation doesn't really care about the use cases: it merely cares that the behavior matches the stated behavior in the documentation.
the IDEAL documentation for a developer is a proper PEG/LALR grammar for the language. That way you can properly parse expressions. Clearly they didnt provide it.
The documentation gives enough information to reduce an abstract expression from the GUI down to a mathematica expression, which is enough to build an AST. From there, it's a matter of building up each component to match the semantics.
"Another problem I have with mathematica is that although the different functions are extensively referenced (I won't use the word documented), the language itself is not very well explained, and by language I mean how to piece all the functions together and more into one coherent piece of software."
That's the job of the programmer. The documentation should explain how each bit works and the rules for combining the bits, but it's up to you to take the pieces and build something.
Think about Legos: you have a pile of bricks, and no one is going to tell you how to build a rocket ship using those pieces. That's up to you :)
"Take the unix manual for instance. The first thing I do when checking the manual is to search for example. Reading the list of switches is useless to me unless I have a working example of how the thing works."
The manpages do a poor job of explaining the zen of unix. Once you start thinking of operations as transforming streams of text, then you start thinking of tasks in terms of smaller units.
For example, a few minutes ago I needed a way to upgrade all global `npm` modules. I knew there was a way to get JSON lists (npm list -g --parseable --json), which lines I wanted (the ones starting with ' "'), and what I want to do with those (get the name and install). Putting it together, one straightforward way is
npm list -g --parseable --json 2>/dev/null | grep '^ "[a-z-]*": {' | sed 's/^ *"//;s/".*$//' | while read x; do sudo npm install -g $x; done
Now, the documentation doesn't explain that this is a way to do what I want. But the documentation gives enough information to know where to look.
However, I would not recommend it as general purpose language because of its proprietary nature.
The $295 barrier to entry is way too high. Unless there are better interpreters than Mathics (which as someone mentioned is great, but is just a subset) around, I don't see the point.
Oh, come on! Considering the approximately $2,000 price for standard commercial versions of Mathematica, MatLab, and Maple, the $295 for the home version of Mathematica is quite reasonable. If you want to freeload, get Sage (which is quite good, btw).
Wolfram now has a version of Mathematica called "Starter" which costs $995 CAD and can be used for commercial purposes (unlike the home version). The Starter version only gets upgrades for one year, but you can keep using it after one year.
This is a tool with years of work by a huge team behind it, with hard-core scientific innovations built in, and which you are supposed to use for years professionally.
Imagine if dentists said: "I will use a hammer to take out your teath. I cannot justify $10,000 for this proprietary machine for company X".
Seems like everyone's misunderstanding my sentiment--now that I look back, I was pretty unclear.
I'm not arguing that Mathematica is too expensive. I think it's worth the money and more for math/science/engineering work. I was glad to pay up because it fills that niche for me.
My beef is with the suggestion that it should be used for general purpose work, like scripting. I believe that if people need advanced math features, Mathematica is extraordinary. But dropping $295 for a proprietary system as a replacement for Ruby or Java?
You cannot share your source code in a way that those who matter to you can modify and run, without them paying the price too. Including your future self.
Ahh, I was assuming the parent to my comment was implying that people who don't already have Mathematica should check it out for general-purpose programming.
If you've already bought Mathematica, great, use it for whatever you want! However, I don't think you should buy it unless you actually need its advanced features.
Last time I checked Wolfram wasnt even hiring. . . . . . . Why bother learning Mathematica or writing your own free version i mean seriously? There are perfectly good Javascript libraries for doing whatever "math" stuff you feel like burying your nose in and another thing. . . . It's actually impossible to write a computer program that will prove anything significant. Turing figured that out like 80 years ago, get a clue morans
>Why bother learning Mathematica or writing your own free version i mean seriously? There are perfectly good Javascript libraries for doing whatever "math" stuff you feel like burying your nose in and another thing. . . .
Not very familiar with this "math" thing, are we?
>It's actually impossible to write a computer program that will prove anything significant. Turing figured that out like 80 years ago, get a clue morans
It's "morons", I believe. And Turing figured nothing of the sort.
Not to mention that it's very easy to write a computer program that will prove something significant (as long as you don't expect the program to do the whole proof itself, which it can also be done).
But Mathics is great for exploring the concepts in the Mathematica programming language, a language that does not get the attention it deserves. If you are not familiar with Mathematica as a language and and are curious, see this comparison of Mathematica with other programming languages such as C, APL, and Lisp, from the first edition of the Mathematica book: http://reference.wolfram.com/legacy/v1/contents/4.2.html (this fourth section was dropped from the second edition and beyond).