# Future Directions of Wolfram|Alpha

Stephen Wolfram highlighted several future directions of Wolfram technologies during his keynote address at the International *Mathematica* User Conference 2009. Among them were new developments surrounding Wolfram|Alpha.

In the following video, Stephen outlines some of the directions in the works for Wolfram|Alpha and gives a sneak peek at one soon-to-be-released service. (To hear more of Stephen’s keynote, please see part 1 and part 2 of this series.)

**Transcript Excerpt:**

We always try to maintain a portfolio of development directions, from the near term to the very long term.

Well, one long-term, large project that we were working on for years was Wolfram|Alpha.

And as you all know, one of the things that happened this year is that we launched Wolfram|Alpha out into the world.

I view *Mathematica* as a language and system for defining and implementing formal knowledge. For computing, developing, and deploying systems of all sorts.

Well, what about all that real-world knowledge? All that specific data, and models, and methods, from every specific area?

Is there a way to make all that knowledge computable?

That was the objective of Wolfram|Alpha.

To see just how much systematic knowledge can be made computable.

I wasn’t at all sure whether this was going to work.

Whether this was the decade—or even the century—where this would become possible.

And without *Mathematica* there is no way it would have been possible.

But *Mathematica* has made it possible.

Wolfram|Alpha is all built with *Mathematica*.

All those people who now use it every day are all running one giant *Mathematica* program.

It’s right now about 7 million lines long.

Running on thousands of CPUs across—right now—four colocation centers.

All built with web*Mathematica*. Managed and monitored by many layers of *Mathematica* programs.

There are many aspects to Wolfram|Alpha that are I think interesting and important.

I really view there as being four major technology components.

The first core element is dealing with data, being able to take large amounts of data from lots of different areas, have a pipeline for curating this data, for automatically organizing it, correlating it, making it computable, injecting expert domain knowledge into handling this data.

Doing things which are a scaled-up version of what we have done in with data paclets in *Mathematica*.

Generating this huge corpus of curated, computable data.

The second core element is taking all the specific methods and models from all sorts of particular areas—essentially every kind of algorithm, every kind of method, every kind of model that’s been defined—and actually implementing them and making it possible to actually run them in Wolfram|Alpha.

In *Mathematica* we have the raw material for doing that implementation, but in actually building Wolfram|Alpha we have added the millions of lines of code that correspond to an increasingly large fraction of all possible methods and models that exist in different areas.

A third core element of Wolfram|Alpha is the presentation of results.

So one of the things we have been able to use is our computational aesthetics methodology that we have developed in *Mathematica* to automatically figure out when given a particular kind of data or a particular kind of function to visualize what is the best way to produce a compelling visualization.

A fourth element is something completely different. A very different direction from ones we have taken in *Mathematica*, which is freeform linguistic input.

It’s a different discipline from *Mathematica*.

In *Mathematica*, we want to make everything very systematic, so we can build arbitrarily large and deep things with it—like Wolfram|Alpha.

But in Wolfram|Alpha, we want to do essentially “drive-by” computations.

Have people just type what they think, and have Wolfram|Alpha automate doing everything from that.

*Mathematica* is very systematic. Wolfram|Alpha is full of heuristics, catering to every possible foible of human expression.

It wasn’t at all clear that was going to work. But by using the kind of flexibility and interoperability that only the *Mathematica* symbolic language can provide—and also using some dashes of NKS thinking—we’ve been able to build something that works remarkably well.

It was a complicated decision knowing when to “release it into the wild”.

It was actually a little frustrating. We’d been building up all the frameworks and capabilities.

Actually we’d reached the maximum derivative point so far.

But we also decided that we couldn’t develop too much further without seeing actual user input.

Without seeing what people actually want to ask Wolfram|Alpha.

The actual release was pretty exciting. Perhaps some of you watched the launch on the live webcast.

As we got 10,000 CPUs running web*Mathematica* to start serving computational knowledge to the world.

In what felt like a pretty grand act of democratizing knowledge.

Well, Wolfram|Alpha has been doing great.

Both in terms of its use in the world. And in terms of its technology.

It’s a different development process in some ways from *Mathematica*.

Every day there are zillions of bugs and suggestions that flow in from the outside world.

And as we analyze the actual logs of usage, we can see more and more.

We’ve got a giant source of to-do lists. Coming in raw from the world.

We’re doing some pretty extreme development too.

We’re leveraging on all the development methodology and tools that we’ve built up for *Mathematica* over the past couple of decades.

And it’s letting us do some pretty remarkable things.

I’m pretty proud now of being able to make a *Mathematica* release maybe every couple of years.

But do you know how often we release a new version of Wolfram|Alpha?

It’s once a week. 23 times so far.

We develop. We freeze code. We test. We have a whole cycle. And it happens every week.

Of course, there’s data being updated in Wolfram|Alpha much, much more frequently even than that.

Every second. New weather data. New financial data. Whatever.

Well, there are all kinds of new things going on with Wolfram|Alpha.

I don’t think I have time to talk in total detail about them here.

But let me mention a bit.

As of last week, the Wolfram|Alpha API is available.

So you can call Wolfram|Alpha from lots of places. And you’ll in fact start seeing it integrated into some major systems soon*.

And following the principle that you should always use what you build—we just released a major application of the API: the Wolfram|Alpha iPhone App.

When I play with it, I think it’s almost absurd.

You’ve got this little tiny thing.

You’ve got a keyboard with integral signs and so on on it.

And you’re instantly doing these really complicated computations. Right here in your hand.

Actually, until we had the iPhone app, I really didn’t appreciate how valuable mobile computable knowledge would be.

It’s quite something.

Of course, it’s also interesting moving our technology to another, quite different platform: the iPhone.

With all sorts of different interface strengths and challenges.

And it’ll be interesting to see Wolfram|Alpha—and *Mathematica*—move to more platforms in the future.

Well, there’s a lot else going on with Wolfram|Alpha.

One of the exciting things coming soon is the Widget Builder.

You see all these little web calculators that are out there where you fill out a bunch of input fields and get a result.

All these places where people have active websites that are based on a few controls and produce output.

All sorts of form builders exist where you can create an interface with a collection of forms.

It’s becoming easier and easier to create these forms. The part that is not easy is making the forms compute something at the end.

Well, Wolfram|Alpha changes that picture and makes it possible.

What is exciting is that it makes sophisticated computation programming instantly accessible to anyone.

We can use the freeform input of Wolfram|Alpha and can essentially specify a program with various parameters and computations from there.

OK. Something else.

There’s a whole business that’s emerging around enterprise and custom versions of Wolfram|Alpha.

In some ways I think seeing Wolfram|Alpha lets people understand just how powerful the whole technology structure around *Mathematica* can be.

But in any case, there’s a lot of activity around enterprise and custom Wolfram|Alpha versions.

All sorts of integration into websites, application programs, intranets, and so on.

All sorts of work on curating data and making proprietary material computable.

It’s a mixture of technology and processes.

You see, in building Wolfram|Alpha, we’ve extended all those processes we’ve developed so well for building *Mathematica*.

We’ve got data curation pipelines, and what we call scanner development, and linguistics, and so on.

All *Mathematica*-based processes.

Well, as we deploy Wolfram|Alpha into the enterprise, we need to provide those processes.

And our Wolfram Solutions group, that we launched a couple of years ago, is expanding very rapidly to do that.

It’s really very nice. We’re seeing some extremely interesting and impressive deployments underway.

Oh, and another that’s coming along those lines is the Wolfram|Alpha appliance—kind of a clone of part of our rather complex Wolfram|Alpha infrastructure.

OK. Something else with Wolfram|Alpha is the Professional Version. Allowing download and upload as well as a single input line.

* Such as Microsoft’s Bing

I like Wolfram Alpha

For mathematics I have a suggestion. It might be possible to get synonymous forms today. I find that students often do not understand that two expressions are synonmous.

I would like to add a feature in Wolfram Alpha that works like this

synonmous forms expression

A list of synonmous forms can be returned and also how you move between them like how steps in derivations are shown.

thanks