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

Because of the importance of groundwater recharge and discharge in the hydrological cycle, the U.S. National Research Council (NRC) deems research on them to be of critical priority. However, their rates and patterns are so complex that it takes years of study to estimate them.

With a team of colleagues, Lin is developing a suite of Mathematica interactive manipulations that utilize advanced matrix-computing and image-processing algorithms. It has several user interfaces, and offers the flexibility to apply expert-level knowledge to extract spatial patterns. It also provides a generic pattern-recognition approach that supports virtually any spatial decision support system (SDSS) used to assist in management applications such as water resources, land use, and agricultural development.

More details and other applications are on the Mathematica Solution for Geosciences page. You can find more on Lin’s work and other cutting-edge uses of Mathematica in our Portraits of Success pages.

During last year’s keynote address, Stephen surprised attendees with news about the release of Mathematica 7—just 18 months after Mathematica 6. This year, he said our development pace has become even faster.

The following video clip includes a few examples of what our R&D team has in the pipeline for future versions of Mathematica. (You can see the first part in our series of highlights from Stephen’s keynote here.)

Transcript Excerpt:

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 geoemetry, 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.

Stephen says Wolfram Research will follow up an extremely successful 2009 with a remarkable “breakout year for our company” and the Mathematica community.

Over the next few weeks, we will be sharing video highlights and transcript excerpts with you from Stephen’s conference keynote.

In the first part of this series, Stephen shares the history and trajectory of Mathematica, including some insight on what he calls the “most dramatic” development for him.

If you can’t see the video, please enable Flash in your browser or install the latest version of Adobe Flash Player.

Transcript Excerpt:

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.

Not surprisingly, we’ve seen increased interest in Mathematica’s financial applications stemming from the current economic struggles. Accurate models and analyses are in demand to determine the best way to get the world’s economy back on track and prevent future crises.

That’s a great match for Mathematica’s powerful capabilities.

To showcase how effective Mathematica is, we designed a portal to demonstrate its capabilities for financial applications. The new Mathematica Solution for Financial Risk Management web page, which I researched and created, is a comprehensive overview of what Mathematica can do in finance.

On the page, you’ll find tutorials, articles, documentation, and other resources to get you started. You can also view telling case-study videos and written descriptions of how finance professionals use Mathematica to get their jobs done.

For example, in one user story Fannie Mae economist Bernard Gress details how he created new mortgage-forecasting models utilizing Mathematica. In another, Alan Savoy of nGenera discusses combining Mathematica and webMathematica to build an online financial analysis tool.

One of the things I enjoyed personally about the project was going through the financial category of the Wolfram Demonstrations Project. There are currently nearly 200 financial Demonstrations—some of them tools created by finance professionals to use in their work, some of them created by educators to teach certain concepts (I admit I found those really useful), and some written by developers to show off various things Mathematica can do in the world of finance. And all the code used to create them is freely available, making them a great starting point for your own explorations.

I’d like to share some Demonstrations I think you’ll enjoy.

The Constant Risk Aversion Utility Functions Demonstration by Seth Chandler is interesting because it requires Mathematica to solve a second-order differential equation symbolically in real time whenever the parameters are changed, to plot utility functions that exhibit constant risk aversion under the Arrow-Pratt measure.

You can choose whether to show the constant absolute risk aversion curve or the constant relative risk aversion curve, vary the risk aversion coefficient, and set the coefficient’s value at two points along the curve.

Jason Cawley’s Credit Risk Demonstration looks at 30 years of actual data on corporate bond performance, then creates a Markov chain model of credit risk. Using Mathematica’s ability to manipulate lists of data and create visualizations, the Demonstration shows how the ratings of 100 simulated bonds change over time.

When using the tool, you can adjust the maturity, the length of call protection, the starting rating, and the subordination, or choose a new random seed for the simulation.

Robustness of the Longstaff-Schwartz LSM Method of Pricing American Derivatives by Andrzej Kozlowski uses the Longstaff-Schwartz least squares Monte Carlo method of computing the value of an American put option, approximated by a Bermudan option with 50 exercise times. It’s an intriguing Demonstration because it shows how Mathematica Demonstrations can be used to study problems in current financial research; the author references two journal articles.

In it you can select three kinds of bases and can vary several parameters including degree and number of paths of the Monte Carlo sample. The Demonstration produces a plot of the expected cash flow vs. stock price.

These are just a few of the Demonstrations that show how financial professionals use Mathematica to model, compute, and analyze.

When you get a moment, check out the Mathematica Solution for Financial Risk Management website. Let us know what you think, and also let us know how you’re using Mathematica in your financial work—leave your comments below.

I always analyze and explore these problems in Mathematica. Being a kernel developer, I see whether Mathematica can indeed find a solution. This last issue has challenging problems, and it was particularly gratifying to observe that Mathematica could solve them right out of the box. So here are my solutions to three of the paraphrased problems:

Problem 11457, by M. L. Glasser:

Solution in Mathematica: Relaxing assumptions on a and b to avoid degenerate cases:

Problem 11456, by R. Mortini:

Solution in Mathematica:

Problem 11449, by M. Bataille:

Solution in Mathematica: As the expression is left unchanged by the variable’s rescaling, and as c is positive, let us set c==1.

Hence the minimal value of 9/8 is attained for a==b==c.

Because the expression is left invariant by interchanging any of the variables, the maximum value of 2 is attained for a==b==c/2 or a==c==b/2 or b==c==a/2.

Also today, Wolfram Research developers spoke on the growing capabilities of Mathematica, Wolfram|Alpha, and the new Wolfram|Alpha API. In addition, our users covered a great range of topics with presentations from teachers and their students, researchers, and business professionals.

One of the nicest things about the conference is having developers and users in such close proximity. Both groups take advantage of the time between talks and during meals to discuss project needs and problems, and try to work out best solutions. There is also a lot of creative thinking about the future.

We look forward to sharing more about this year’s conference with you.

Along with many Wolfram Research developers, Mathematica users from all over the world have been speaking on the myriad ways they explore those same features and technologies in their projects. With so many interesting topics, choosing which talks to attend can be difficult.

The afternoon started with Stephen Wolfram’s keynote speech. The talk covered a timeline of growth for Mathematica, Wolfram Research, and Wolfram|Alpha. The recent Wolfram|Alpha API and iPhone application were discussed, as well as items like the Wolfram|Alpha corporate and professional versions that we can look forward to using in the future.

Attendees represent everyone from new users to longtime enthusiasts. We’re excited to see all of you and are looking forward to the rest of the conference.

Late last week we introduced the Wolfram|Alpha Webservice API, allowing outside developers to call Wolfram|Alpha from their websites or application programs.

Then yesterday we released the first mobile implementation of Wolfram|Alpha, in the form of an iPhone app.

Tomorrow, we’re doing something completely different: Wolfram|Alpha Homework Day—a 14-hour live webcast event for students and educators.

Oh, and starting on Thursday is the International Mathematica User Conference, which will show many advances in the core Mathematica technology on which Wolfram|Alpha is based.

In May we launched Wolfram|Alpha as a major website. But the website is really just the tip of an iceberg. Wolfram|Alpha is a whole technology that can be deployed and used in all sorts of ways.

This week we’re seeing some of the diversity of what can be done. The API as a tool for developers. The iPhone app as a consumer product. And Homework Day as a community event that Wolfram|Alpha enables.

My approach to managing R&D is to maintain a portfolio of ongoing projects, short-term and long-term. There’s an amazing amount in the pipeline for Wolfram|Alpha, which will emerge on timescales from weeks to years.

I’m very proud of the achievements of our various teams that we’re seeing this week. The diversity of what’s becoming possible with Wolfram|Alpha is surprising even us. There are a lot of very exciting things to come…

Mathematica and Wolfram|Alpha are great resources for both teachers and students. Using the two together is a good way to explore topics in more depth. This video shows a few examples of how you can utilize Mathematica and Wolfram|Alpha in your own classroom.