

Introducing the Predictive Interface - lispython
http://blog.stephenwolfram.com/2012/12/what-are-you-going-to-do-next-introducing-the-predictive-interface/

======
TeMPOraL
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.

<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._ "

------
6ren
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.

~~~
lispython
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...](http://blog.stephenwolfram.com/2012/03/the-personal-analytics-of-
my-life/)

------
hayksaakian
A good example of when doing things the hard way pays off.

Processing natural language is difficult and not strictly necessary, but doing
so is easy to appreciate and has clear benefits.

------
Symmetry
This reminds me of several things.

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.

<http://www.useit.com/papers/anti-mac.html>

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.

<http://ridiculousfish.com/shell/>

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.

~~~
scrumper
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.

------
valgaze
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."

------
jrajav
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.

It's not like this is completely outside of Wolfram's vision for the product,
either (first answer):
[http://www.reddit.com/r/IAmA/comments/qisot/im_stephen_wolfr...](http://www.reddit.com/r/IAmA/comments/qisot/im_stephen_wolfram_mathematica_nks_wolframalpha/)

Perhaps we'll see something more open with 10? I'm not holding my breath.

~~~
cormullion
It's only 90 pounds per year. I know free is good, but that doesn't seem
impossibly out of reach. I spend more than that on coffee.

~~~
jrajav
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.

------
benhamner
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.

The paper describing their philosophy and the predictive interface is here:
<http://vis.stanford.edu/files/2011-Wrangler-CHI.pdf>

------
ommunist
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.

------
sazpaz
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.

------
cormullion
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.

------
lispython
I think a good feature in this predictive interface is it even could let user
send feedback to improve the result.

------
vy8vWJlco
Smells like code completion (not a bad thing). Like Dasher, for analysis.

------
gmriggs
also known as the Ribbon in Microsoft land.

~~~
scrumper
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.

