Keynote address at the 1998 Worldwide Mathematica Conference, Chicago

Thank you very much. And thank you all very much for coming here to help us celebrate the first 10 years of Mathematica.

Well, I’ve decided to make a slight break from tradition this morning. At essentially every Mathematica conference in the past, I’ve started the conference off by demonstrating some of the technology we’re developing. But this time I’m going to let some of the other people at our company describe that, and I’m going to talk here about some more personal things—about history, about the future, and about how this thing we call Mathematica came to be in the first place.

To do that I have to talk a bit about the goals that I’ve had in my life and about some of the things I’ve done to achieve those goals.

I’m not sure how respectable it is to say this in the modern world, but I guess I have to say that what’s driven most of what I’ve ever done has been fairly intellectual things. I’ve been interested in ideas and in making things happen with ideas. Mostly I’ve been interested in scientific and technical ideas and in discovering and inventing new things in science.

I was pretty young when I first got interested in science, but I got rather serious about doing it rather quickly. I read lots and lots of books, mostly about physics, and I got really interested in trying to figure out all sorts of problems in physics.

But one thing I realized very early was that for me to be interested in something I had to be somehow doing something unique. I wasn’t the slightest bit interested in solving problems that were exercises in a book because I knew that other people must have solved those before. I was only interested in solving problems that it didn’t seem like anyone had ever solved before.

Well, when you do an exercise in a book, it’s usually set up so the calculations you get into aren’t too complicated. However, if you’re trying to solve a problem that hasn’t been solved before, you’re always running into all sorts of really complicated and messy calculations. I quickly got exposed to lots of those. At first that was quite a problem because I was never terribly good at chasing down all those minus signs and factors of two and so on.

By the time I was a midteenager in the mid-1970s, I made an important little personal discovery: I didn’t actually need to do all those calculations myself—I could just get a computer to do them for me. I invented all sorts of tricks for working out complicated algebraic things with help from fairly simple computer programs, and so I got pretty good at things like recognizing combinations of special functions from surprisingly few terms of a power series.

I actually suppose it was fairly amusing because I ended up publishing papers with all sorts of extremely complicated calculations in them. As a result, people thought that I was some kind of calculating wiz—but actually the real hard work of almost all of those calculations was done by a computer.

By the end of the 1970s I had finished being a teenager and had become a fairly respectable young particle physicist. But as I thought about doing particle physics for a living, one of the least palatable things that I realized was that I would have to spend a huge fraction of my time calculating things and not really particularly thinking about actual ideas.

I was already using the best computer tools that existed, and I had built quite a few of my own. But things definitely weren’t streamlined. Each calculation was its own separate challenge and had to be done by putting together different tools in different ways. Eventually I realized that the only way calculations could be done in a truly streamlined way was for a whole new kind of computer system to be built.

At first I didn’t even consider doing such a thing myself, and I tried to persuade the people who’d built some of the tools that already existed to do it. But mostly they told me that what I wanted to do was far too ambitious or downright impossible. So after a while it became clear that—as so often—the experts weren’t going to be much use. If I wanted such a system, I was going to have to build it myself.

So in November of 1979 I started to do just that—I began the project of building a streamlined system for doing all the kinds of calculations I thought I’d ever need to use in particle physics and elsewhere. In some ways I might have liked to keep the whole thing completely to myself—as my personal calculational secret weapon—but it was a huge project and since I was going to put all that effort into it, I figured it made sense to make sure lots of other people would be able to use it too.

Actually, just to have something that would work for all the things I wanted to do, I needed a proper production-grade system, not just some kind of academic toy. So I got very serious about system design and software engineering and quickly started building a huge program in what was then the new-fangled, system-implementation language called C.

I called what I built SMP, a symbolic manipulation program. Its main emphasis was on doing large algebraic calculations of the kind that come up a lot in such areas as particle physics. But I wanted the system to be extensible, so I thought about how to enable others to define their own structures in it.

Looking back, knowing Mathematica, one can already see in SMP the seeds of a lot of key ideas that ended up being crucial to Mathematica. Probably the most important of those was the idea of pattern matching.

I’d had quite a lot of experience working trying to specify things like algebraic computations in standard procedural-style languages. And it was incredibly frustrating. One was always having to make a loop asking for the second part of the first part of whatever, checking that it was a plus sign, and so on—constantly taking expressions apart and putting them back together again.

Well, I knew that wasn’t even close to the way that I myself thought about dealing with expressions. And so what I decided to do was to work out how I could emulate on a computer the way I actually thought about manipulating expressions. And what this led me to was the idea of using pattern matching and of simply being able to say "an expression that looks like this should be transformed into one that looks like that."

Well, at first I started off thinking about that in fairly mathematical terms—that one wanted to identify elements of the some set and so on. But pretty soon I realized that the cleanest, most elegant, most general way to specify pattern matching and transformations like that was essentially purely structurally. And that was pretty much how it was implemented in SMP. Well, the details weren’t nearly as nice as they are now in Mathematica. But the idea was already there. And like a lot of ideas—and particularly a lot of ideas in Mathematica—the really crucial thing was the fact that I had managed to boil everything down to a very simple and very general concept.

Even though I’d started off mainly thinking about manipulating algebraic expressions, I’d come up with something very general that ended up providing a whole different way to think very generally about computations.

Well, part of that I realized immediately. But like a lot of kind-of-foundational ideas, it really took many years and a lot of experience before I really understood the true significance of it.

From a practical point of view, the first version of SMP came into existence in 1981, and immediately I and quite a lot of other people started using it. I had thought that SMP would be useful to people in all sorts of areas of science and technology, and it was great to see that people started being able to use it.

But there was a problem: I had to figure out some kind of structure to really let the SMP system grow. Up to that time I had just been a simple academic. But it became very obvious to me that academia wasn’t the place to have something like SMP really develop to realize its potential. A company was where it should be. So, much to the horror of some of my academic colleagues, start a company I did.

And actually I made one big mistake. I decided that since I was just an academic, I should bring in professional management experts—and turn over the running of the company to them. Well, I must tell you that’s the last time I’ll ever do that.

There kept on being decisions that I thought were really stupid. But since I wasn’t supposed to be running the company, I said, "OK, go ahead and do it your way." But after a while I realized that almost every one of the decisions that I thought were stupid really were stupid—and that actually my simple commonsense thinking wasn’t so bad after all.

Well, SMP as a product didn’t do badly, and I know that some of you here were users of it. But the company wandered off into all sorts of other random things, and I ended up pretty much leaving it to its own devices. And actually, to my amazement, it did in fact survive—and after an extremely long time even achieved its objective a few years ago of going public.

But already in 1982 I had started to go back to doing basic science, and actually working on SMP had made me get much more ambitious about basic science. I guess SMP made me realize that one really could start from nothing and kind of, just with one’s hands, build a pretty big thing. But at a more conceptual level it had also gotten me thinking about how complicated things in science and nature could get built up from simple components.

You see, in working on SMP—and particularly the language in SMP—that’s kind of exactly what I was trying to do: to have a few simple primitives, then to be able to build everything from there. And I realized that the same kind of thinking I’d done in designing SMP could also be applied to basic science.

In particle physics you’re kind of trying to ask: "How does the universe get built up from elementary particles?" But I realized that there’s a much more general question that can be asked: "How does anything that’s complicated get built up from its component parts?"

You see, one of the weird things is that for a long time we’ve actually known all the laws of physics that are relevant to the basic components of everything that we see in everyday life. But this doesn’t mean we’ve been able to explain all the complicated phenomena we see. Actually, we’ve been a long way from that. And the problem is that even though we know how the components work, we just don’t know what happens when we put lots of them together.

It’s a pretty general problem, and it’s one that I ran into pretty hard in 1982 when I was thinking about a whole range of different questions in various areas of basic science. So I decided that if I wanted to make progress, it was no good just trying to build special-purpose solutions in each area; instead, the right thing to do was to try to make a frontal attack on the whole general problem.

Well, the first thing I did was to try using all the various sophisticated ideas in mathematics that I’d learned from doing theoretical physics. But they really didn’t do much good. I mean, one just wasn’t even close to being able to find a mathematical formula for a turbulent fluid flow, or the operation of a brain, or even the shape of a snowflake. So I tried to figure out what I could do instead. 

And what I realized was that I should try to find the very simplest model for the components of all these kinds of systems and then just use a computer to find out how it behaved. Well, the model I came up with was a thing that I later learned was called a cellular automaton—a thing involving an array of black-and-white squares with simple rules for how the colors of squares get updated. And actually it turned out that way back in 1973 I had actually made up a model that was just like this and had even tried running it on a computer. But I’d just tried one case, and it didn’t do anything very interesting.

Well, in 1982 I at first didn’t find anything terribly interesting either. I put in my very simple model, and the behavior that came out from my computer experiment was also very simple.

But then I decided to be a bit more systematic, and I just investigated every single simple model of a particular kind. And I discovered something incredibly interesting. Even though I’d put in very, very simple rules, I got out very complicated behavior—and behavior that looked remarkably like behavior that I’d seen in lots and lots of systems in nature.

Well, I thought I’d discovered something fairly important, and I spent the next several years analyzing it and trying to find out what was really going on. And actually what I mostly found out was that what I’d discovered was actually much more important and more fundamental than I’d initially thought.

At first it was fairly amazing me that nobody had ever discovered this stuff before, but as time went on I realized that to really recognize what was going on, one had to make a pretty fundamental change in the way one thought about things—and that’s something that doesn’t happen so easily.

Well, I got really excited about all this stuff, and the papers I published and so on made quite a stir. And quite a lot of other people started doing things based on what I had done. In fact, before long there were thousands of papers about cellular automata, extending various features of what I’d found out and all that.

There wasn’t anything terribly fundamental that people found out; in fact, somewhat to my frustration, everyone kept on doing huge amounts of work based on fairly trivial features of what I’d done and kept on just not noticing the big conceptual points.

So what I thought was: perhaps the right way to really make these ideas really take root is not only to describe the ideas themselves but also to try and build an infrastructure in the world for letting people do work on those ideas. So I set about launching a new field of science that I called "complexity theory."

I did the obvious things: I started an academic journal for the field, and I founded a research institute for it. But I think the most important thing I did was to define a fairly clear marketing message for the field.

And that marketing message did pretty well. Before long all sorts of people said they were doing "complexity theory," and there started to be all sorts of popular books about the wonders of the field. I think the high point in a sense was a TIME magazine cover about "complexity." Of course, as so often happens, my own role in the whole thing quickly got eroded, which wasn’t especially inspirational for me. But more important, despite a bunch of hype, nobody really figured anything much out beyond what I had already done. And, in fact, they didn’t understand much except the most superficial aspects of what I’d done.

I suppose in a sense it was my fault—because in 1986 I had pretty much left the field and instead started a huge project that in the end is what’s brought us all here today.

All the time that I’d been working on cellular automata and complexity and so on, I’d been using computers and doing computer experiments constantly. But, once again, I’d been unhappy with the tools I’d been using. I had SMP. I wrote lots of programs in C. I used various graphics systems and so on. But I kept on having to write and rewrite things, and I kept on having to build little pieces of code to glue everything together. And I got fed up with it.

In fact, what I figured was that in the end, even if all I wanted to do was to make progress on my science, it would be more efficient for me to take some time and build proper general tools, then go back to doing science, than it would for me all the time to have to build new special-purpose tools as I went along.

Well, I am also a practical fellow. And I realized that there would soon be computers very widely available that would allow a huge range of people to run any general-purpose computer system I built. 

So, with that in mind, I set about designing a very ambitious system that would do everything in technical computing that I and everyone else would ever need. I wanted to make a system that would really last—that would have no compromises that I would later regret and have to try to work around. I wanted a system that would last a lifetime.

Well, my experience with SMP was very, very useful, as was my experience in cellular automata. In SMP I had tried all sorts of fairly radical ideas. Some had worked; others hadn’t. And it wasn’t too hard to tell which was which because I knew which features of SMP I myself had liked using over the years. And I knew which features I and other users had always been confused about.

And from my work on cellular automata I was convinced that it really, really was possible to have simple underlying principles that one could build everything on top of. I mean, at the outset that seemed fairly hopeless. I wanted a system that would do terrific numerical computation, make fantastic graphics, do whatever algebraic computation I wanted, be completely extensible, have a terrific user interface, and do everything. And certainly, from looking at what other people had done, there didn’t seem any way to integrate all this stuff together.

But the crucial idea that I came up with was to represent everything—and I really mean everything—in the system as a symbolic expression, and then to think about all the operations in the system as being transformations on symbolic expressions.

Well, there’s a long history of ideas a bit like this, going back to Leibniz and through the logicians and philosophers of the end of the last century and the beginning of this one. But I had to go a long way beyond what they’d done, and actually what I came up with in the end was much simpler, and much more general, than what had ever been figured out before.

And that’s what’s at the foundation of Mathematica and everything that Mathematica does. And looking back over the last 10 years, I must say that the idea worked out even better than I could possibly have imagined.

I guess I’ve had this experience many times: that if one can really get an idea to the point where it is as simple and clean and elegant as possible, then it turns out to be even more powerful than one ever at first imagines.

Most of the time when people design computer systems, they don’t do any of that. They just take various pieces of functionality and string them together as best they can. And up to a point that works—at least until you try to do something new and different that the people who built the system didn’t happen to quite think of. And then it all falls apart.

Of course, it’s not that making clean, general designs for things is easy. In fact, it’s damned difficult. I think I’ve gotten pretty good at it, but it’s certainly one of the hardest, if not the hardest, thing I know how to do. 

It’s such a weird business too. One starts with lots of sophisticated functionality and ideas. And then one begins grinding it down. And one goes on and on grinding until—aha, this is all just such and such! And one’s ended up with something incredibly simple and obvious. And one might think one was just dumb for not having seen this right from the start.  Or at least one might think that, if one hadn’t seen what other people had produced and one hadn’t been through this process thousands of times.

I guess every function in Mathematica is in a sense like a disembodied idea. It’s the result of one of these processes of taking lots of pieces of functionality and gradually grinding them down to see the simplest, most general thing that can represent them.

Well, in 1986 and 1987 I spent lots of time designing how Mathematica should work, and I was also madly writing code to implement the core pieces of the kernel and supervising other people writing all sorts of other crucial pieces that were needed. I decided that the best way for me to really define the system was to write a book that documented it—not least because if you want to describe something honestly in a book, you’re forced to really think it out and to get something that’s decently clean and simple.

Well, by the spring of 1988—even a little quicker than I’d expected—we’d pretty much got the first version of Mathematica finished, and I was starting to spend a lot of my time trying to build the structures needed to actually have Mathematica flourish in the practical world.

Between finishing SMP and starting Mathematica, I had had a hobby of doing management and strategy consulting, and so I had seen a fair number of ways to do things wrong. But I was completely convinced—and still am—that in the world as it is today, by far the best way to turn raw intellectual ideas into practical realities is through entrepreneurial companies.

So to make Mathematica a reality I set up our company—and this time I resolved to set it up as I thought a company should be set up and to run the thing myself.

So, by June of 1988 we were ready to officially release Mathematica to the world. So on June 23, 1988, we had a press conference in Santa Clara, California, and told the world about Mathematica. 

It worked out well. It was one of those moments where the world was actually paying attention, and people understood the description we gave that Mathematica was "a system for doing mathematics by computer." And the next day there were stories about it in most of the major newspapers, and everything was off and running.

Well, that was 10 years ago now. So what’s happened since then?

Well, I remember predicting 10 years ago how things would develop with Mathematica. And what I basically said was that I thought there’d be steady growth in the number of people who’d be able to run Mathematica on their computers, and there’d be a steady growth in the number of things people would want to use Mathematica for.

Well, that’s pretty much what’s happened. We passed a million users some time ago, and the diversity of places where Mathematica is used has been steadily increasing.

I suppose it’s kind of dull to say that things have developed in the kind of steady way that one thought they would. But that’s what’s happened. And I guess when one builds tools like Mathematica, what one really hopes for—and what the people who use those tools should really hope for—is that everything will develop in a smooth and steady way.

And the point is that we didn’t make any big mistakes. There are no big things in Mathematica Version 1 that I regret. And we’ve never had to go backwards. We’ve always been able to just build more things on top of the foundations we’ve already laid.

Computers have gotten faster, gotten more memory, and gotten more elaborate user interfaces. But because we didn’t make any compromises when we first built Mathematica, Mathematica has just grown right into all these things.

And I suppose the only real surprise—if there has been one—is just how strong the underlying ideas of Mathematica, and the language inside Mathematica, have turned out to be. When we added typesetting in Version 3, for example, it might have been that we would have had to develop a whole new programming paradigm for it. But we didn’t. We were able to just take the symbolic programming constructs that already existed in Mathematica and immediately apply them to a completely new area.

And I’ve seen that over and over again—both in terms of things that we’ve done within our company, built into Mathematica or otherwise, and in terms of things that other people have done in using Mathematica for all their various applications.

I suppose if there’s one thing that’s been a little disappointing, it’s this: not nearly as many people as I might have hoped have I think really yet understood the big ideas of Mathematica. Now, of course, many of you here are wonderful exceptions to that. But in the world at large I think people often just look at Mathematica as a big collection of specific tools for doing technical and mathematical calculations.

Now, of course, I suppose that’s partly our fault; after all, we did start off by explaining that Mathematica is "a system for doing mathematics by computer." And I think that was a necessary simplification at the beginning. But in reality, as many of you here are well aware, Mathematica is much more than that—both in practice and conceptually.

In a sense it was very good that I picked 1986 as the time to start building Mathematica because that was really the first time in history that one could imagine building a computer language that could be used by a lot of people, but which wasn’t constrained in all sorts of ways by the computer hardware that happened to exist. You see, when most of the standard computer languages were designed—Fortran, C, and so on—computer time was really expensive. So the crucial thing was that the language make things as easy as possible for the computer without worrying too much about the person using the computer. And the result was that those languages worked hard to stay close to the detailed operation of the hardware of the computer.

But when I designed Mathematica, what I wanted to do was to make a language that was much higher level and that did things the way people think about them, not the way it happens to be convenient to set up computer hardware to work. And from everything that’s happened with Mathematica, I think I can fairly say that that was a very good idea.

But it’s still an idea that hasn’t been at all widely absorbed. The few computer languages that have emerged since 1988—like Java—are incredibly primitive from a language capabilities point of view.

I guess some people say that languages aren’t really needed anymore, now that we have such elaborate graphical user interfaces. Well, it’s true that when one wants to do a limited set of things, menus and palettes and so on are great—and starting with Version 3 of Mathematica, one’s been able to build very nice ones in Mathematica. But if one wants to scale things up to do more general kinds of things, that approach fails miserably. Perhaps it’s something to do with the central role that language plays in general human thinking, but the fact is that language seems to be the only medium for actually representing ideas that have any serious level of generality or sophistication.

And if you’re going to be using language, you shouldn’t be using something that’s based on shifting specific pieces of data from one register in your machine to another. You should be using something that’s really representing the computational process and the way you’re thinking about it at a higher level. And that’s exactly what the symbolic programming paradigm in Mathematica is set up to do.

Well, as the years go by, it’s encouraging to see that more and more people seem to get the point. And in a sense I guess I don’t blame people for taking a while to understand. It’s hard. And, you know, every year as I go on using Mathematica, I learn a little more about just what one can do with what’s in Mathematica.

I guess it’s like big ideas in science—it just takes a while for things to get absorbed. And by a while I mean long enough that these past 10 years will seem like almost nothing.

Well, fortunately a lot of what we’ve put into Mathematica seems to be well appreciated on much shorter time scales. As most of you probably know, after Version 1 came out in 1988, Version 2 followed in 1991 and Version 3 in 1996. Version 3 was really big and included our whole new mechanism for dealing with notebook-interactive documents as symbolic expressions. I’ve seen some very, very nice things that people have done with that idea, and I’m sure I’ll see more at the conference. But it’s another one of those big ideas—structure-programmable documents—that I think is going to take a while to really get absorbed.

Well, in addition to developing Mathematica, there are two other things that we’ve put a lot of effort into: developing the community around Mathematica and developing our company.

As far as the community around Mathematica goes, it’s terrific to see so many people here who have been so successful with Mathematica over the course of so many years. There have been a lot of great personal achievements with Mathematica—hundreds of books written, thousands of papers, and by now many tens of add-on software products. And at this conference I’m sure I’ll find out about a lot more things that have been done.

As far as our company goes, one of the things I’ve worked very hard at is to build a team of people who can really carry the vision of Mathematica forward. And I think we’ve now got a terrific team, and I think we’ve got a company culture that is set up to be able to continue to allow us to achieve great things.

I guess our company culture really revolves around building products that we can be proud of. Lots of companies—probably most companies—end up having a kind of "good enough" philosophy. That’s not what I’m interested in, and that’s not what the people at our company are interested in. We’re interested in building things that are the best, that have the best ideas, and that will last way into the future.

I’ve worked hard to make our company a place where that philosophy can really work, and to do that you also have to be a successful business. As many of you know, our company—actually it’s a group of companies—is a private company. And the reason it’s that way is that it allows us to concentrate on serious long-term things rather than always having to worry about the short-term repsonse of the stock market. And I’m happy to say that we’ve been able to run our company well enough that at this point we’ve had 39 consecutive quarters of profitable operation—ever since Mathematica Version 1 first shipped.

Well, another important aspect of our company is our efforts to explain to the world what’s good about Mathematica and how it can be used. Some things there I think we’ve done very well, others perhaps not so well. I mean, you know you’ve successfully got some kinds of marketing messages out when folks, who have all sorts of products that are vaguely like pieces of Mathematica, start trying to use the exact same marketing messages to sell their products.

Well, it’s wonderful to see so many people around the world using Mathematica, but at some selfish level one of the main reasons I wanted to build Mathematica in the first place was just to have Mathematica to use myself. And I’m very happy to be able to say that, in fact, I have been able to spend a lot of time these last several years actually using Mathematica.

Up until Version 2 was out in 1991, I spent all of my time growing our company. But then in 1991 I decided to go back to doing basic science at least some of the time. Actually, kind of what happened was that I saw what had happened with the field of complexity theory that I’d tried to get started, and I saw that other people really weren’t moving it forward very well, or even understanding properly the things I’d figured out. So I figured that if I really wanted to see something good happen, I was going to have to do it myself.

I figured that with Mathematica I had a terrific tool for doing science. I figured that I was at least an order of magnitude more efficient at doing things than before, and I wasn’t a complete slouch even then. So I decided to return to the basic questions about science that I’d started off working on in the early 1980s, and I realized that what needed to happen if progress was going to be made was a fairly major change in direction.

I think sciences get defined by the methodologies they adopt, and what I realized was that to make progress there was going to need to be a whole new kind of science developed. If one looks at science—or at least the hard sciences—for the past three hundred or so years, one of the common themes is the idea that mathematical equations are what we should use to describe the universe. Now that worked very well for Newton and friends three hundred years ago in figuring out the orbits of planets and so on. But it’s really not worked when it comes to more complicated problems in physics, or almost anything in biology and places like that.

So the question is: how can we do anything definite if we’re not using mathematics? Well, actually it’s kind of strange that we take mathematics so seriously. I mean it’s presumably true that the universe operates according to definite rules, but why should those rules be the kind of rules that we happen to have invented in human mathematics—derivatives, integrals, continuous functions, and all that?

Why shouldn’t nature use other kinds of rules? Well, in the past I suppose one wouldn’t have known what other kinds of rules there could be. But now there are computer programs, and computer programs can in effect be thought of as defining rules. But what do typical computer programs do? I mean, the programs we usually use are set up to perform particular tasks. But what would happen if we just picked very simple programs at random? What would they do?

Well, in studying cellular automata I’d already looked at one example of that. And I’d seen some remarkable things. And as I came back to studying these things, I realized that what I’d seen was actually even much more remarkable, and even more of a shock to the intuition, than I’d even ever imagined.

So I started looking quite generally at what simple programs do. I had a great time. It was kind of like doing all the obvious experiments in the computational world—kind of like it must have been for Galileo and friends doing all the obvious experiments in the physical world three hundred years ago.

And I discovered some really, really interesting things looking back. Some of them could have been discovered a long time ago—a really long time ago, like by the Babylonians—but they weren’t. Instead, it took having Mathematica to be able to explore everything to know exactly what one should be exploring.

Well, that was what I was doing from about 1991 to 1994. Then at the end of 1994 I decided I’d better stop just being a Mathematica user and make sure a new version of Mathematica got built. So then I started spending a lot of my time pushing to get Mathematica Version 3 finished. 

And as that was being done, I started trying to apply some of the things I’d figured out in my new kind of science to try and solve a bunch of basic problems in existing sciences. And it’s been just fantastically exciting! It’s really great how looking at things from a different point of view lets one make incredible progress.

And I just love using Mathematica. I think I’ve gotten pretty good at it. And now I can’t imagine how I—or anyone else—can ever make any serious progress in figuring things out without using it. I mean the rate at which one can do things is just incredibly different than it ever was before. I think at peak performance I’ve been producing about the same amount of material as would be in a good scientific paper at the rate of one paper every working day.

I’ve managed to figure out a lot of fundamental things in physics, in biology, in mathematics, and elsewhere. And I’ve even managed to make a lot of progress with something that takes me back to my original interests in particle physics—I’ve managed to make some rather surprising progress towards finding a truly fundamental theory for all of physics.

Well, it’s kind of a weird business I’ve been in. I’ve been trying to build a new kind of science, and it’s been going so well that I’ve just kept going—for seven years now—discovering new stuff. People keep on asking me about what I’ve discovered. But I’ve decided not to make the same mistakes I’ve made before. I’ve decided one needs to treat this kind of thing like a product release. One has to get everything all figured out, all tested, and then one has to explain everything clearly all together.

I know perfectly well that it will take a while—certainly decades—before people really understand the stuff I’ve figured out. It certainly took me more than a decade to understand a lot of it. But I want to try to give people the best chance to understand things by explaining it all in the most complete and forceful way. Part of it is a book I’ll be publishing. But I’m also going to try some ambitious experiments in education and in creating intellectual structures in the world at large and on the web. And hopefully I’ll finally be ready to do all that by early next year.

Well, I don’t want to start our conference off by throwing the schedule off. As I said at the beginning, here today there are going to be a sequence of talks from the leaders of various development efforts at our company about some of the new technology we’ve been developing. And at 5 p.m. today, I’ll be doing a Q&A where I’ll try to answer whatever questions I can.

But for right now, I’d just like to thank you all, and all the users of Mathematica around the world, for being such a great inspiration. You know, when I get out and about, which is very rare these days, people often ask me why—after I’ve done so well in my various business enterprises—why do I still work so hard? And actually these past seven years I’ve been working harder than I’ve ever worked before—I think I’m now averaging about 1.5 million keystrokes per month. Well, part of the answer is that I just really like what I do. But another part is that it means a lot that there are a large number of people in the world who understand and appreciate what I do. And that’s what helps someone like me to always want to go and do more, to build more ideas and more tools—and more science and more technology.

Thank you all very much.