Open-source it! The only programming languages that will ever succeed from now on will be the open source ones. Yeah, he can keep special-purpose libraries closed-source. And the server-software behind Wolfram. Maybe even the Mathematica GUI if he also offers a free "community version" or something on the side. But otherwise this will just not work. But the core language and core engine must be open-source with a liberal MIT or BSD license for it to ever grow an ecosystem around it.
Even Microsoft gets it now (with C# and many other stuff)! Apple also gets this with Swift! Typesafe gets it with Scala. Even Oracle partially got it in a twisted way, by allowing things like OpenJDK to exist!
Really, Mathematica and Wolfram seem wonderful tools, but probably as many as 10x the number of paying users would start to use them and contribute to their development (and most of them would also pay for "pro versions",trust me), if only they had an open-source core...
But it's probably too late and any future scientific computing platform will be built around Python and Julia and all the great work done by Wolfram Software will simply be forgotten because they simply don't grok how "business growth" and "software ecosystems" work in the 21st century...
If it were open source, many more people around the world would have access, but Wolfram’s cash cow would dry up.
Thankfully, open source programming environments keep improving, and between R, Python/Numpy/Scipy, Julia, etc., platforms like Mathematica and Matlab become less relevant every day.
Before you suggest developers the consultancy route, that penalizes the developers of software which is so well written and documented it can be used straight out of the box.
One thing I'd do differently to him: whenever the user isn't goint to profit from the software financially (in this case, hobbyists and students), there's a good case to be made not to charge for it, as without an initial user base, it will be difficult to sell it to companies. But if he wrote the code, he can decide on its licence.
Well, to be fair, Wolfram is one of the few scientists actually making money from scientific software. I've seen software companies doing much worse, to the point that I actually doubt there is any serious money to be made from most scientific/engineering software.
The closest language implementation in open source is "Pure" (http://purelang.bitbucket.org/), which I personally find superior in many respects.
Term rewriting is an interesting topic, but it's not a deal-breaker as wolfram is trying to convey. We have many alternatives nowdays.
The perhaps non-obvious limit is that the ordering of the rules plays a central role in term rewriting (as it does in it's close cousin: pattern matching), which makes it "cumbersome" (or quirky) to extend in a truly modular way.
Mathematica might have a chance if open-sourced, but it's not the language which is interesting from a technical perspective, but the entire ecosystem of base libraries which is quite well done and which probably has much deeper copyright issues.
A language, unlike a complete environment like Mathematica, allows you to build your own programs whole-cloth. But if those programs ultimately require Wolfram's permission to run, I don't really care how awesome it is, I wouldn't touch it with a 10 foot pole, for fear of it becoming the next J++.
They can still make money by charging for printed manuals, support, or offering some sort of supercomputing back-end like EC2 for research institutions. But for a serious developer to invest their own time learning this tool, the risk of a closed ecosystem is too high.
Even if Mathematica is never open sourced, there's still value in having a commercial language that can incubate new ideas or applications of existing ideas, for open source efforts to either ignore or riff on. The document+repl model used by IPython/Jupyter is an example of something that WRI didn't pioneer but certainly helped popularize in its modern form.
Another example that I think should be more widespread is the idea of 'superfunctions' whose arguments exploit a simple grammar to scale from simple invocations to arbitrarily complex ones. In effect you have a lightweight DSL -- a large or infinite family of functions fused into one -- which I think can buy a great deal of concision and flexibility.
GroupBy (https://reference.wolfram.com/language/ref/GroupBy.html) is one small example of this idea; in its simplest form it just partitions a list into equivalence classes, but scales up via its argument grammar to something more like (optionally nested) MapReduce. Part (https://reference.wolfram.com/language/ref/Part.html) would be another example. Again, this isn't something unique to Mathematica, you see variants of this idea in e.g. Clojure and Haskell, but my impression is that we've incorporated it into a wider cross-section of our language and made it more light-weight and convenient to use.
Another thing that I often think about is the notion of having a deep web of interrelated structures and behaviors, for example colors both have a visual display form (little colored boxes), IDE edit mechanics (you can click them to edit them in a palette), and polymorphic properties like distance, so that functions such as Nearest and FindClusters can 'automatically' operate on them. That's of course hardly novel, typeclasses in Haskell were designed to do precisely this, arguably more elegantly and user-extensibley.
But I think Mathematica shows how it is really valuable to have not just the capability to do this, but having it built in and working -- with many of those n^2 possible interactions between functions and data already curated and implemented. WRI is far from having done this completely, but again, we're trying, and I don't know of other groups that are trying to do this in an as integrated a way, across so many areas of computation.
> Open-source it!
Agreed. But I think the main reason for doing so, is in service of open, reproducible research. I'm sure if you're modelling blast patterns for a rocket to replace the Hellfire, you don't really care if your model stands upon series of locked, proprietary stuff -- as long as it is useful.
But if you're modelling influence effect of various ways to organize voting in democratic government, or doing publicly funded fusion research -- it's much more important that your results are transparent and easily reproducible (now, and in the future, which could be decades, or even centuries, away).
And I think that exploratory research and experimentation is exactly one of the strengths of Wolfram. But it needs to be much better than open solutions for it to even make sense to recommend a closed tool over various open tools -- for producing open research.
Consider if Einstein's research was locked up in some proprietary platform, rather than presented as simple text. While we'll see many papers and innovations in the space that is readily covered by human readable equations and text -- we're already firmly in a world were there are real discoveries that are made and proven only with the help of code.
I really can't see any future for a closed system in such an academic setting (but I can certainly see that closed systems can sell, and be used as tools in companies... provided that those tools continue to be taught and used in universities...).
- Casey Muratori
Wolfram certainly has talent, but like Steve Jobs, it may be more people-talent to know how to manipulate and impress others than mathematics talent. He certainly has some of the latter too.
Maybe I should just get over it.
> The goal of the book is to take people from zero to the point where they know enough about the Wolfram Language that they can routinely use it to create programs for things they want to do. And when I say “zero”, I really mean “zero”. This is a book for everyone.
One of the examples he gives is how to: Make a word cloud from the first letters of all the words:
WordCloud[StringTake[WordList[], 1]]
Sure, "Times[2,3]" might seem more human friendly than 2 * 3...until I get tired of writing that phrase out and doing an explicit function call just to get 2 numbers. But of course, in most software development, when am I really ever multiplying 2 numbers? Infrequently enough that I imagine I'll have to frequently Google whether the function name is "Times" or "Multiply", proving the first example of the classic adage about the 3 hardest things about computer science.
So there's a lot of things about the language that seem like a disaster to me, but I'm not smart enough to design my own language. Sometimes I'll take the opinions of the masses into account...for example, Python's use of significant white space seemed profoundly annoying but plenty of smart people are able to build profound things elegantly with it, so I took the jump. If Wolfram language is such a step beyond competing languages, where are the examples of things elegantly built with it?
Edit: apparently David Auerbach has said the things I think I want to say, but more eloquently http://www.slate.com/articles/technology/bitwise/2014/03/ste...
FYI here are your answers...
WordCloud[StringTake[WordList[], 1], WordSpacings -> 10] (* spaced out * )
WordCloud[StringTake[WordList[], 1], Binarize[CurrentImage[]]] (* shaped like your face * )
twitter = ServiceConnect["Twitter"]; ServiceExecute[twitter, "ImageTweet", Image ->WordCloud[StringTake[WordList[], 1]]] ( * Tweet a wordcloud *)
For that kind of detail, you will always want the documentation http://reference.wolfram.com/language/ref/WordCloud.html
http://www.wolfram.com/language/elementary-introduction/02-i...
https://reference.wolfram.com/language/ref/Table.html
Strange that this function is called Table when what it clearly is is an iterator that outputs a list. Its output is no more tabular than Range; it outputs an ordered list as does Range. In fact Range[10] seems to be shorthand for Table[n,{n,10}] yet they have completely different names.
If you show this book or go through this book with a true novice, like a child or complete non-programmer (no one has 'zero' knowledge like he says), this would turn them off programming for a long time.
To hook people in, to give them an actual /reason/ to learn programming, you need to show them how programming can be used to do something fun or useful. For example making a little game, or making something to help with a spreadsheet or so forth.
Instead, he waits until the very end of the book to start thinking about using the language to create something useful: "OK, so now everything is ready to talk about deploying things to the web. And at this point, people will be able to start creating useful, practical pieces of software that they can share with the world."
Start with how to make a simple web page, or a simple game that others can play, etc. Don't end with that. Make it easier for people to use your tool to make games or practical applications.
Then again, as others have pointed out, the fact that this tool is proprietary though makes it a non-starter for novices, anyway, in my opinion.
[HTML]: http://www.wolfram.com/language/elementary-introduction/