# A Remarkable Year Ahead for *Mathematica*

Future *Mathematica* features, new directions for Wolfram|Alpha, and how the two Wolfram technologies will be integrated were highlights of Stephen Wolfram‘s keynote address at the International *Mathematica* User Conference 2009.

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.

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

Stephen Wolfram’s paradigm is so ambitious, and it is great that such ambition has created these great products (Mathematica, Wolfram|Alpha, GridMathematica, etc.).

I want to thank Stephen Wolfram for giving a teleconference to UNAM, Mexico. It was great to listen directly from him all this exciting history of ideas, work and success.

Jose

Will be nice to know what are the items in the to do list so that we know what’s coming on Mathematica 8 and Mathematica 9!

Is that possible make a timeline for Mathematica as well ?

http://www.wolframalpha.com/timeline.html

So that new features and milestone from version 1 to 7 are more clear.

Will love to have full ray tracing capabilities inside Mathematica will that be one in the to do?

I am using some of their products, and i think they made great contribution to the industry, Stephen Wolfram will be remembered for the work

We will always be grateful to wolfram sir for his great and timeless work.

Around 1960 IBM’s main computer was the 1401. Its main programming language was called SPS. Symbolic Programming System, Previously you wrote ‘Machine language’, quoting memory addresses explicitly. With SPS you gave each address a name.

I’ve used Mathematica since version 1.2 and it has been a very interesting journey so far. Can’t wait for the next releases.

Kudos to Stephen Wolfram for his contribution and grateful to his efforts that changed the way things work now.