# Keynote Speech for International *Mathematica* User Conference 2009

Given at the International *Mathematica* User Conference 2009 in Champaign, Illinois, on October 22

Well, it's nice to see you all here today.

And it's great to see all the interesting talks about using *Mathematica* that are happening here over these three days.

What I wanted to do here today was to give you a rough overview—a kind of bird's eye view—of what we're up to these days, and where we see things going in the future.

I always love to do demos of our technology, but I'm not going to do too many of those here today; I'm going to leave most of that to the people who've been at the front lines of creating the technology.

So: what are we up to?

Well, I have to say that things are going extremely well.

We've had a great year.

Even though there's been economic recession all around, we've had impressive growth in our business—and our company has expanded considerably.

And, of course, we released Wolfram|Alpha, which is a huge *Mathematica* technology achievement that's creating a whole ecosystem of its own.

I know some of you have come to many conferences with us, but particularly for those who are new here today, I thought I'd say a little about our history, and how we've gotten to where we are today.

I started building SMP—which was a precursor to *Mathematica*—back in 1981, and inventing some of the ideas that would become the core of the *Mathematica* language.

We started creating *Mathematica* itself in 1986, just a little more than 23 years ago.

*Mathematica* 1.0 was released on June 23, 1988—with over 600 built-in functions.

I think it was very important that before I worked on designing *Mathematica*, I'd spent a decade doing basic science—eventually working on precursors of what became NKS.

I viewed the design of *Mathematica* as like a difficult basic science project.

A big puzzle to drill down and find the essence of everything. To find the underlying principles on which things are based.

So from the very beginning, we built *Mathematica* on principles—on powerful unifying ideas.

Sometimes that kind of intellectual purity is an impediment to progress.

But I'm happy to say that in the case of *Mathematica*, it's been quite the opposite.

In fact, as the years have gone by, we've realized just how powerful the principles really are, and just how much we can build from them.

I suppose the first principle of *Mathematica* is unity. Everything has to fit together.

Partly that's a matter of detailed design: of carefully thinking through every function that's added to the system, to make sure it fits in well with everything else that's there.

But what makes this possible is really a fundamental organizing idea: the idea of symbolic programming.

The idea that everything can be represented in a unified way, as a symbolic expression.

And then that this unity of representation makes it possible to have language primitives that apply in a unified way to everything.

Well, unity has been one guiding principle of *Mathematica*.

Another is automation.

The idea that once you tell *Mathematica* what you're trying to achieve, it should as much as possible automate actually doing it.

So that, for example, it automatically picks what algorithms to use, automatically works out how best to present your results, and so on.

Automation is sort of a key engine of progress through the world of technology.

Because it's what lets you not have to worry about one layer, and be able to work on a layer above.

And in a sense unity and automation together do something really remarkable: they make it possible to build a system in a sort of recursive exponential way—so that the whole becomes greater and greater than the sum of its parts.

Unity is what lets one part of the system readily make use of all the other parts.

Automation is what lets the parts that one can use to build more in the system be ever larger.

It's really been a thrill over the years to see these principles play out in what can be achieved, and built, in *Mathematica*.

In some ways, it's been a humbling experience, though.

Because it's often taken a very long time—sometimes a decade—to see just what might now be possible, given what's been built so far.

Even after all these years of experience, it's hard to imagine what might be possible until you have the actual concrete technology—and often use it for several years.

And for example right now it's certainly clear that that's happening with Wolfram|Alpha technology.

Well, you know, when we first introduced *Mathematica* 1.0, we described it as "A System for Doing Mathematics by Computer".

The structure that we had built—the whole symbolic programming system and so on—was certainly much more general than traditional mathematics.

But mathematics was an important core area for us, and is what we emphasized first.

So how did things evolve after Version 1.0 in June 1988?

Version 2.0 arrived in 1991, particularly rounding out some of the general language constructs.

*Mathematica* notebooks, with their cell structure and evaluatable content, had already been part of *Mathematica* 1.0.

But we'd thought of them as a separate layer—just an interface around the *Mathematica* kernel.

But at the beginning of the 1990s we realized that a great unification was actually possible.

That with our symbolic programming paradigm, we were able to represent notebook documents just like we represent everything else.

Treat them like data that we can generate, and manipulate, automatically.

Well, it took a few years to develop this idea—but the result was *Mathematica* 3.0, released in 1996.

Which introduced many key innovations. Like symbolic documents. And also generalizations of the very concept of a language.

We get a lot of satisfaction out of building definitive things.

Things that really nail an area; that capture it in a permanent way.

And for example the integrated math input and output system of *Mathematica* 3.0 is such a thing.

It's a unique feature of *Mathematica* that's possible because of the whole symbolic programming and symbolic document structure.

And even though 12 years have passed since it was first introduced, nothing like it exists elsewhere, or seems even vaguely on the horizon.

Well, we'd described *Mathematica* 1.0 as a "System for Doing Mathematics by Computer".

Already by the time of *Mathematica* 2.0 that wasn't a good description, and we invented—somewhat to my chagrin—the term "technical computing".

But after *Mathematica* 3.0 it was clear our paradigm and principles could still go much much further.

There were—as there are now—zillions of special-purpose systems that do little slices of what *Mathematica* can do.

And somehow there was the view that—even though it might not be as convenient to use—a special-purpose system must somehow always be more efficient than a general system.

Well, *Mathematica* 4 and 5 blew away that idea.

And proved that with our principles of unity and automation we could make a general system that was actually *more* efficient, not less, than special-purpose ones.

Numerics was a big example of this.

And the critical point was that numerics can be done most efficiently if it's not just done with numerics.

If one can rely on robust, automated, symbolic analysis—or on-the-fly symbolic algorithm construction—in the middle of a piece of numerics, it's possible to do it much, much more efficiently.

And the crucial point is that with the unity and automation of *Mathematica*, it becomes in a sense cheap to do all these fancy things as part of any old piece of numerics.

Unity and automation let us create ever larger building blocks—which we can use to build more and more, at a faster and faster rate.

And as we moved through *Mathematica* 4 and 5, and into the years beyond, our rate of algorithmic progress has been ever increasing, maybe even almost exponentially.

But there've been big new ideas as well.

Starting soon after *Mathematica* 3, we started wondering whether our symbolic paradigm could be used not just for what one might call static results, but also to create dynamic results.

It took a while. But in 2006 we finally finished it.

Really reinventing *Mathematica*. Creating the concept of dynamic interactivity. And in a sense taking *Mathematica* from a language for creating static results, to a language for creating interactivity.

We'd come up with `Manipulate`, and we'd figured out how to use the symbolic paradigm to represent controls and processes as well as functions and results.

I view `Manipulate` and its friends as a great feat of automation.

Taking the process of creating user interfaces from being one that takes large amounts of manual work, to something that one can specify instantly, and get carried out automatically.

It's really changed the way I work.

Being able to let me create interactive interfaces all the time, in the middle of anything I'm doing.

Well, this arrived in *Mathematica* 6.

And actually *Mathematica* 6 was a huge release.

Our exponential curve of algorithmic development was beginning to be visible.

We'd gotten very serious in things like computational aesthetics—introducing yet another kind of automation.

And we'd introduced the idea of data paclets—of curated data that could automatically be accessed inside *Mathematica*.

And inside our own internal development process, we'd also done a huge amount of automation.

Building up a very sophisticated software system for building and testing *Mathematica*—a giant collection of *Mathematica* programs for creating *Mathematica* itself.

And we'd been sharpening some of our more secret weapons.

Like using NKS methods to discover algorithms just by searching the computational universe.

In a sense it was fitting that *Mathematica* 6 came 18 years after *Mathematica* 1.0 was born.

Because I felt it was really the time when *Mathematica* came of age.

When we could see just how limitless the possibilities are. And when we'd created systems that could really let us capture those possibilities.

Well, *Mathematica* 6 was a huge release. And we might have thought that after that, we'd rest for a while.

But no. Those of you who were here last year will remember that we had a big surprise at this conference.

18 months after *Mathematica* 6, we were able to release *Mathematica* 7.

Which was another huge release—with more than 500 new functions just in that one release. Almost as many functions as the total in *Mathematica* 1.0.

We introduced integrated image processing. Integrated parallelism. Symbolic charting. Boolean computation. Discrete calculus. Genomics. Weather. And lots and lots more.

A huge release.

Well, that pace of development has not just continued. It's become even faster.

The pipeline that we have heading for *Mathematica* 8, *Mathematica* 9, and *Mathematica* 10 is really incredible.

I think already this morning there's been a preview of a few things.

But the whole collection is really, really remarkable.

I suppose the thing that's most dramatic to me is this.

In the early days of working on *Mathematica* I had all these to-do lists.

I knew it was a long-term project. That there was just a huge stack of things that we would have to build to make possible things in the later parts of the to-do list.

Where if it was going to be possible to automate that kind of computation in a robust way, it would have to rely on integrating a dozen other kinds of computation.

Well, here's the exciting thing. In the next couple of *Mathematica* releases, we're going to be able to get the end of that old to-do list of mine!

Before *Mathematica* reaches its quarter century, my whole original to-do list is going to be done.

It's a great feeling—to see the whole arc of *Mathematica* development get us to this point. And to be able to see it go so much further from here.

To realize that all these years we've just been building higher and higher.

And that the layers of algorithms and software that we put down a decade or two ago are what we're building on today.

People sometimes say that software rots.

That's not what's happened with *Mathematica*.

In some areas, there's a decade or decade-and-a-half cycle where individual algorithms end up being swapped out.

But the overall structures have been incredibly robust.

Probably because they are based on incredibly robust core principles, like unity of design, and automation of operation.

Well, other keynotes at this conference are covering some of the specific things that are in our R&D pipeline.

But let me at least give a few examples.

One big area is PDEs. Strong, general, PDEs.

This is one of those areas where doing it well requires already having a huge stack of other capabilities.

Symbolic analysis. Computational geometry. Fast linear algebra. Lots of other things too.

There are huge design challenges.

How does one specify boundaries, and equations, cleanly and efficiently?

I think it's been nearly 20 years since I started talking about "PDE special functions".

The analog for PDEs of ordinary special functions for ODEs.

Well, it's finally possible to implement those in a nice, general, efficient, way.

Which will immediately open up all sorts of new applications for *Mathematica*.

OK. Another area.

Probability and statistics.

In Version 7, we added the whole `FittedModel` structure, for handling statistical models.

With a clean, but fairly traditional, approach.

But what's coming is an amazing whole structure that only *Mathematica* can ever even get close to.

A whole symbolic mechanism for representing empirical distributions, and doing computations with them.

It's going to make handling probabilistic models as easy as doing algebra.

In one fell swoop generalizing and making accessible a vast swath of probabilistic methods that exist in many different fields.

Making *Mathematica* not just *a* system for doing statistics, but the *only* system that has a core understanding of statistics—and that lets one in a unified way apply all the modern methods for handling data and models.

Oh, yes, and in a very nice, clean way, being able to check off from my old to-do list: handling numbers and data with statistical errors.

OK. Something else.

In *Mathematica* 7 we introduced discrete calculus, and things like integer sequence recognition.

Well, coming soon in the pipeline is a vast amount more discrete mathematics.

Especially in graph theory.

You know, in Version 6 we introduced `GraphPlot` and its friends for automatically laying out networks.

They're incredibly useful functions. I use them all the time.

Well, to really do the kind of unified job of graph theory that we want to do in *Mathematica*, we need tight integration between this kind of visualization, and actual computation with graphs.

And that's what's coming.

With lots of very strong algorithms for handling essentially arbitrarily huge graphs.

I happen to be looking forward to that for some basic science applications of my own.

But I think that there are going to be a huge number of applications of what's in a sense consumerizing heavy-duty graph theory.

What else?

Well, I mentioned before that every decade or decade and a half or so we're finding it's worthwhile to revisit algorithmic areas.

Because sometimes there are general advances in algorithms in those areas.

But usually more importantly, there are enough ambient developments in *Mathematica* that we can really rethink the way we handle the area.

We did that for symbolic differential equations in Version 6. For sums and products in Version 7.

Well, that same kind of process is rippling through other areas.

An example in the pipeline is symbolic linear algebra. Doing matrix operations efficiently on matrices with symbolic entries.

Very useful if one can make it work fast. And with all the supporting functionality that now exists in *Mathematica*, together with some clever mathematical algorithms, we can.

Then there's equation solving. We introduced strong `Reduce` functionality in Versions 4 and 5.

There's a much stronger general `Solve` in the pipeline. The first really major update to `Solve` since Version 1.

Oh, yes, another algorithm breakthrough area: `NIntegrate`. We've developed a whole bunch of new algorithms for handling functions that oscillate.

`NIntegrate` is sort of a black-magic function—that has to get an answer efficiently without taking the time to look too much.

Well, it's symbolic analysis that allows it to work.

We've been pouring all sorts of sophisticated ideas into `NIntegrate` for years. But just recently we had a breakthrough that's really going to extend it for a lot of practical cases.

OK. Here's another algorithmic area: tensors.

Manipulating tensors has been a classic symbolic computation activity for more than 40 years.

I worked on it myself a zillion years ago.

And in *Mathematica* there are several very good tensor packages that have been developed.

But somehow I've never been satisfied.

It's always seemed like tensors can only be introduced as a bolt-on—a subsystem with its only separate syntax and structure.

Well, the exciting thing we have coming in the pipeline is fully integrated tensors.

And in doing that integration—which is a really difficult piece of design, I might add—we're getting a whole lot of other things.

Generalizations of arrays. Sophisticated handling of permutations. Et cetera.

An old problem in tensor analysis is canonicalization of tensor expressions; telling whether one can swap indices around to establish equivalence or not.

I worked on this a bit myself a zillion years ago. I always thought some kind of graph theoretical approach could work.

Well, that's now happened.

And it's going to make doing serious tensor analysis feel pretty much like doing ordinary algebra.

Oh, by the way, a spinoff of the tensors project is going to be—finally—a nice, clean, consistent handling of vector analysis.

OK, yet another area.

It almost made it into Version 7, but we weren't quite happy with it.

A general subsystem for dealing with wavelets.

Integrating wavelets into everything they can be. Images. Signals. And symbolic computation.

Dealing in effect in a quite general way with nested as well as periodic decompositions.

OK. In Version 7 one of the very nice enhancements was symbolic charting.

Bar charts. Pie charts. Histograms. But all based on a clean, symbolic design that lets one maintain data in a structured, symbolic way and propagate it through computations and plots.

Well, in our pipeline is a whole zoo of chart types.

It's a little like special functions. In the history of visualization in all sorts of fields, different ideas have been invented.

Candlestick charts in finance. Radar plots in data analysis. Plots in the complex plane for complex analysis. Whatever.

Well, we're going to be introducing all of those into *Mathematica* in a nice, clean way.

So you can use them not just in some special hacky way in the field where they were invented. But in a nice general way across every field.

Oh yes, and we're going to solve one of my decade-plus favorite problems: introducing general scaling functions to let one handle any kind of functional transformation on the scales of a plot.

OK. Well, there's a lot with core graphics too.

Some of it is algorithmic. Some of it takes advantage of advances in things like graphics hardware.

On the algorithmic side, we've got a lot with computational geometry, and meshing, and region descriptions coming.

These are core capabilities that let us do exciting things where we can move the frontiers of what's possible in computer-aided design and so on.

There are also core visualization enhancements. Like generalized texture mapping for surfaces, all fully integrated into the system.

You know, the list of things in our R&D pipeline is really long.

It's such fun right now. We've built up so much in *Mathematica*. We're really just able to go on adding and adding.

And—at a least with a lot of hard work in design analysis—the whole system really fits together.

So that the things we're adding have impact not just in their specific areas, but all over.

In Version 7 we introduced integrated image processing.

And I must say that I've personally found it quite amazing how often I want to use image processing for all sorts of things that I wouldn't usually ever have thought of as image processing.

But because it's all integrated into the *Mathematica* system, I can just do it.

Well, the image processing in *Mathematica* 7 is pretty impressive. But it's nothing compared to what's coming.

Lots of sort of higher-level image processing.

One of the ways we implement automation in *Mathematica* is with superfunctions. Things like `Solve`, that just goes off and solves equations—and takes care of how it happens.

Well, we've got a bunch of image processing superfunctions coming. Some pretty surprising stuff.

Oh, and it's all really efficient. Efficient enough that one can use it not just on static images, but on video too.

And to support that, we're making it so that things like `Import` and `Export` get generalized to real-time streams of data.

Yet another giant project that we're now able to do in an integrated way.

OK, here's another thing.

Control theory. There are a lot of interesting methods that have been developed in control theory over the last few decades that actually deserve to be better integrated into general analysis, and model-building, and so on.

Well, partly building on the add-on *Control System Professional* package, we've figured out how to real integrate control theory methods into core *Mathematica*.

It's very strongly based on nice, clean, symbolic representations of control systems.

But what's important is that we're bringing all this stuff right into *Mathematica*.

So it can interact with our statistics functionality. Our graph theory. Our linear algebra. Whatever.

You know, it's really a spinoff of the unity principle for *Mathematica*.

The idea that everything should be built in.

That you don't do your work by buying a bunch of separate add-ons, each its own strange world.

But that you just get one integrated system: *Mathematica*.

It's a lot more powerful that way. Because you can count on being able to draw on anything you need.

You've got the biggest, strongest building blocks to use.

OK. Well. One general direction is integrating methods from lots of areas. Figuring out how to design them in general ways.

It's difficult work. But the good news is that we've gotten faster and faster at it over the years.

I think some of the design challenges that we now routinely solve in a couple of hours we'd just have gotten stuck with a decade ago.

Probably that's one of the reasons we're able to see such growth in *Mathematica* in these years. So many things coming off my to-do list from 20 years ago.

We've needed to build all the ambient algorithmic capabilities. But we've also needed the experience to do design.

And it's tremendously satisfying to me how many old design chestnuts we're cracking these days.

In fact, I think they're almost all gone. Though now that we can see further, there are definitely some challenging new chestnuts on the horizon.

Well, back to areas that we're integrating.

GIS is an example. We've already got various import/export formats, and in Version 7 we added very strong geodesy capabilities.

Well, that was a precursor to comprehensive GIS and mapping support. Which is coming.

Another area that we're integrating is financial computation.

Since Version 6, we've had financial data capabilities.

Well, now we're adding all sorts of financial computation, built right into *Mathematica*. Both simple stuff, for cash flows and time value of money and so on.

But also really elaborate stuff with valuing fancy financial instruments. That relies on really crunchy numerical and algorithmic capabilities.

All right. What about user interface capabilities?

That's a whole 'nother story.

I think people will be happy to hear that our user interface group is finally convinced that paper and printing are not going to go away.

So in the pipeline is lots of polishing and enhancement to our printing capabilities.

To help one make beautiful PDFs and things with *Mathematica*.

Oh yes, and there's also a bunch of new capabilities for defining and manipulating styles and stylesheets.

Making all that more streamlined.

There are things coming, like `Overlay` and `MultiscriptBox`.

These may sound straightforward, but they're really tricky to design so they really work smoothly.

Talking of which, there's a lot of smooth going on in our drawing and graphics editing capabilities.

There are metaphors for using those tools that come from drawing programs, or image editors, or whatever.

But the *Mathematica* case is much more general. And it's really a challenge to fit all these general capabilities into a small collection of gestures that are really smooth to use.

It's been an interesting exercise for our usability group. Really watching how people use these tools.

And figuring out how to smooth things out—so the graphic never jumps in some confusing way because it's redoing its plot range, but still manages to take advantage of the best plot range heuristics, and so on.

Well, talking of metaphors. One standard computing metaphor that we've never particularly captured in *Mathematica* is the spreadsheet metaphor.

And that's another thing that's coming: a `SpreadsheetView`, that lets one get all the advantages of spreadsheet-like data entry, but integrated into the generality of *Mathematica*.

OK. Another big direction.

In *Mathematica* 1.0, the basic metaphor for the *Mathematica* language was linear text, like ordinary human languages are written.

In *Mathematica* 3.0, we introduced 2D input—real math notation that we could parse and understand.

Well, we've been thinking for about 20 years about how to smoothly go beyond that: to have whole networks as input.

In *Mathematica* 6, when we integrated graphics right in with typeset input, that became somehow structurally possible.

But what we've really wanted to do was to invent a way for people to smoothly make use of such capabilities.

"Drag and drop" is a metaphor that's pretty nice for some applications, and some interfaces.

Flow charts or block diagrams are nice for some other interfaces.

We've now for the first time in the *Mathematica* front end got the raw material to generalize all of this, and make a whole new level of interface.

Well, we're making very interesting progress on that. I think it's going to be demonstrated elsewhere.

And there are still some serious problems to be solved.

We keep on saying "there's a `Manipulate`-like function lurking here". Something clean and simple that really unlocks a sophisticated set of capabilities.

Well, we haven't found that yet. Maybe it'll come in the next few weeks. I'm pretty hopeful.

But it's a breakthrough that's been a decade or perhaps two in the making.

Alright. So that's a little on our core *Mathematica* R&D pipeline.

There's a lot going on in the way *Mathematica* is interfaced to the outside world as well.

More on parallelism.

Work on GPUs.

Still more import and export formats and capabilities.

And here's a big direction: embedding the *Mathematica* interface into things.

Making *Mathematica* notebooks be smooth plug-ins.

Coming very soon is a complete browser plug-in for all the common browsers and platforms, so you can seamlessly run a *Mathematica* notebook inside a web browser.

So that if you click on a `.nb` or a `.nbp` file, it'll just automatically download a plug-in—typically a version of *Mathematica Player*—and it'll just open in the frame of your browser.

The same idea is coming for example for PowerPoint. So right in the middle of a PowerPoint presentation, you can have a live *Mathematica* notebook, with `Manipulate` and everything.

Well. There's a huge amount in *Mathematica* already today. And new things are being added at an incredible rate.

It's becoming easier and easier for people in all sorts of fields to immediately use *Mathematica* in their work.

So another big initiative we have is to define specific *Mathematica* solutions for all sorts of different areas.

You'll see some that emerging right on our main website.

That's what the Solutions tab is about.

There are already a few dozen specific areas that are covered. We're going to be going even more deeply into these, and we're going to be adding a lot of other areas.

Really defining in each case the ways to use *Mathematica* in each area, and communicating the definition to people working in that area.

Over the course of the next year, people are going to be hearing a lot more about *Mathematica* in a lot of different fields.

We've got a spectacular set of capabilities for people; now we're really defining how *Mathematica* can immediately be used.

Both within individual fields, and for all the innovative stuff that happens in the boundaries between fields.

Where unity of design and automation are absolutely crucial. Where it's no good to have a canned system that was just built for one field or another.

Where you need *Mathematica*, and nothing but *Mathematica*. Because that's the only way to bridge the methods and techniques of different fields in a smooth and integrated way.

Well, OK, there's a lot going on around *Mathematica* as a product, and enhancements to *Mathematica*.

We brought out *Mathematica Home Edition* this year, and that's been a big success.

Our technology has reached the point where it's really accessible to all sorts of people, professional or not. And *Home Edition* provides a way to reach people who, at least now, have a more casual, hobbyist, interest.

As we continue to broaden our licensing models, there's some interesting new technology coming there too.

We've been working hard for years on a whole new activation scheme for *Mathematica*, that'll make it easier to install and administer and use *Mathematica* in complex IT environments, and elsewhere.

A big innovation in *Mathematica* 6 was a whole new structure for our documentation system. Introducing tens of thousands of pages of examples. Introducing ideas like guide pages and so on.

What we did with the documentation system is actually one of the things that unlocked a bunch of growth for the *Mathematica* system.

That allowed us to expand the structure of the system while still communicating it clearly to people.

Well, another thing that happened this year is a new version of Wolfram *Workbench*.

Some people use *Mathematica* to do one-line computations. And that's great.

But one of the impressive features of *Mathematica* is still it's a completely scalable system.

That goes smoothly from one-line usage to building huge systems.

Systems with for example millions of lines of code in. Like *Mathematica* itself. Or for example Wolfram|Alpha.

Well, part of what makes it feasible to build such huge systems in *Mathematica* is the software engineering tools we have.

*Workbench* is one of those. Plugging into Eclipse, which lets one develop with a large team, potentially even across several languages in addition to *Mathematica*.

Well, there's a new version of *Workbench* now that has additional capabilities—particularly for generating what one might call "*Mathematica* style" documentation. As well as for setting up tests and so on.

Also in the software engineering area, there's web*Mathematica* 3.

This year we got a lot of new proof that web*Mathematica* is really capable of running a large production system—because it's running the whole of Wolfram|Alpha.

But web*Mathematica* also introduced some other very interesting capabilities.

Like having a Flash interface to `Manipulate` capabilities.

So that you can move controls on the client side, in your web browser, and have that go directly through web*Mathematica* to run on the server.

We're still trying to figure out all the things we want to do with these capabilities.

But I'm guessing a bunch of you will actually—maybe actually already have figured—some really interesting things there.

OK. Well, what else have we been up to?

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.

How does this integrate with *Mathematica*?

There will be functions in future *Mathematica*s that allow the Wolfram|Alpha API to be called from within *Mathematica*. So huge amounts of data and specific algorithms available in Wolfram|Alpha will become available through functions in *Mathematica*.

Another very important direction is using the freeform linguistic capabilities developed in Wolfram|Alpha and making them available in *Mathematica*.

In *Mathematica* we have this very systematic language that allows us to systematically build things. In Wolfram|Alpha we have this thing that is very easy to get started with.

Can we merge these two to get the best of all worlds? We're working hard towards doing that.

The basic concept is to be able to start off using freeform linguistics to specify what you want to do, and specify each piece of what you want to do and then get out systematic *Mathematica* code that you can assemble into a larger and larger system.

So: Wolfram|Alpha has definitely raised our visibility this year.

It's a first in many ways for us.

It's our first major spinoff company.

Our first really strong production web system.

Our first deeply consumer offering.

It's turning into a great business... with a whole ecosystem developing around it.

But it's also a great piece of outreach.

You know, our company has been very committed forever to all sorts of outreach.

Maybe it's because we have a product called *Mathematica*... but I think we're by far the most prominent math outreach company in the world.

With things like *MathWorld*.

With the work we do on the *NUMB3RS* TV show.

We also support in various ways what must be almost a complete set of math competitions, and math outreach.

As well as lots of our technical education initiatives and so on.

We've been doing the NKS Summer School very successfully for seven years; Advanced *Mathematica* Summer School for two.

This year we'll be starting a summer program for high-school students.

Of course, one of our prominent pieces of outreach is the Wolfram Demonstrations Project.

We've developed a sort of post-web-2.0 approach... for Demonstrations... for volunteers for Wolfram|Alpha.

There's a lot going on.

I think we've developed some fantastic technology platforms.

We're also continuing to develop our company.

We're growing very rapidly—recruiting all sorts of outstanding people.

We've got a lot of opportunities right now.

Our sort of positioning in the world—not only in terms of technology but also corporate brand and access to very interesting opportunities—is really great.

We've been solidly building for 23 years...

Looking at our various metrics, I think we're heading for a breakout year for our company.

Thanks for being with us here.

Thanks for sharing our journey.