I'd say it would be even better if instead of promoting primality test ("prime?") to the first place in case of a prime result, it would display "[it is] prime!", since the program already did the check. Why hide information from user?
BTW, Bret Victor wrote a lot about this kind of interfaces in his essay "Magic Ink". It's long as hell, but well worth the time it takes to read.
Key point from the end of this essay, regarding use of machine learning to create smart / learning interfaces, which really got me thinking:
"Unfortunately, an algorithm that can only be wielded by a master is almost worthless. There are far more applications than experts; if application programmers cannot make use of learning, learning applications will remain rare and exotic.
(...)
As I see it, the primary challenge for the machine learning community is not the generation and tuning of yet more algorithms, but the design of simple abstractions. Learning magic must be packaged. Like a “file,” the abstraction must be usable by any engineer working in any domain. It must be so simple that it can be taken for granted.
Today, a Perl programmer needs just four letters to invoke decades of research into filesystems and physical media: “open.” A finely-tuned mergesort is available with the word “sort,” and even more finely-tuned hashing algorithms require just a pair of brackets. Until machine learning is as accessible and effortless as typing the word “learn,” it will never become widespread."
He presents prediction as new, ignoring google suggest; predictive text on phones/tablet keyboards; tab-completion in bash/vim; intellisense etc. And it obscures the part that is new:
And the second is what actions would lead to useful results.
No longer statistical, but based on the (presently) unknown! Not predicting what you are likely to do, but exploring ahead of you. Not based on your past, but your future... A very cool idea.
Actually, at present, it seems to be just a secondary ranking filter of statistical suggestions, so it would never consider an original action (i.e. that wasn't already likely). However, that kind of exploration would really be expensive. Another problem is defining "useful results" generally, so it applicable to results not seen before.
It may not seen on one's machine, but Wolfram Research should already have other data about how people previously use some result. Or the data can come from Stephen himself, as he log every keystroke since 1989. http://blog.stephenwolfram.com/2012/03/the-personal-analytic...
Interesting: "Mathematica is a big enough system that I don’t think anyone (even myself) can immediately remember everything it does. So that means that particularly if one is using a somewhat unfamiliar part of the system, the Predictive Interface is highly useful."
The first is the essay, "The Anti-Mac User Interface" which everybody ought to read. But that talked about a UI that let people send commands in natural language then the computer would use completion and Thesauri to make suggestions as to what precise commands the user might have meant.
There's also the shell I use, fish (the Friendly Interactive SHell), where there's traditional bash style tab completion, but it also looks for common commands I've given in the past and if I type 's' say it'll show 'ssh -t linux.mit.edu screen -R' in greyed out text because that's the most common command I use that starts with an 's'. And then I can just pretty Ctrl-f to fill in the completion. Or I can keep typing to 'sc' and it'll come up with another auto completion based on those two letters.
Or there's Ubuntu's HUD, which lets you select things from the menu's using fuzzy matching and remembering which commands you use most frequently and presenting those first. Basically the one thing that keeps making me think that maybe I should go back to Unity.
I find those keyboard command interfaces really natural. I loved the command palette in IntelliJ, for example: shortcut to bring it up, then start typing what you want to do and it'd suggest available commands.
This reminds me of the interactivity of Light Table.
Actually, a lot of features of Mathematica - not to mention the language itself - make me think "You know, this is pretty damn cool. I wish I could actually use it."
Am I the only who wishes that Mathematica and its core language weren't locked down so tightly to a single market? Just imagine if they released a free home version (monetizing off of W|A ads and suggestions), and/or a standalone kernel stripped of all of the frontend features. As it is now, innovation and creation with Mathematica is hampered heavily, and I don't see it gaining any more mass market recognition and usage. With a more free and open model, on the other hand, it might be able to break out.
I was only mentioning that sense of "free" tangentially, and I wasn't bemoaning my own situation, just theorizing that they could get much greater mass market penetration (which they seem to want) with a free tier.
I guess it wasn't very clear, but what I really meant was an open platform for hacking on. As it is it's very difficult to use Mathematica as a normal programming language, and it's clearly not designed for that (even though there is a vocal contingent at Wolfram that wants people to try anyway). If it were split off into two projects - a completely open core language and a set of closed symbolic math APIs + frontend tools on top of that language - then it would open it up for anyone to hack, create and innovate on, instead of playing around in their very heavy and very limited garden with no option to integrate with other tools, distribute, or improve and extend the language.
Very curious to see how well this works in practice.
An excellent example of a usable predictive interface is DataWrangler from the Stanford Vis group - http://vis.stanford.edu/wrangler/app/. Bit of a learning curve, but well worth it if you're working with semi-structured text data.
Wolfram | Alpha predicts from the previous human input, I am getting "Assuming 'the future' is a song" on request "What is the future". But even kids are better than Wolfram in answering such a question. They can tell you that the future is a grammatical tense used for expression about things that will or can happen.
And from this limitations of the predictive interface are clear. If it does not have enough candidates, it will bring user nothing but weak excuse.
I can see something like this hitting the IDEs shelves in a few years. Need to use an unknown API for this very specific part of your project? Don't worry about the documentation, suggestions are going to tell you what you'll want to write.
In practice it can be quite useful, proposing simple improvements and adjustments that you can't always be bothered to type out yourself. Occasionally its suggestions are irrelevant. And either way it's less annoying than Clippy.
I saw this and thought it was the typical, flippant, light-grey comment that ends up in newbie downvote hell at the bottom of every HN story. Then I thought a bit more: it's better than that. The Ribbon and the predictive bar in Mathematica are actually quite similar in concept: both attempt to figure out what you're doing and present you with contextually relevant choices.
The difference is that I absolutely detest the ribbon in Office. I find it much easier to remember the path to a particular function in a menu or static toolbar, rather than be presented with an ever-changing soup of psuedo-relevant options; the ribbon denies me the chance to build muscle memory for activating common tasks. Conversely, the predictive bar in Mathematica works very well and I've been using it much more than I expected.
I think this is because Office is a massively limited system compared to Mathematica; it's easy to imagine it as a physical object with knobs and switches for every function, like a really complicated power tool. Mathematica is a gigantic programming language, so large that even its creator admits to having an incomplete understanding of its scope. An intelligent assistant that can show you some natural next steps in your calculation actually makes a lot of sense here.
Imagine if your IDE came with this sort of stuff! You've just added a UIToolbar to your UIView. Do you want to set up matching outlets in the associated view controller? You've just declared an AUGraph; click a button to put method calls in for setting it up and adding a few nodes.
BTW, Bret Victor wrote a lot about this kind of interfaces in his essay "Magic Ink". It's long as hell, but well worth the time it takes to read.
http://worrydream.com/MagicInk/
EDIT:
Key point from the end of this essay, regarding use of machine learning to create smart / learning interfaces, which really got me thinking:
"Unfortunately, an algorithm that can only be wielded by a master is almost worthless. There are far more applications than experts; if application programmers cannot make use of learning, learning applications will remain rare and exotic.
(...)
As I see it, the primary challenge for the machine learning community is not the generation and tuning of yet more algorithms, but the design of simple abstractions. Learning magic must be packaged. Like a “file,” the abstraction must be usable by any engineer working in any domain. It must be so simple that it can be taken for granted.
Today, a Perl programmer needs just four letters to invoke decades of research into filesystems and physical media: “open.” A finely-tuned mergesort is available with the word “sort,” and even more finely-tuned hashing algorithms require just a pair of brackets. Until machine learning is as accessible and effortless as typing the word “learn,” it will never become widespread."