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