Celebrating 35 Years of Mathematica

Well, hello everyone.

Welcome to a celebration of sorts, both a look back and a look forward. Today is the 35th anniversary of the original launch of Mathematica. So Mathematica launched June 23, 1988, and that's 35 years ago today.

And I wanted to talk a little bit about where we started the journey.

We'Ve been on and what it looks like from here.

So what happened on June 23, 1988?

We had a press conference. Those things existed in those days in.

Santa Clara, California, kind of showing off for the first time in public Mathematica and on a variety of different machines and with a variety of different industry.

Folk, including Steve Jobs, who was then.

Building up next, and folks from Sun.

Microsystems, Bill Joy and Andy Bechtelsheim, and.

Folks from IBM and Silicon Graphics and several other companies.

And we kind of got this all launched. I can show you perhaps, let me show you.

The.

We have a, a scrapbook that we actually made the 25th anniversary of Mathematica originally. But show you a little bit of that. This was.

We had an invitation that we sent.

Out that started off how fast can.

You work this out?

And it's an integral. And then in the time it took.

You to turn this page, Mathematica would have given you the answer. So, okay, that was what Mathematica, as its name suggests, was first targeted towards doing mathematical computation.

It's, as I'll talk about later, kind.

Of the bigger conception that I started in the late 1970s is this kind of make everything in the world computational. And that's what's led us to now.

Have Wolfram language as kind of our full scale computational language, the outgrowth of Mathematica. But I think it's perhaps interesting in.

Looking back at version 1 of Mathematica to see if we can actually run.

Version one of Mathematica. Not a trivial feat because the computers.

That existed at the time aren't really in wide circulation today. But we have a sample here.

And let me show you, let me show you what we have. So we have, we actually recently discovered a Mathematica version 1.1 box that have.

Been in storage for a long time. This is a, the version 1.0 box.

Was a larger gray box. This is the, this is 1.1. This is. So let's, let's actually see, just for.

Fun, let's see what was in the box.

And this box had been sitting unopened for a very long time. So, okay, well, there's one of those license agreement things.

Okay, then there's Mathematica for the Macintosh setting up.

And let's see what, what, what it tells us to do here. It probably tells us to do things like, okay, it's what you need Mathematica configurations. Okay, it's got all kinds of stuff about how to drag icons from one place to another. And okay, it's got a special section here.

I'm working with limited memory.

We'll probably come to that in a minute. Then there's a summary for Macintosh experts.

I should explain that version one of.

Mathematica ran on a Sun workstation computer.

It ran on several other kinds of workstations.

It in fact ran on the next computer.

But the next computer hadn't been released at the time. When Mathematica version 1 came out in.

June of 1988, came out later in 1988 and the Mac was the only kind of really personal computer on which Mathematica ran.

It didn't run on PCs because at the time, IBM quotes IBM PCs were.

Limited to 640k of memory and we.

Just couldn't fit in that size. Later on, by early 1989, I think we had managed to cobble together with various kinds of memory extension technologies a way to run at least something on, on a PC.

But when, when Mathematica first came out, the Mac was the only desktop, the only, the only personal computer on which it ran. Okay, this is the user manual.

So this was, this is the days.

When one documented user interfaces.

We learned many years later. We did kind of a focus group once with some of our experienced users having them open a much later Mathematica box only to discover that even people who've been using the product for a long time had no idea that there even was a lovely piece of documentation.

That described the user interface.

I think the main lesson of that.

Is that a good user interface should need no description. All right, let's take a look. There is the release notes from then.

We get to a user registration card.

And an information request card and look at that T shirt order form. Let's see, T shirts at the time cost $8 each and had available variety of styles. We probably should bring those back as a retro kind of thing. But on the user registration card there were questions here. What were the questions about? Well, there was a. There was no email address looks like, or maybe no, no email address to be listed here. Phone numbers and make some models of computers.

And then there was questions down here about. On the information request card asking about the availability of Mathematica on.

This is a good list of computers.

An Alliant computer.

People heard of those. Maybe Apple Macintosh, Apollo, Ardent, Atari, att, Unix, PC, a Commodore, a Convex, a Cray, a Dec, Vax, under Unix or vms, an ETA computer. I'm afraid the ETA computer I don't think ever actually arrived, despite its name. Hewlett Packard, various IBM, a Mako computer, Multi Flow, next, Sequential, Silicon Graphics, Sony, Stellar and Sun.

Let's see what else is in the.

Card in the box here. And we have a Mathematica online Services on the portal system. So remember, the web did not exist yet. In fact, as a sort of footnote to history, the web was originally created on a network of NEXT computers at.

CERN that had originally been bought for.

The purpose of running Mathematica on those NEXT computers. So when Mathematica first came out, the web didn't exist. This was an online dial up system that allowed for. That we set up to allow for distribution of various kinds of Mathematica packages and so on. The modern Packlet repository and so on is a modern version of that.

Okay, here we go. This is the real goods.

Here are the floppy disks. That's the distribution media. And that there is an actual floppy disk that the software came on complete with a registration number glued on it.

This is for those who are slightly on the younger side.

This is not a 3D printout of the save icon. This is a piece of. Look, you can, when it goes into the computer, it moves that little window and exposes the magnetic disk inside there. All right, well, so that's what's in the box. The other big thing that actually came out the same day that Mathematica became available as software is the original Mathematica book. This was a conveniently short book that.

Has kind of defined the standard for, well, certainly our descriptions of what's now Wolfram language. It's kind of interesting that now the reference documentation, which is hundreds of thousands of pages long, it started its life.

As the appendix to the physical Mathematica book.

This book was happily very successful in bookstores. It was very convenient that people could in those days. You know, in today's world you go to a website and check things out. In those days you go to a bookstore and check out what Mathematica could.

Do by looking through the book.

And it was also something that I learned from this was this book was short enough that many people really did.

Have a chance to just go through.

And sit down and read the book. And it was kind of both a description of how to use Mathematica and implicitly kind of A story of how to think about doing mathematical and technical computations by computer. Kind of a way of. Of describing that.

That new way of doing things.

I think that the big transition that.

Really happened as a result of the release of Mathematica was that people who.

Had been in the kind of mode of, well, I can do a calculation and if I have to use a computer, I've got to go ask a programmer to program it and so on. With Mathematica, it for the first time became possible for actual sort of frontline theoretical scientists and so on to do their own computations. And that opened up sort of a lot of capabilities for many, many people. I myself have, have taken great advantage of those capabilities to do all sorts of science.

All right, well, anyway, let's see. We have here a Mac SE30 computer. And let's see, we could. Let's. It supposedly has. Has Mathematica loaded onto it. So let's see, we can probably switch to looking close up at the screen. Screen.

And. Okay.

Let'S go and launch Mathematica here. Oh, okay, let's see.

I think we couldn't.

The icons were pretty low resolution, so we just had an octahedron there as the icon. But let's see whether we can launch it. Okay, here goes. Okay, there's the startup screen. And that indicator there is a very scary indicator because that's the memory indicator and that shows the amount of memory that's being used.

And I guess this machine has two.

And a half megabytes of memory because those big tick marks are a megabyte. So this has two and a half megabytes of memory.

And right now we're just running the front end. We can start to see some things.

In the front end. Gosh, I have to remember that you have to hold down the mouse to see things. Well, so, so we've got about Mathematica and we've got a very elaborate startup screen with all kinds of technology with.

A celebratory cellular automaton here.

You can reseed the cellular automaton and you can even change the rules. Let's see, I have to try Rule 30 here. There we go. Did I get that right? Is that Rule 30? I hope that's right. I should know this by now. Wait a minute. No, that's not right. And it's that. Seed it again. Okay, maybe, maybe not. In any case, this was. That was the. That was. I wonder what the help does. Maybe that's too. Maybe I shouldn't press that. It's tempting fate to do that. All right, let's try. Let's see what happens. Let's see. Is there a way to magnify this window? Maybe, maybe not. Okay, let's try. Let's just try the quintessential starting the system kind of thing. Ok, so now you see the kernel is starting.

We started the front end.

The kernel is starting.

It's using more and more and more memory.

It's doing lots of work loading things in. And if we're lucky, if we're lucky, if we're lucky, it'll eventually successfully say two plus two is four. Okay, good stuff. Now, the test query, test calculation that I always used to do was 1989 to the 1989. And the question is, how long does that take? So let's just see how long that takes here. It's of course instantaneous today, but in those days it was not. And it's probably going to use a bunch more memory. Wow, this is so slow. This is terrible. I think. Come on, you can do it, computer. Wow, this is really slow. That's amazing. Today it's less than the blink of an eye to do this computation. I think this computer. Well, let's see whether it works. Ah, there we go. Amazing. Okay, let's see. And I have to remember that you.

Have to hold down that there isn't.

Continuous scrolling on a Mac of that time. There's no continuous scrolling. So we just have to scroll back here to look at this. But okay, we successfully did the computation. Let's see, we can say, oh, gosh, I'm trying to run the scroll wheel, but there isn't any scroll wheel here. Ok, so let's say N of that. And I hope. Come on, this is really painfully slow. There we go. OK, so it had 6,600 digits. All right, let's try something else. Let's try a plot. Let's see. Say plot sin X. We're using the exact same syntax that we would use today. And let's see what happens here. Okay, very good. It produced the plot. I think we can even resize the plot on the screen here. Oh, you saw that little weird weight cursor that came up. Definitely not used to this. Okay, let's try a 3D plot. Let's try something like, I don't know, a bessel function. It was a thing that we used. It was on one of the T shirts. So let's say Bessel function j0 of a square root of x squared plus y squared x runs from minus 10 to 10, y runs from minus 10 to 10. I'm really living dangerously here because I don't know if this is going to going to fit in this little computer here.

But what's interesting is that same exact.

Syntax is what you would use today. All these things have remained compatible all these years. Let's see.

And notice that the thickening of the cell brackets, this whole concept of notebooks was something we invented for version 1.

Of Mathematica, together with all of these mechanisms for cell brackets and so on. And the fact that even that the.

Kernel is running separately from the, from.

The front end is notable. And we can double click here and we'll close up that cell just like it works today. Up here we come. There's our 3D graphic. And actually, I want to open that cell again here.

Notice by the way, that little icon.

There that goes next to the cell.

That was something that we don't have anymore. That was a thing that kind of.

Indicated in an iconic form, kind of the number of cells underneath the closed cell. Okay, well, here's our 3D graphic. Let's see. We can probably resize it just about. Let's see what happens if we try and rotate it. Is there a way to rotate it? There was some kind of way to rotate it. It certainly wouldn't rotate in real time, but I think there was a way to. Maybe not in version this is in this version 1.1. I don't think there was a way to rotate it, perhaps. All right, so it's fun to see all this stuff. We can take a look at all.

Our friendly functions like Nest List or.

Something of FX10 that will all be there.

All of these things that have become important parts of Wolfram language as it is today. Well, of the about 7,000 functions that.

Are present in Wolfram language today, I think there were, what was it, a little less than a thousand, I think, in the first version.

But all the ones that were there.

Then are still there in some form today. And let's see how compatible things are. So let's go ahead and save this notebook. Let's see, save it on the desktop. Let's save it as 35th anniversary and press save. Okay, we successfully saved it. All right, let's, Let's see, let's look at the wider chart here. Okay, so now the question is, can.

We take this notebook and get it.

Onto a modern computer? Well, of course there isn't networking on this machine that would let us do that. So the way we have to do it is use a floppy disk and, oh, look, I noticed that we have a floppy drive here. And I notice in some there is a poor dead bug that.

Showed up.

On top of that floppy drive. Maybe that's a sign of something. All right, let's dispose of that guy. All right, let's put this floppy disk in the floppy drive, and then the Mac will grind around. Oh, look, the floppy drive is making all kinds of funny noises. Grunt, grunt, grunt, grunt, grunt. And let's see, how do I do this? I have to remember how to do this. I think I go. Do I go here? I have to get to the finder. How did one get to the finder? Oh, yeah, it's behind there.

You know, when I first saw this.

Kind of graphical user interface mechanism with Windows and things on top of each other and so on, I first saw that when I visited Xerox PARC once in probably 1979. And I was like, how could this possibly work? People are always going to get.

It's going to be as confusing as.

Having pieces of paper and so on. And kind of remember that. Okay, let's see. This is that floppy drive. So what I think I want to do is go from the desktop with the 35th anniversary thing here, drag it onto the floppy drive, and hopefully it will copy that floppy. And then let's see what we can do with it. Okay, so it's copying the floppy disk. And now I think it copied it. All right. How do you eject a floppy disk? Well, you drag it to the trash. I think you can still. Okay. All right, now we have a floppy disk. Now the challenge is how do we read that onto a modern computer? Well, I have a modern computer here, and I also have. I hope. Let's see. Let's move this out of the way slightly. And if we're lucky, I have a modern floppy drive reader. Floppy reader. So I think we can just plug the. Into this machine and it starts making all kinds of blinding noises. And that is a very loud floppy drive. Okay, let's try putting the floppy disk into the floppy drive. And what am I doing wrong here? Well, that would be a problem. I had another floppy disk in the floppy drive. It doesn't work with two. So let's put it in grind, grind, grind. And. Let's open a modern Wolfram desktop. So it is ready to receive the time. The thing from the time machine. Okay, there's an untitled. Okay, let's go ahead and switch to this screen and let's double click this. That's reading off the floppy drive. What's all that junk? What is that that's stuff that used to be on this. That does not have. Where is the thing I just put onto that disk? Oh no. What happened? Well, humph. A live demo. Well, this is no fun. Okay, let's switch back to. The Mac here and let's go ahead and. Did I manage to switch around these? No, no I didn't. Let's do this again. So let's take a look at. Just put this in again and hopefully that will show up as an icon here. And what am I doing wrong? Okay, we've got that there. And now we want to take. This file from the 35th anniversary.

You know what I'm going to do?

I'm going to open this up here just to see what's on it. That is very odd. That must be a floppy disk from like a Mac from like millions of years ago. How strange. Well, let's use. Okay, let's use this other floppy disk here. I have a feeling that must be a disk that came from a computer that my parents had a very, very, very long time ago. That must have been shipped through many, many different places. All right, let's try this floppy. Would have probably been a good idea to use a new floppy, if such things even exist. All right, let's take a look here. Why is there a Polyhedra dot M that just showed up there? All right, let's take a look here. Oh, there it says 35th anniversary. It has a thing. You know what, I'm going to think that maybe there's something wrong. Okay, let's see if it can load it up here. Okay, well, it loads it back on here.

You know what?

I'm going to suspect that I was living too dangerously by giving it a name that began with a number. Let us try and rename it. Does this work? I thought renaming worked. Okay, well, let's try saving this again and save as. Let's try just the word anniversary. Okay, saving, saving, saving. All right, Now why doesn't it show up there? It. All right, let's try this again. Oh, I see. The anniversary just shows up there. And why, why is there a name for that floppy disk? That is very, very odd. I think that's a.

That must be a floppy disk with a long and strange history.

Okay, let's take that. Put it in the trash rejects. Now let's try putting it in here. And it goes grind, grind, grind. And. Let me see if this opens up. Still grinding, still grinding. Hopefully it will have opened up as untitled here. Oh, I see what happened here. The file name is Too long. And so it broke it up with a dot S AR how very, very odd. For some reason, this thing won't deal with. Let's call it Annie ma, which was the file extension for a Mathematica file back in the day. All right, let's try taking that file and dragging it from the floppy drive. Let's. Just a second here. Let's go and switch back to this machine. Let's try dragging this. Oh, come now. Drag it to a modern orphan desktop. Let's see what happens. All right, moment of truth. Are we actually going to. Oh, look at this, look at this, look at this, look at this.

Exciting.

Okay, let's make this bigger. We can do that on the modern. Look at that.

A notebook from.

Basically 1988 we just created. And there's our 1989 to the power 1989.

There's our plot.

Not perhaps. And there. Oh, look at that. There's our 3D plot. Not as beautifully presented as it would be today.

Let's try rerunning.

Let's take that piece of code.

Notice that we still have the cel.

Brackets and cells and so on.

It's. It's not sharing. We aren't seeing.

Oh, your screen, it's black. Oh, my gosh. That was no fun. The exciting part. We all missed the. Okay, let's see. We have to try this again because this was really. This was really good. Okay, so we finally have this. File from the floppy drive.

This is the.

On the floppy drive. Let's select that file. And if I can only get it selected, my fingers are not. If I select that. Come on. And move it. Well, maybe if I just double click it. We're lucky. No, that's not what I want. No, no, no, no, no. Okay, let's see. I just have to drag it to. How can this be so difficult? This should be very simple. This is like, for some reason, because it's on that drive, it isn't liking my attempts to just drag it here. Well, here, let me do this. That is a confusing collection. I think I'm going to try that one there. Okay, now. Oh, what is it doing there? Asking me to save that. Okay, hold on, hold on. We're going to solve this problem. I just solved it before when you couldn't see. Let me see. Come on. Should be possible to select this.

This is a modern. This is a modern issue.

Not. Not the ancient issue. All right, let's see. That should work. Okay, let's drag it onto this and let's see what happens. What's Going on here, I just did this and. Asking me to save it as another file. It didn't do that before. Well, okay.

Up.

Well, okay, success. At least there we successfully opened our notebook from 1988. Let me make it bigger again. All right. You can see the calculation that we did back on that. Mac can see all these things.

It's not in as nice colors as we have today.

Well, the Max screen wasn't a color screen back in those days. There we have this plot. Maybe we can just go ahead and copy that cell down here and now redo that plot and there we get the results. It's a bit, came up a bit.

Faster and it's now, now rotatable in real time.

But what I find very nice is.

That we have continuity from back 35 years ago. One could type a piece of code then and still have it run, run today. And for myself, I have programs that I wrote back in 1990 and so on and they run without change today.

And that's to me a, a significant.

And very nice thing. And I don't think there are too.

Many other software systems that can, can.

Boast the fact that they have maintained.

Compatibility over all that period of time. All right, well.

So that was, that was a little bit of, of a historical look back. Let's talk now about a little bit of a look forward. I think a thing to say is the reason that Mathematica Wolfram language today is still compatible with 35 years ago is because the things that we're doing are kind of timeless in a sense. My original goal in building Mathematica Wolfram language was to figure out sort of what are the essential primitives for computation in a form that we humans can readily use them, what are those essential primitives. And then implement those things without thinking about kind of the computers of the day and the specific details of what those computers did. What is the kind of theoretically correct thing to do to kind of capture the ideas of computation to. In a form that people can use. And that was kind of my goal back at that time. And the fact is that is a timeless goal. And that's why today we can still take code from that time and run it. I should say that sort of the backstory of this is I started building the precursors of Mathematica back in November of 1979. I embarked on building a system called SMP Symbolic Manipulation Program, which was in many ways a forerunner and a test run of Mathematica smp. Kind of to design smp kind of. I tried to do something that was sort of analogous to what I thought I was doing in natural science, which is, in natural science, you go from the natural world and you kind of drill down and find out what the essential elements of that world are, what the primitives are, and then try and understand how natural science is built up from those. For me, what I was trying to do was to go from kind of the computations people might want to do and figure out what the sort of essential primitives of those are to be able to implement in a computer system and to understand what those primitives were. I kind of went back to the foundations of computation and to things people had done in the 1920s, 1930s, and so on, looking at kind of how can one represent computation. It took me to things like combinators and, well, all the other kinds of foundational models of computation, lambda calculus and so on, as a way to sort of understand what was the essence of this thing we think of as computation. I actually kind of ended up a little bit generalizing those things and repackaging them into this idea of symbolic expressions and the idea of sort of representing anything as a symbolic expression that has a head together with a collection of arguments. In smp, we called those projections, and we talked about projectors and filters and so on. Now we would call that head and arguments of a symbolic expression. But the idea of symbolic expressions was something that I kind of started. Started with an SMP and started with the kind of represent everything in terms of symbolic expressions, then with the kind of key operation being do transformations on symbolic expressions, that all of the operations that one wants to do are represented as transformations of symbolic expressions. That was kind of the core idea of smp. And then to implement, to figure out, well, what were the functions that were the kind of repeated work, lumps of computational work that people will want to use. Let's implement those as the primitives of the language and use that as the foundation. Now, I have to say, in S and P, that was building that in 1979, there were many different sort of ergonomic considerations. For example, typical people didn't know how to type with 10 fingers and so on. And so having short command names was a big, kind of a big thing one wanted to do because one didn't want people to have to type these long names. And autocomplete was many years in the future. And so one of the things that was a mistake in SMP was that the names of functions and commands and so on were all very short. So many of the things that we have Today in mathematical morphine language already existed in smp, but their names were very short. And that had the consequence that the code you wrote was pretty hard to read after you'd written it. It was kind of a little bit like in something like mathematical notation, one kind of has a limited number of symbols that one learns gradually over the course of learning mathematics. And that's okay. One can learn what a plus sign and a greater than sign and so on mean. But if you're, if you're given this whole pile of hundreds or more of these things which have short names and maybe, maybe different notational forms, that's something that people find very difficult to deal with. When I built Mathematica and Wolfram Language, one of the key things was not to do that, to just leverage the English language and to use kind of as names of functions, kind of ordinary English words or combinations of English words, and to have that be the, the thing that you. So that, that, that's kind of, it allows you to take your knowledge of things in English and generalize that to, to be able to understand what the computational language means. Now, one thing that's really kind of cute in today's world, when we ask an LLM to write Wolfram language code, it actually does a reasonable job. GPT4 and things like that do a reasonable job of writing Wolfram language code. But they know the names of the functions that we have so carefully chosen over the course of the last 35 years. And sometimes they guess what functions might exist, and sometimes they don't know the name of a function that perhaps is newer than their training set, and they end up guessing the name of a function and they usually guess correctly, which I think is a tribute both to the LLM and to the consistency with which we've been able to name all these functions. So kind of the functions should be obvious to humans. And it turns out we've kind of got a test of how obvious they are, because they also seem to be obvious to the LLMs. But in any case, so kind of the big idea of SMP and then Mathematica and Wolfram Language is this idea of symbolic expressions and transformations on symbolic expressions, pattern matching as a way to transform symbolic expressions and using that kind of pattern matching concept as sort of a core operation that goes across all the different domains that the system might deal with. And one of the things that happens with symbolic expressions, one of the things we've discovered over the years is, is that, yes, symbolic expressions are extremely general kinds of things that can be used to represent sort of everything. And gradually we realize that they can represent more and more. Back when I was designing SMP and back in the early days of Mathematica, one of the use cases that I really wanted to hit was mathematical computation, symbolic mathematical computation, algebraic expressions, kind of structures in mathematics and so on. And that was a kind of a high bar because that's a complicated kind of structure that one's dealing with. And symbolic expressions, yes, check mark work well for dealing with those kinds of mathematical constructs. So then over time, we kind of started using symbolic expressions to represent other things very early, at the very beginning, also representing programs as symbolic expressions. The concept of pure functions as symbolic expressions of concepts as whole chunks of code patterns and so on, all as symbolic expressions. Then graphics as symbolic expressions, then the structure of notebooks as symbolic expressions, then processes that one was running on one's computer, and different kernels and so on as symbolic expressions. Many, many years later, things like cloud objects as symbolic expressions, all these different things being represented as symbolic expressions. Then back now, 15 years ago or so, a little bit longer ago than that, the idea of entities in the world as symbolic expressions, as pieces of symbolic expressions, the entity that represents a city or a chemical or a movie as a symbolic expression, this notion that everything is a symbolic expression is kind of the core idea of Wolfram language. And it was the core idea. It's been the core idea of Mathematica all these years. And it turns out to be a very flexible idea. And it turns out to be an idea that really is a sort of key bridge between sort of the abstract possibilities of computation and the way that we humans think about things. I think it's probably not unrelated to the fact that we humans use natural language. We use human language as a way to communicate, a way to organize our thoughts. And this kind of symbolic expression idea sort of plugs into the same underlying stuff as kind of as human language does. And I think it's something where the kind of. We're trying to take what we're doing and make it. The challenge is to have something where humans can sort of this. This bridge between computation and human thinking. How do we get sort of the raw capabilities of computation and make them accessible to humans? How do we represent the things that we humans care about in a form that can also be transmitted to computers? It's a different mission, in a sense, than programming languages have traditionally had. Programming languages traditionally have the mission of computers work in a certain way. They have variables and program counters and loops and memory to be Allocated and all this kind of thing. And we want to make something which is where we can program the computer, where we can get the computer to do what we want using its kind of primitive operations. Kind of the concept that originally started with SMP through Mathematica, now Wolfram language, has been just try to represent things we humans care about in a precise computational form. And I think the thing that I've kind of steadily realized, increasingly realized, is that it's this, this notion of thinking computationally about things. This is kind of the key paradigm of the 21st century. And it's something that we have to kind of put it into concrete form. We can just sort of imagine we're going to think computationally about things. But how do we actually talk about things computationally? Well, you know, we had first human natural language as a way to kind of express our thoughts in something beyond kind of the internal operation of our brains, so to speak. Then we had various kinds of formalizations of natural language very early, one being logic from a couple of thousand years ago, where one had sort of lifted above pure natural language, this kind of formal structure of logic, where one can have something that kind of represents the kinds of things one might talk about in an idealized form in human language, but in a more precise and formal way. And then the other big sort of formalization of ways to think about things is mathematics. And it. And it's. And sort of the thing that really launched mathematics as a successful endeavor was the invention of mathematical notation maybe 500 years ago or so now, because that allowed mathematics to go from something that you just talked about in words to something that you had a streamlined notation for, with plus signs and equal signs and things like that. And the result of that sort of streamlining was the development of algebra and calculus and so on, and eventually all the various mathematical sciences. Kind of a very important thing made possible by kind of this idea of notation for mathematics, this idea of having sort of this streamlined way to talk about mathematical concepts. So in a sense, the thing that I have sort of increasingly realized is the mission that I've been on for the last 40 something years, and that Mathematica is sort of the key element in making real is how does one make a notation for computation? How does one take kind of the idea of computation and make kind of a formalized notation that connects with the way we humans think about things? And as far as I'm concerned, that's the mission of Wolfram language is to provide that full scale computational language to represent the things we Think about in computational form, to be able to take kind of something we might think vaguely about and say, well, let me think about that really in computational form. What do we do to think about something in computational form? We have to say, what's the symbolic expression that might represent this thing we're talking about? What are the functions that we might apply to that symbolic expression? What are the transformations on that symbolic expression which do something that we're thinking about? How do we take this kind of thing that's kind of swirling around in our minds and. And turn it into something where we're saying this symbolic expression, it's being transformed in this way? Well, we clearly have to start from something. And what we're starting from is all of the structure that's already built into Wolfram language. Kind of the idea is to build in kind of the knowledge that we as a civilization have accumulated, to build that in a form that's immediately accessible to the language. So that means building in the actual factual data. You know, what are all the cities in the world, what are the masses of all the isotopes, all these kinds of things, what are the directors of all the movies, et cetera, et cetera, et cetera, all these kinds of facts about the world. And we've spent years now curating all of that kind of factual knowledge. And then what are the kind of models that can be made about that? You know, what. What are the models for the orbits of satellites, what are the models for the pressure of deep oceans, things like this, implement all of those kinds of things in sort of algorithmic form. And then what are the kinds of operations that we commonly think about? Whether that's something that we might do in visualizing something, whether that's something we might do in optimizing something, and so on. These are things that we as a civilization have kind of threw lots of effort in the last few hundred years, learned how to do. Now we want to make those primitives in Wolm language so that one can immediately access any of those things, and so one can think leveraging what's already been sort of figured out in our civilization. In a sense, in human language, we are doing something a little bit like that. We're taking kind of when we invent a word for things, we build up all this knowledge around that word that when a thing kind of condenses into having an actual word defined for it, that's a place where we can really get going and thinking about things in natural language. But now we have computational language where we're sort of condensing into the functions, the primitives of the computational language to allow us to kind of build things from there. And I think this is a. I mean, it's a tremendously powerful kind of paradigm, and it's something where we can expect that just as kind of the invention of mathematical notation 500 years ago kind of was the thing that allowed the mathematical sciences to get launched. I see kind of the creation of computational language as the thing which allows one to sort of launch computational X for all fields X. And we've started to see that over the years, and it's been great to see over the course of years, a great many people kind of do very important work and build careers on the basis of using Mathematica or Wolfram language to kind of think computationally about things and think in new ways, be able to build further in all of these different fields. As I say, I think the way to think about it is kind of computational thinking is a new form of formalization after logic and mathematics. Computational thinking, and it's one that is extremely flexible, is really very much more general than the others. But it also has another important kind of footnote, which is it's immediately something through orphan language that one can actually implement on a computer and expect to have the computer help one do things. Obviously, with mathematica, back in 1988, we were taking the existing. That the thing that we were most emphasizing from the name of the product was we're taking the existing kind of paradigm of mathematical science and making that computational, so to speak. Originally, the tagline for Mathematica was a system for doing mathematics by computer. In many ways, that undersold kind of the mission and the promise of what we were trying to do. But it was kind of talking about the use case that was clearly the strongest use case. And by the way, one of the things that it's very hard to predict these kinds of things. One of the things is that it wasn't obvious what the evolution of mathematics as a term of activity would really be. Would mathematics come to encompass all of these kinds of computational ideas? Or would mathematics stay as a thing that talked about the kinds of concepts that mathematics had been talking about? As it turned out, mathematics pretty much stayed talking about the concepts it had been talking about, leaving sort of this open area of making everything computational, formalizing things in computational terms. And one of the things that is critically important about Wolfram language is that it is a language that's intended not only to be written by people and fed to computers, but also to be read by people. And it's something where it's a language that one can think about things in. And I certainly do that and have done that for many years. It's a language where one is kind of, one is trying to take one's thoughts, put them in computational form, crystallize them in Wolfram language, and then be able to have one's computer help one work out the consequences of those thoughts and build a potentially tall tower of sort of practical functionality that can be deployed in the world and so on in all sorts of. And certainly mathematical and Wolf and language run in endless kind of enterprise, large scale kind of settings in the world. Well, the thing that in. So one of the things that's happened in very recent times is not only can Wolfram language be written by humans, it can also be written by LLMs. And one now has the workflow through our chat notebook mechanism, which maybe I'll show here.

Perhaps.

Through our chat notebook mechanism, it's possible to. You can, you can be chatting with an LLM and telling it kind of in vague natural language. Hey, I want to write a program that does this. It'll then synthesize a piece of Wolfram language code. It'll do a pretty good job usually. But what it'll do is it'll take this sort of vague natural language that you entered and produce a precise piece of computational language. That's what it thinks you meant. And then you can look at that computational language and say, yes, that's what I meant. That's great. That's a kind of solid brick that I can use to build other things on. Or no, that's not quite right. And you can tell the LLM, go fix this thing, or you can just edit it yourself and then you can then do computations from there. And the LLM itself is really, you know, its mission is to take kind of the things that it learned from reading the web and other sources and sort of grinding those up and making the sort of extrapolation to understand and create natural language and sort of do common sense kinds of things to do the kinds of things that we humans can kind of do off the top of our head. The mission of our computational language is to do the things that computers can do that we can't readily do sort of off the top of our head. The things that require new computation, the things that are not sort of based on kind of just putting together the pieces that one gets from things that one can see on the web, so to speak. They're things that it's something where you have the sort of full depth of computation. And I think this sort of workflow where you're kind of describing vaguely what you want, it's turned into precise computational language. Then you use that, you look at the computational language often. It will help you in understanding. You realize, oh, well, if I'd said this more precisely and said all these different words, maybe the LLM would have written the right computational language. Actually kind of missed the point and it wrote the wrong piece of computational language. But now with that computational language, I understand what it. I have a precise representation of things. I mean, the thing that's great about computational language, in addition to the fact that it can be run by a computer, is that it also, it's completely defined. It's something where you can go look at the documentation, you can go run it, you can see what it means. It's not something where you abstractly say, oh, the computer understood what I was talking about. There's an operational meaning to that, which is the computer can take what I was talking about and actually run it. By the way, I should say that sort of the first sort of large scale, successful example of this kind of thing was wolf Malpha from 2009, where we're taking kind of natural language input, we're taking the kinds of things people type or enter in intelligent assistance or whatever, and we're taking that natural language input and converting it to Wolfram language, computational language, and then doing computations and showing a bunch of results. You can't feed WolframAlpha a giant essay in the kind of way that you can feed an LLM a giant essay. It's intended to take sort of small fragments of natural language, but it's then intended to be very kind of precise in terms of if it says, I can translate this into computational language, I know what it means. I, I have the computational language, which I can then execute that. If it does that, it will get it right. And it might say, well, I don't know what you mean, but if it succeeds in translating it to computational language, it has a precise meaning which it can then compute from. So in any case, this kind of idea of computational language as this medium for thinking about things computationally, I think is sort of the critical idea of the 21st century, actually. And it's the thing that has sort of launched the computational X fields. It's a thing that we've tried to make sort of a key contribution to by providing this notation, by providing this computational language to have a sort of concrete form of being able to think computationally about things. And I think one of the things that is actually very exciting today. Well, I should say back when Mathematica first came out in 1988, there was sort of a transition that I alluded to earlier. It hadn't been the case that typical scientists, theoretical scientists and so on, expected to use a computer themselves. There were computer experts, programmers, who were the ones who kind of were the druids who did those strange sort of incantations and so on to operate computers. And so if you were a typical scientist, you would formulate your thoughts separately. Maybe you would try and explain them to a programmer and the programmer would go off and write a program, then you wouldn't ever see that program and they would come back and show you a bunch of results and you'd say, wait a minute, that's not right. And then you iterate again for the next couple of weeks. Well, I myself happened to start using computers very early in my life at least, and kind of got the idea that, look, you can do science and do computation all sort of connected together. You can use computation as an exploratory tool for science, but to do that you have to have this kind of close coupling between thinking about the science and actually doing the computation. And that really hadn't been possible for people who were sort of scientists before June 23rd of 1988. And what happened with Mathematica, which was really quite lovely to see, was actually a surprisingly rapid kind of transformation of. It kind of started with a lot.

Of, well, sort of high end scientists.

Let'S say, who really of all ages, I might say, who kind of quickly adopted Mathematica as kind of their way of actually doing computation with their own fingers, so to speak, and being able to kind of include computation as part of the thinking loop in actually figuring things out. Well, now we're many years later, many more people know Wolfram language, many more people have learned other programming languages. There's been sort of a repeated effort to teach people coding, so to speak, at various stages in life. I think it's generally not been all that successful. I think the thing to understand is programming languages and programming and coding and so on. This is something which there is a definite very important segment of the population that, you know, care about and need to know how to do that. Just like there's a very important segment of the population that know how to deal with what's under the hood of a car, so to speak. But there's a quite separate segment of the population that is mostly interested in driving cars, not in fixing them, so to speak. And I think that the. The thing that sort of this, this, that many more people obviously use computers today then program them. But the thing that's sort of exciting about computational language is it provides this way to sort of broaden the access to the power of computation to a much broader range of people. And the thing that's really, really cool in this year, so to speak, is this new dramatic broadening of access to computation and to computational language through LLMs, through chat notebooks, and so on. Because I think what we can now expect to see is that people from sort of all backgrounds, back in 1988, we saw this transition of people with science backgrounds, quantitative science backgrounds, now being able to compute themselves, so to speak. Now I think we'll see a transition from people from all sorts of clear thinking, but nevertheless, not necessarily technical backgrounds being able to make real use of computation and computational language as a result of LLMs and modern AI technology and so on, and the kinds of connections that we're trying to make between these things. And I think that's pretty important, actually. I think that the, as I say, the fact that one can kind of get started just stating what one wants as a sort of natural language essay and then turn that into computational language from which one can let the computer go and do its thing, that's a very important thing. And I think. So there are many pieces to this whole story. But another important piece to the story is how do you. What is the modern way of presenting what you do? So, you know, people will write essays, they'll write academic papers, et cetera, et cetera, et cetera. The thing that those, usually those papers will contain, you know, some words, maybe some formulas, maybe some images, graphics. Good luck reproducing those graphics. Maybe they'll have a note at the end saying, in principle, there's data available here or there. Sometimes it's in our data repository and then one can actually read it. Other times, usually one's off in some complex jungle of trying to understand how to actually get some readable form of this data. But in any case, one of the things that I think is an important piece of the computational language story is the idea of computational essays as a way to present one's thinking and one's work in a mixture of text and perhaps formulas and graphics and computational language. And for example, in the things I've written for the last many years, if you take any graphic in something that I write and click it, you'll get the computational language code that will make that graphic. And that's been a very important thing in. In building up a bunch of projects that I've worked on and allowing other people to build on what I've done, because they just click the picture, they can modify it, they can use it themselves, and so on. But another piece to this whole story is in this computational notebook, computational essay in a notebook, one is looking at reading the text that's something humans are supposed to read, maybe the formulas they're supposed to read, the pictures they're supposed to look at. But then also the computational language as a thing that is part of the communication of the ideas. It's an integrated part of communicating the ideas. It's not just a thing you feed to the computer. It's a thing that humans can look at, humans can read. And Wolfram language is sort of the unique example of a computational language that. And a computational language that's been built to be read by humans as well as written by humans. And so that's the thing that is kind of this idea of computational essays as kind of the way to present computational the way to present things. Making use of computation, making use of computation not just in the back room to compute things, but also right up front as a way to explain. That's kind of formalism for explaining the world. And that's kind of a critical aspect, I would say, going looking at the future of kind of how sort of computational X develops. The medium of communication is computational essays, which have this feature that they're using computational language as a way to explain things. And that computational language is something you immediately can use as a building block to go further, because it's something you can just run on your computer for yourself in your own context and so on. To go further with, and the idea of notebooks that, as I mentioned, we invented back in 1987 for Mathematica version 1. It's kind of been interesting to me to think that notebooks, in a sense, were, we always thought, were kind of one of the simpler ideas that made Mathematica possible. Some of the more sophisticated ideas were things about symbolic expressions and pattern matching and transformation rules and the kind of whole design methodology and structure of the language. But it took about 25 years. And then at the beginning, people said, what are these notebook things? And people who are using them were like, excited because they could present things in that form. And I think the very first sort of journal type article as a notebook existed already by maybe late 1988, and it was. But it's something where this idea of notebooks, maybe 25 years later, I would say, kind of gained a higher degree of popularity. And people kind of took our ideas from notebooks down to many, many details.

Actually, but not all the details.

Not. There's still a lot of stuff. Even in 1988 style notebooks of ours, there's still a lot that hasn't ever been implemented elsewhere. And that's really very useful and very ergonomically convenient. But any case, so computational essays using computational language as a medium for expressing ideas. It's something where again, just as one has to learn to write good prose that is good for communicating things, so also one has to learn to write good computational language that's good for communicating things in the clearest possible way. And that's sort of a different skill from just like, let's hack together the code. It's something that needs a different kind of skill. Just like you can say, well, I can write a piece of prose in principle, or I can write a piece of prose that people really understand readily. Well, I think this so kind of the talking about kind of the whole sort of computational language idea, one of the things that has progressively happened is sort of what do you take for granted on your computer? Back in 1988, computers had gotten to the point where, yes, they had operating systems, they had some programming language capability, they even in the Mac had a graphical user interface, and later on they had networking capabilities and other kinds of things. And I think we can now expect that computational language and the knowledge of the world that comes with that is something that one can expect to sort of take for granted when one walks up to any computer. It certainly helps that by connectivity to the cloud and so on. One can, one can readily access that on any computer. I think we can also expect that the sort of LLM AI layer will also be a thing that one comes to sort of expect when walking up to any computer. And the combination of that sort of shallow use of language, shallow but broad use of language and common sense that LLMs provide is sort of a complementary thing to the kind of depth that computational language provides. And together those are really a very powerful way forward and a way where through the LLMs, there's sort of access to this great depth of capability of computational language to a much broader range of people. So I kind of expect that that's going to be a critical feature of the future of these kinds of things. I think the thing that is kind of the key skill for us humans is so how do you Try and think about things computationally. Computational language provides a way to sort of crystallize those thoughts. But you have to kind of have a place where you're starting. You have to sort of say, well, given the thing that I imagine that I want to do, how do I think about that enough in computational terms, in a sort of formalized and organized enough way that I could even start explaining, even to an LLM and what it is that I'm trying to do? Then I kind of see it as actual computational language. Then I can keep going. But I think that sort of a key skill going forward is this kind of generalist skill of saying, how do I think about the world in a kind of computational way? And one of the things I think is perhaps interesting is when one sort of asks the question, what should I know about the computational world, so to speak, to be able to so think about things computationally? Well, you need to know a bunch of facts about. About the computational world, so to speak. You need to have the idea of, you know, what a. What a sort of computational representation of an image or a sound or something, what the idea of, of some kind of pure function and. And so on is. There are these ideas, these. These things that have been discovered in our civilization and so on. And it's a question of getting. Of having the sort of broad knowledge of all of those kinds of things. And I realized that actually, if you just look at the kind of homepage of the Wolfram language documentation, it's a pretty good sort of set of points about things that are sort of parts of that computational world, things that are sort of part of the canon of knowledge that has been put into computational form, the computational representation of the world. It's kind of a good place to start in terms of understanding the world computationally, so to speak, and being able to think computationally and formulate things so that one can make use of computation as sort of the power tool to make progress. Well, so I view that as being kind of one of the next phases in what has to happen is kind of the broader and broader knowledge by people of kind of the general idea of the computational world. And then the ability to take these different pieces of one of the things that's been a big emphasis in designing our computational language is sort of consistency and compatibility between these different parts of the language and different kinds of things you can do. That's kind of a key aspect of Wolfram language. And it's something that, as one has this more general view of what's computationally Possible becomes even all the more valuable. It's so that's kind of the. So. So I think this, this kind of sort of the. The future of sort of pretty much every field X is computational X. What is computational X? Well, it's about taking these broad ideas of computation and, and being able to see how they fit into some particular area X. And that's kind of the. And I'm pleased to see that kind of the things that we've been building for such a long time have sort of landed as really the key element that's needed, with the help of LLMs and so on, to sort of make computational X a real thing for a broad range of people. Now, you know, it's fun to compare the sort of. If you compare kind of The Mathematica version 1 and its capabilities with a modern Wolfram language, Mathematica version 1 is a small slice of what is now possible. What has been exciting is that the design methodology and the core design ideas of symbolic expressions, transformation rules for symbolic expressions and so on, those core ideas have successfully carried us from the sort of thin collection of things that were Mathematica 1 to the full collection of things that are today's modern Wolfram language. And that really validates for me the idea that the symbolic expressions are a successful kind of medium for understanding computation in the way that humans can engage with it. It's kind of ironic, perhaps amusing in some ways that I've also been over all these years very interested in basic science. In fact, from my point of view, the reason to originally build SMP and then Mathematica was so I could use them myself. And I'm sort of, if I'm user number one or something in some sense for these systems, I don't think I'm any more even close to the best Wolfram language programmer. But although I use it every day, it's, I think the thing that has. It's. It's kind of, you know, I have a. It's kind of the tool that's allowed me to think more about basic science. And by the way, in terms of the sort of the rhythm of one's life, you know, I've kind of alternated between thinking about basic science and building tools for technological tools and have done that kind of alternation about five times now. And I found that sort of doing the basic science informs kind of what tools one can build. Having built those tools, one can then do more science and see further at a scientific level. And that's been a really powerful thing. But one of the things that's happened is. So I've been a big user of what's now Wolfram Language and Mathematica and so on, and generating hundreds of thousands of notebooks over the course of years that every so often I have to pull up one from 1990 or 1991. And they run, which is really nice. And it's kind of as. It's like you can. Well, not quite as extreme as you excavate a die from some dice from kind of ancient Egypt. And they're in polyhedral shapes. And it's like, gosh, it's a polyhedron that is, as you know, looks like a modern polyhedron. Well, that's because a polyhedron just is a polyhedron. It's an abstract kind of thing. And our goal with our computational language has been to make it the kind of abstractly meaningful thing. And that's kind of what the fact that we can maintain compatibility over this long period of time is kind of a dividend from that. From that effort. But anyway, one of the things that is perhaps amusing, even ironic, is that I've been interested in basic science as well as in creating tools and in basic science. One of the things that I've been interested in is fundamental theory of physics and sort of, what is our universe actually made of? What's underneath space and time and all the things that we experience in the physical world? What's the underlying machine code, in a sense, for all of that? What's the thing underneath? And three years ago now, we kind of launched the Wolfram physics project, having made really tremendous progress in understanding this question of sort of what's at the bottom? What's the machine code of the universe? And it's all about hypergraph rewriting, and it's all about using hypergraphs as a representation of space and everything that's in it, and all the different paths of rewriting corresponding to the different histories that show up in quantum mechanics, all those kinds of things. But the thing that I realized only kind of after the fact, in a sense, is that in the end, what we're doing in physics project in this kind of model of fundamental physics, it's really back again to transformation rules for symbolic expressions. In a sense, the representation that we have for the universe given in terms of hypergraphs. But they really can be thought of as very much just symbolic expressions. It really turns out to be the case that after many, many, many years sort of exploring different kinds of things, we're back realizing that the actual universe is the same kind of idea of Transformation rules for symbolic expressions. For me, it's sort of a personal irony because I kind of started off kind of inventing this idea of transformations for symbolic expressions back in 1979 or so as a piece of sort of tooling, a sort of intellectual tool and an engineering tool. And I really hadn't been thinking about that in trying to construct kind of a fundamental theory for physics. But it's kind of interesting that the fundamental theory for physics, which one ends up constructing, loops back to the same set of core ideas. Well, okay, I've talked a little bit about where we are now, a little bit about sort of where I see the future going. I would say that the thing that we've had this kind of very fixed mission of sort of making everything about the world computational, having this fixed set of design principles, building on the things we built before, been very satisfying, as is clear from sort of this compatibility of our system. It's been very satisfying that. It's been possible to kind of just keep building all these years. You know, often you build something, you kind of throw it away, you build something else. In a sense, that's what I did between SMP and Mathematica. I built SMP and so on and then started from scratch in building Mathematica, which was a good thing because SMP had a lot of good ideas and some not so good ideas. And in Mathematica we were able to take the good ideas and not the.

Bad ideas, so to speak.

But it's been very satisfying to be able to take this kind of stack of both ideas and technology and just keep building for the last 36 years to create what we now have today. And I look forward to doing this for many years to come. It's been very nice to kind of share this activity with lots of people who've been able to make use of Mathematica and now Wolven language. It's been kind of great to see all these things have been discovered and invented and created with the technology that we built, and lots of people able to unlock new kinds of things and have a good time kind of using and learning with the technology we've built. That's been a tremendously satisfying thing. I think that one of the things that one kind of realizes after one's been at this for as long as I've been at it is you kind of get some idea of kind of the rhythm of discovery, invention, absorption of ideas and so on. And it's always, you know, I've done a certain amount of scientific history and it's always interesting that the. The first instinct is, oh, you know, when you look back is to say, oh, that idea. Everybody understood that immediately because now we're 100 years later and that the. The 25 years it took, or even the 50 years it took for something to emerge, they all get compressed in our view from today. And it seems like that just happened immediately, but actually it took a generation or several generations for something to be understood and really absorbed. And so it's kind of interesting to see from where we are now, kind of how we can expect that to play out in the future. And I have to say that I think a lot of the ideas and things that we have now, it will be interesting to see as the decades go by, so to speak. There's a very slow process for seeing these things get sort of very widely absorbed. I certainly noticed in the big book that I wrote in, came out in 2002, a new kind of Science. I said in the preface of that book that many of the things that it describes will at first seem to people quite shocking and eventually will seem obvious. And 20 years later with that book, I would say a progression of more ideas from the book have started to come to seem obvious to people. And it's kind of. I find it kind of charming that people will take ideas. Well, a big one from that book is computational irreducibility. And we'll just take it for granted, as obvious and as I do now after so many years. But at the beginning, when I first introduced that idea back in the 1980s, it was very far from obvious. It was a kind of a shocking idea. Well, so it is with tools. And there are things where one kind of introduces things. As I say, notebooks were sort of, in some sense, surprising and shocking back in 1988. And then gradually, over time, they become sort of widely absorbed. And so it is with other ideas about the construction of orphan language and so on. And I think one can plainly see that there are ideas which are kind of where the absorption time is measured in the substantial fraction of a century kind of timeframe, based on at least what I can see from the history of the absorption of ideas in science and other places. So it's kind of nice to be able to have built something and to be able to have lots of people be able to use something which is in some sense, an artifact from the future. In some sense, the things we've built as a result of having kind of understood something about what the foundations of computation can be like and sort of building from Those foundations, we've been sort of. It's been very nice to be able to build things which are kind of the obvious thing that you can build, but they're the thing which aren't necessarily absorbed in today's world in a very broad way, but they're things which one can think of as kind of artifacts from the future. And so I think it's very nice to kind of take the point of view, as I certainly end up kind of thinking of myself as doing. When I use Wolfram Language and Mathematica as a tool, I'm kind of. I know I'm kind of using something which for many people seems like kind of a magical artifact from the future. It's something where it's kind of. It's. It's very. It feels very satisfying to feel that one is using sort of an artifact from the future. It's like, I don't have to wait for the future. I can just use this now. And that's something that we've been. We've been trying to deliver sort of artifacts in the future for a long time. I myself kind of like to really, really feel the best about things I've created where once it's created, one can kind of see that that was possible, but one might not have been able to see that the thing would be possible before it was created. And I think many aspects of Mathematica had that feature that once it was created, one could see, oh, yes, that's kind of an obvious thing one could do, but before it was created, it's not something one readily imagines. And it's something where it feels very good to be able to sort of build on a kind of tower of ideas and get to a place where one can sort of imagine new things. And that's been a really satisfying thing to do. So I think back from. If you had asked me back in 1988, you know, what would this all look like 35 years from now? I would have said, well, I think it's going to be kind of. We're going to be able to build on these foundations. I. I expected that. I think that the extent to which kind of the idea of symbolic expressions and so on, the extent to which that's really been as general as it's been, has been surprising. And the fact that it even extends to kind of fundamental theories of physics and so on is even more surprising. But that's been something of a surprise. I think that the extent to which it's been possible to take kind of general knowledge from the world and make it part of the computational language. That's something I hadn't so much expected back in 1988. I thought that there was a domain of kind of precise formal knowledge in areas like mathematics and so on that was readily sort of turned into, could be turned into something computational. But I hadn't really realized that these sort of things about the world that seem fuzzier and unless definite, could also be in. Could also be sort of codified in such a way that they can be made computational and made to be things you can compute about. And I think that the, the thing that it's so, so kind of. There have been some things that have been sort of expected, some things that have been surprises. I think just a few years ago we finally checked off the last thing on my 1991 to do list for what should be in the Mathematica of the future. There are a few things that could drop off the list because they're things that the ambient technology of computing no longer makes make any sense. But mostly those were sensible things to want to try to do in 1991, and we finally got them all done. It's kind of been a long term story building the things that we've built and we've kind of. We very much planned for the long term, but it's satisfying when that planning for the long term means that we can maintain compatibility over 35 years and so on. Well, okay, I think that's more or less what I had to say here and I'm excited that we're that in a sense, when I use Wolfram language today and I look back at Mathematica from 1988, it all seems very modern. It seems very modern today and it seemed very modern in 1988, but it's retained its modernity all these years, much as kind of the polyhedron from antiquity might maintain its modernity. It's kind of a thing where when you get the primitives right, when you really can get the essential ideas in a clean form, you kind of maintain that sense of freshness over all this time. And it's very nice to see that that's been the case. Even though the details of floppy disks and printed books for everything and so on, those have been sort of washed away in the world. But the kind of the structure of our computational language has remained unchanged and is something that I hope and expect can be built on for a very long time to come. So, all right, thanks very much.

And let's see. I think maybe we have time. Do we have time. Let's take a look here. Do we have time for some questions or comments or not? Oh, boy. Okay.

Well, we seem to have questions here.

So let me see where I can.

Well, okay, there are a few questions here.

Maybe I can try to address these.

Aaron asks, in the early days of Mathematica, perhaps even today, were most people used to thinking of programs procedurally? Can you talk about people's reaction to learning to do functional programming? You know, I don't think anybody who hasn't been exposed to kind of coding of the kind that fits into sort of the, the structure of computers as computers were originally built. I'm not sure that people find procedural programming natural in any way. I think the idea that you can, for example, take a list of things and do something to them, the idea that you can do an operation on things and so on, those ideas seem to come very naturally. I've watched this for kids, for example, who learn Wolfram language as their first language. It's like they don't really have any trouble with any of that stuff. And sometimes when they've learned, oh, a computer thinks about things procedurally step by step, then when they get to see something where it's a sort of functional programming story and they don't have to do that, they're like, this is very confusing. How can this possibly work? And then they realize it works and it's like, oh my gosh, that's cool. Now, having said that, there are ideas in kind of computational language and functional programming and so on. They're ideas that are ideas that are not obvious. For example, the very idea of a pure function, an anonymous function, a lambda, a lambda function, these kinds of things, that idea, it took a long time to develop that idea in the history of human intellectual development. And it's not an idea that to most people, in fact, I don't think I've ever seen anybody to whom that idea was self evidently obvious when exposed to a computer. So it's something you have to learn, and it's a little bit like in math, in logic, in these other areas of formalization. There are ideas to learn and there are ideas to learn if you want to understand the world computationally. Some of those ideas, those ideas are very natural in sort of a functional programming kind of framework, but they're ideas that you nevertheless have to learn. One of the challenges that I've set myself for the next year or so is to kind of write down something about what is needed, what one needs to learn to learn computational thinking, what kinds of Facts and principles and ideas one needs to learn. I think Aaron was also asking about how did people think about programming. I have to say, for a large collection of scientists, for example, and students who learned, whose first exposure to computers that could actually compute things was to Mathematica, those people, they never learned procedural programming and they were never confused by it. There were other people who said, oh yeah, I learned Fortran and, or I knew assembly language. Those were kind of the prevalent, you know, Fortran was the prevalent kind of scientific programming language of the time. And they're like, well, you know, this doesn't work like Fortran. And sometimes they were confused. I know, you know, I, I can say there were people, I, I might give two examples. One, Yeah, I suppose I can give these examples. The John Nash, who was a creator of Nash Equilibrium and so on, happened to be a, was a user of Mathematica and I think had a deeply procedural view of some of the code that I saw that he'd written was some of the most bizarrely kind of procedurally spaghettified code I've ever seen. He managed to make it work, which was interesting. Another person, well known mathematician, who very charmingly, somebody who happened to have been a former student of mine, was sort of assigned the task of showing him how to use a computer, how to use Mathematica. And this particular individual kind of had never used a computer, never touched a computer before, and kind of then developed this theory for how computers must work inside and all about essentially transformations for symbolic expressions. And I found it charming that from, you know, that was the natural thing for a, a kind of a, a sort of distinguished mathematician who was used to thinking kind of cleanly about formal ideas. The natural thing for him particularly having seen Mathematica was this must be how computers actually work inside. Of course it's not, but it's kind of, kind of interesting that I think that there's a certain naturalness to this and it's been a, an anomaly of history. That hasn't been the thing that some people have seen at first. I mean I would say that these waves that started with basic, which was one of the better, one of the waves of, you know, let's teach coding typically on the terms that computers use procedural programming and so on. I think that those waves of let's teach coding have come and gone multiple times over the years usually because in the end the sort of procedural programming thing is definitely an acquired taste for certain kinds of engineering oriented folk. And it's something which I don't think is particularly Natural as a way to think about things. I always find it charming when people find ways to explain things to make them seem natural. Like back in. When people are explaining relativity and trying to explain why space and time with the same kind of thing and coming up with all these kind of contorted explanations. It turns out in our model of physics, space and time aren't the same kind of thing, which is what we might expect from our everyday experience. But there are these very contorted sort of explanations of this. And it's the same thing, I think, with procedural programming sometimes, that people come up with these very contorted explanations for why this must. Why this seems natural. Anyway, the. Okay, so Dzero asks, was there any point in these 35 years where you said, okay, time to close up shop, this won't work? No, I'm happy to say no. It's really. It's been a great, A great ride. I would say that with smp, the thing with S and P, I started my first company and I made many mistakes in that. And that was something where it was at some point time to just say, for me, this is not going to work. I mean, that company actually did. Did okay in the end. And it went. It became an AI company back in the. Well, by the. By the late 1980s, early 1990s. But AI meant a different thing in.

Those days, expert systems and things like that.

In any case, that was a case where I sort of said at some point around 1985 or so, that's not going to work. If I'm going to be able to build a system that is the system I want to have, I need to start from scratch again. And that's what led to the building of Mathematica. But there hasn't been a moment when, I mean, it's, you know, by the time one has many millions of users and many, you know, many things that are based on the system, once built, it's kind of no turning back. And I find it, you know, I'm proud of what we built, but it's also now a responsibility and responsibility to maintain the kind of the platform that many people have built many things on. And as I say, it's great to see this compatibility that we managed to maintain. And I think that's sort of part of the responsibility is to maintain those kinds of things. And.

So let's see, it's, you know.

I will say, by the way, that, you know, this kind of journey of building, building Wolfram language has been one that I've been lucky Enough not only to have many enthusiastic users, but also our core team of developers. And I'm also happy to say that many people have been working on mathematical and Wolfram language for many decades. And I think someone who's been at the company for 30 years was noting that he was now the 15th in line in terms of people having retired and so on and left before him. So the 30 years of tenure at our company, there are still 15 people who have more tenure than that. So it's been great to be able to work with a really talented group of people. It's also been very nice that all the time there are new, typically young, but new people to us coming in, to the whole kind of. Whole kind of ecosystem and to our company. And it's been something which has been very invigorating for me over the years. It's been something where I. I like to kind of assess how many of the ideas we implement are ideas that are mine. And I don't know whether it's still the majority. I'd like to hope it isn't still the majority, but there's a substantial chunk that is ideas that have originated with other people. And that's a great thing. And I think it's also, for me, it's something where the activity of building Wolfram language is kind of a. It's a fascinating intellectual activity. I think this idea of, you know, if you're doing language design, you need to kind of drill down to. Into kind of the essence of how things work to a point that it's kind of the. The most essential way to understand things. It's kind of a poetry of intellectualism, so to speak, of trying to. Trying to sort of get to the essence of ideas and represent them in a way that people can understand. I mean, that's. That's. This kind of. This. This activity of language design involves that. It's been, for me, something that's been sort of a. A very satisfying, exciting thing to do because it's made me learn about all kinds of different areas, and it's made me learn those areas fairly deeply. And in fact, insofar as I've been able to make progress both in the building of oral language and in science, that's in no small part a consequence of the fact that I've had this. This kind of breadth and depth of knowledge of all these different areas and been able to make these kind of connections between them. But it's been great to kind of share that journey with a lot of talented people at our company. And also in recent years, last five years, live streaming, many of our internal design review meetings. And so perhaps some of you have gotten to know some of the, some of the folks who, who work at our company through those live streams. But it's also been been great to kind of share that process with people in the outside world.

See trying to.

The. So let's see. I'm. I'm.

Some other questions here.

Well, Lala asks what went into the launch of Mathematica in 1988. So started building it in August of 1986. That was when the first code got written. And we'd actually planned that it would be launched early in 1988 and really was not too far behind schedule. In the end it was we kind of set, I think we set the final sort of announcement date maybe a month or two in advance. One of the things that was a gating item for that was the publication of the Mathematica book published by Addison Muslay Publishing Company. And that was a big adventure to get that book published and in bookstores on time. It's actually a thing that the modern world actually takes longer to print a book now than it used to take to print a book then at least if you're not using kind of modern print on demand technology if you're doing an actual print run. And I remember for the original Mathematica book, the creation of the book was a whole adventure because it was a book that in the end had, it was produced with, with Postscript, which was kind of a new technology back then. And, and it was. We were producing it. Well anyway, the, the end of that whole story was that having we, we had to gut like get the thing output onto film to be printed from. And in the end, in one of those, in the end the CEO has to jump in and do things, type stories. It was over, it must have been over the.

Labor Day, Labor Day, Memorial Day.

I always get those mixed up the holiday at the beginning of the summer time because sort of everything was closed down. And I ended up flying to Toronto where we knew a person who had a phototypesetting machine and we kind of babysat the machine over a weekend and kind of generating the film for the original Mathematica book. And then I flew from there to Boston and at the airport in Boston handed the film for the book to somebody from the production group at Addison Wesley who took it off to be printed. But that was the main controlling item was get the book printed and get it into bookstores. And that didn't take Too long, I guess. I guess it took six weeks, something like that. Once the book was, you know, once the film was printed for the book, we were kind of committed to certain aspects of the design. I would say that one of the things that, that I did at that time, which is something we sort of continued with, is, you know, the documentation came first. Typically before implementation was like document things, then implement. In modern times, as we've done more and more difficult implementation and more and more difficult design, it tends to be the case. You do some initial documentation, then you start implementing things, then you kind of see how it feels and how it works, and then you come back and iterate that. But that was kind of the story of that. And then in the actual setup for the sort of grand press conference, it was again very much of a. Well, we were starting to actually sell Mathematica on floppy disks at software stores. Yes, there were software stores in those days. It was kind of people believed there would be corner software stores, like there will be corner bookstores, and we needed to actually get copies of Mathematica available in software stores. So it was a kind of a floppy disk duplicating adventure with computers and so on. Later on, in later versions, there was kind of always this grand moment when the master disk would get made. And usually the timing was such that somebody would have to fly with them to the duplicator to get the disks made. But the actual final. So it was really a very quick process to build version one of Mathematica, partly because I had sort of prototyped many of the ideas and engineering methodologies in SMP and made some of the obvious mistakes there. And it's always kind of shocking to me that a modern version of Wolfram language can take longer to produce from the incrementally previous version than it took to make version one from nothing. But that's the nature of large engineering systems. It is also something where the ambition level of what we're doing in a version today is so unbelievably much larger than it was back at the beginning that it. And as we're about to release version 13.3, and even that 0.1 increment release is already a very impressive collection of things. I think we recently had a version release where the version increment introduced more new functions in Wolfram language than all the functions that existed in version one. So we're definitely making bigger strides. And that's really a result of being able to build on the tower that we've already created. We're able to take kind of the building blocks. We've already made these big building blocks and they all fit together. We put lots of effort into making that possible so we can build much, much taller, much more quickly. AJ asks, what aspect of Mathematica are you most proud of and how has it influenced your approach to problem solving? I would say the aspect that I'm most proud of is the coherence of design and the fact that it operates on a very small number of principles. And that sort of idea that you can really drill down and understand things and get things to the point where they can be coherent and unified. That idea is something that I have applied throughout my efforts in science and other places. It's like, yes, you can really understand things, you can really drill down and understand stuff. And that's kind of the core thing about Mathematica is that it is all based on sort of really deep principles that then apply to lots of kinds of things. Paula asks, what are some updates to Mathematica that you're looking forward to or would like to see incorporated? Well, gosh, we still have a long to do list. I would say that what happens is that certain areas kind of get to the point where, where they are broadly enough understood that people could actually make use of them. And what we tend to do is kind of surf the front of where things are beginning to be broadly understood and try to take things which maybe have been done in some experimental mode, maybe just maybe by us, but maybe by other people as well, and try and consumerize those, try and package the things up so that they can be broadly used. And I would say that some of the things that, well, even something like hypergraphs that we've used a lot in our physics project or multi way systems and multicomputation, which is kind of an idea that's emerged from our physics project though, has precursors elsewhere. I would say that something like multicomputation, it's just coming over the horizon where I think we understand it well enough, where we can start packaging it up for sort of consumer use and making it possible to really think in a distributed parallel way about computation within Wolfram language. I think some of the things that being able to extend the kind of notion of computational language to kind of everyday discourse, to be able to express the things that one would sort of talk about in sort of everyday discussion in computational language. That's the thing which kind of the LLMs have shown us, if we didn't realize it before, that there is kind of a semantic structure to language and common sense. That is a structured thing that we should be able to capture in a kind of symbolic way to make this kind of symbolic discourse language. And that's another thing that I'm hoping to see happen now. Another thing is that both kind of interface modalities and computer capabilities kind of come over the horizon. Back when we built Mathematica version one, for example, it was a big deal that we defined colors using just RGB values. Back in those days, usually you would load a color table and then index into it. Or that we would decide to make our graphics be resolution independent and not just a bitmap for the particular resolution, not created just in that way. Those were things where the principle was clear. There was a certain kind of reality to the computers that existed them. And we opted to kind of follow the principle, so to speak. But there are things where at this point we're kind of, you know, how do we interface with us humans? You know, we've got our visual system, we've got our auditory system and so on. You know, things like augmented reality. Eventually we started working on things like that back in 1990 when it was cool once before. But when those things eventually arrive, there will be all sorts of new kind of ways in which one can interact with the computational language and I suspect new things that become possible there. I think another kind of thing is interacting with the real world through things like robotic labs, various kinds of actuation in the world. Those are other places where kind of I think sort of we can see computational language really extend to being able to sort of do a physical experiment just by typing Wolfram language and have it happen in some cloud lab. Out there in the world is another thing that sort of a coming attraction that we're just beginning to see. So let's see. Nathaniel asks comments on page 498 of the original Mathematica book. It says Mathematica itself was written using an object or extension. Object oriented extension of the C programming language. Well, yes, we made. Oh my gosh, how can I have forgotten the name that we gave to. Well, okay, so let me explain. Back in 1988, C was a well developed programming language. I would say SMP was one of the first large application programs that was written in C back in 1979. And in those days people would say, oh, you're writing a big serious system, you should be thinking about assembly language and so on. Much as people might say today, oh, you can't use high level computational language. You've got to write things in low level code. And so on. Back in those days that was assembly language, but SMP was written in C. That was kind of a departure. Then when we came to build Mathematica, Objective C and C were kind of just around, but they didn't have native compilers. They had compilers that required translation into C and they were pretty inefficient. And we needed, particularly for memory allocation, we needed kind of a very efficient way to set things up. So we built our own extension of C with a pre compiler that would efficiently deal with the extensions to C that we needed. And I guess we still use that for some parts of our code base, although the innards of how that works have been changed over time, particularly as new ideas about memory allocation have come in. But you know, the original code of Wolfram language all written in this extension of C and I wrote big chunks of that code. I'm a little bit horrified that I'm told a bunch of code that I wrote is still running in the system, particularly code in the pattern matcher and so on, which admittedly was somewhat complicated code. But as time goes forward, more and more of Wolfram language is written in Wolven language itself. I think a very large fraction of it is now written in Wolfram language. And as we advance with our compilation efforts, even more and more of it is written in Wolfram language to the point where I fully expect that at some point in the future, 100% of Wolfram language will have been written in Wolfram language. And that has all sorts of things that become possible in terms of being able to expose more code, et cetera, et cetera, et cetera. It's, it's, it's an interesting thing and I think it will lead to higher efficiency and, and sort of higher maintainability and so on. And I think it's, you know, generally when you're doing a long term project like Wolfram language, there are, there are usually sections of the language that get looked at every, you know, in 20 years there are new, better algorithms for this or that thing. So you come through that area and really try and improve those. And that means that people will quite routinely get messages saying, you reported this problem 20 years ago. And it's finally now as we sweep through sort of enhancing this particular area that's finally now fixed. So we like to maintain those kinds of records. I was going to show, actually I have some of the early registration cards. It's kind of, perhaps we can look at those for a moment here.

I think.

In terms of, let's see, in Terms of logistics, I think I was slated to do a quite different Q and A. And I think maybe we'll just continue with this one. So Gustavo asks, why was the MA extension changed to nb? Okay, so back in the day on a Mac, files had two forks. They had the primary fork and they had a binary fork. And so we had kind of the hack that a Mathematica file was called MA and and its binary fork was called mb. Kind of cute. Actually, the creator ID four letter creator ID was omeg, which and still is omeg, which stood for the earlier name that Mathematica had been given during its development. The first name we gave to Mathematica was Omega. And it's kind of ironic that in moving from Mathematica to Wolfram Alpha, we in some sense moved from Omega to Alpha, so to speak. The name sequence for Mathematica was first Omega, then Polymath, then briefly Technique and then Mathematica. Actually, Steve Jobs was the one who really was pushing for Mathematica as the name was a name we'd considered. But I was like it's too long, it's too ponderous and so on. And for a long time I would say that has served us well as a name. Although in modern times it's been really important for us to sort of make clear that there's a big generalization from the original use case of mathematics. And that's why we really like talking about Wolfram language today rather than specifically Mathematica. Mathematica is kind of the thing that the brand that is the strong one for, for mathematical kinds of things. But Wolven language as a whole is really more about this general computational language story. I forget when we changed the NB extension. I'm kind of thinking it was version three, which is in the mid-1990s. And that was. Well, we didn't need binary forks anymore and we really wanted to emphasize the idea of a notebook. And we, we had thought of notebooks as quite general kinds of things. And it's kind of fun now with chat notebooks we get to show kind of, we get to see, you know, AI's interacting with notebooks. We've, we've had external languages, we had Wolf, well, Wolfram Alpha inside notebooks. Now we get another thing. Un1 comments. They kind of miss old computers because they forced you to focus on the task at hand. Yeah, well, right. They only could think about one thing and the user using the computer could only think about one thing. I think it's now it requires more force of mind on the part of the computer and the human to keep moving forward, so to speak? Brady asks, will LLMs themselves carry the torch forward at making everything computational define their own useful symbolic expressions? I think there's some hope of that. I mean, we've been doing experiments where one takes kind of areas of functionality and kind of including things like legacy libraries that exist in programming languages and so on, and says, how does one make a Wolfram language design for these? And there's some evidence that LLMs following our design patterns can do something useful along those lines, I think at some point, feeding the. What is it? I don't know, thousand hours of livestream design reviews that we have now, feeding those to LLMs to say keep doing things the same way these guys have been doing it is something that is potentially quite promising and potentially something where if the LLM can kind of surface, this is what you might do that's already very useful for a person. It's kind of like it doesn't necessarily. The thesaurus doesn't necessarily tell you the word to write next, but it suggests a bunch of words that are reasonable ones to think about. Wish to be asks, have you ever in the past 35 years written some pen and paper, mathematics on paper? Let me think about that. Not a lot. I have to say, my older daughter, who is now a mathematician, when she was younger, I made comments like seeing her do calculus and integrals and things. I didn't know people still did that kind of thing by hand. Not particularly endearing perhaps, but I. I thought it was kind of a. Almost a charming thing to see, you know, actual by hand, you know, writing of math and so on. I'm trying to think. I don't think I've done very much by hand. I've. I've, For example, with things like cellular automata, simple programs that I've investigated, a lot of that I started investigating at the beginning of the 1980s. I've investigated them extensively with computers. I have like a couple of times by hand, just for the sake of the novelty of it, you know, tried to fill out the squares by hand. It's really boring.

It's really terrible.

You know, it reminds me of why I first started using computers, which is, you know, I want to do physics, I want to do things like that. I don't want to do kind of the drudgery of kind of moving the math around or moving the simulation around by hand, so to speak. That was what got me into using computers. They are a great kind of power assist for those kinds of things. Memes asks, what's the number one function you'd like to add? But seems infeasible with current technology. Interesting question. You know, I've had this idea since the early 1990s, I thought in the early 1990s I started thinking about sort of space time as a network and things like this. And I had this. This idea that I was going to use virtual reality and I was going to have this whole growing network in the virtual reality, and I was going to kind of pick away at it with my fingers like a spider web and, and look at other pieces and so on. And I kind of had this vision that that would be useful. I'm not sure it'd be useful actually, because we've done some experiments along these lines that haven't quite gotten to that point. But I've always had kind of this vision that that might be the thing that might be a useful thing. I don't know. You know, I think that in terms of sort of the interface modalities, you know, stuffing things through the input channels to our brains, there's only a certain set of things that can be stuffed through, so to speak. And those are things that one needs to. So I'm not sure that that's necessarily a direction, I would say. Well, there are things to do with multi computation and sort of being able to do things massively in parallel and so on that are not really feasible yet. I mean, GPUs are too kind of lockstep and actual distributed computers are too kind of slow to communicate and require too big a chunk to be communicated. And also, most importantly, we don't have a good way to think about those kinds of things. We don't have a good way to think multicomputationally. One of the exciting things in the physics project is realizing, well, even though we may not have a good way to think multicomputationally, the universe is working multicomputationally. And our ways to think about things have to do with sort of imposing ourselves on a multicomputational process. So imposing ourselves on the many paths of history, of quantum mechanics and so on. And I think that that is a, you know, being able to pull that into something that we humans can understand. That's, I think, an important and interesting challenge that will probably reveal quite a lot about physics as well as giving us new ways to do computation. So that's something that I think that's a direction. So another thing that is when I think about symbolic discourse language, and I think about translating big Chunks of text into computational form. That's something that looked infeasible a year ago. It looks much more feasible today. Still haven't gotten to the point where we can routinely do that, but it's still, it's something that's, that's looking much more promising. But it's an interesting question. Let's see. Bob asks, what do you think Mathematica will be like in 10 years time? I think there'll be more bells and whistles in notebooks and things. There'll be more kind of routine use of LLMs and so on and there'll be a bunch of sort of additional functionality. But the things, you know, today will still absolutely work and the things, the principles that have existed in the system will still be the same principles going into the future. Guillermo asks, what are some of the most unusual applications of Mathematica you have encountered? Oh my. There's many, many. And I, I think, you know, one of the things that I always really have get feel great about is when there's some field and it's a new emerging field and one hears about it, there's some, you know, emerging expert in this field and something very new. It'll turn out that the computational tool that gets used is with overwhelming probability our language, which to me is really, really cool. That it's really. That was the goal was to have something that people could sort of think about frontiers with. And that's really what seems to have happened. So. Oh gosh, I mean, Well, there's one old story which I suppose deserves to be retold because it's a good story. This is probably the first Mathematica in space story. There's a American astronaut called Mike Foale who was doing a tour of duty on the MERS space station when that was still a thing and had taken a Mathematica with him and it was installed on a NASA PC on the space station. And then there was an accident on the MERS space station and that PC wound up in space. It wound up. But being a good astronaut with always having a backup plan, Mike had a three thumb drive or something tucked away with his Mathematica on it that wasn't with that laptop. So he takes the thumb drive out and is like getting ready to install it on a Russian PC. Now the backdrop to this was the result of this accident had been that the Mir space station was tumbling in space, rotating around in a rather undignified way, perhaps. But anyway, on the spinning space station, Mike puts the thumb drive into the Russian PC and In those days, it was sort of software. Copy protection was a thing. And the thumb drive says, hey, I'm an American copy of Mathematica. I don't run on Russian PCs. So that was kind of a downer for that kind of backup plan. So then our customer service team gets this phone call from some ground control person saying, you know, I don't know exactly what they said, but we need to transfer this license from one computer to another. And it, and there was kind of a, I think was kind of a weird story of. Because one computer, because the computer it was on is off in space, et cetera, et cetera, et cetera. And it was one of those, just turn on the television and see what's happening and you'll realize it's a true story. So we were able to sort of give some different activation code or something. And the Mathematica started running fine on the Russian PC. And Mike was solving the equations of motion for the tumbling space station while on the tumbling space station. And in fact had figured out some plan for how to stop the space station tumbling. But I gather the Russian ground controllers were like, it is not in the plan. You can't do that. That's a new idea. You can't execute that. But eventually they used some, some kind of known planned thing and, and the space station stopped tumbling and everybody lived happily ever after. But that's, I think that's the story of the first, not last, but first, Mathematica in space. I think there have been, I'll tell you one other story of a, of a unusual use case of. Of sorts. This is a few years ago now. I was. So Mathematica and modern language have been used in education well, for 35 years and very widely in college level education, increasingly in high school education. It's kind of one of those frustrating things because back 35 years ago it started getting used in high school education. But it's been such a slow ramp over all these years. I think it might accelerate with LLMs though. But any case, but a few years ago there were a group of, I think 11 year olds or so who were bright 11 year olds who had learned Wolfram language. And I happened to, they had kind of a little club and so on. And I dropped in there and these kids were speaking code to me. And I'm just like, I can't understand this. At that rate for me, this is not a spoken language. I mean, I realized from that moment that we should figure out a way to make it a spoken language because it's actually really kind of useful. But that moment of, I think they were very disappointed that the inventor of this language can't even speak it. It's terrible. But that's, I suppose another unusual use. I suppose now, gosh, there have been so many, I think, you know, there's so many things that are sort of features of the modern world that first got developed, I gather, in mathematical and modern language. And you know, often we don't hear about these things for years. Decades later, you know, the fact that the original codec for Skype was developed, I learned that, I don't know, 20 years after it happened. The fact that the ad bidding algorithm for Google got developed in sort of first presented as a Mathematica notebook, I think I Learned that maybe 10 years after it happened. There are so many of these things that you put out a tool like Mathematica into the world and people use it for lots of things. I would say when it comes to academic work, people sometimes mention oh yeah, use Mathematica for this and the acknowledgments their paper. But it hasn't really been in some fields that's a thing. I mean, in the life sciences, for example, there tends to be method sections. And so you'll see people typically mentioning use of language and Mathematica in those method sections. But in other fields that hasn't really been a thing. I mean, in modern times, when people are saying, did you use an LLM for that? I kind of, I think to the fact that for 35 years people have routinely been using mathematical and morphin language to do things. And it's like nobody said, oh, you can't do that. It's been a thing that everybody sees as being kind of a tool that just helps the humans get what they want to do done. So that's been. But let's see, are there other, are there other colorful uses that I can describe? Well, I suppose I could describe my one, another of my kids, my youngest son, Christopher, who might have been seen on live streams and things in design reviews and such like. One story I might tell there is he learned to use what's now orphan language at a very young age. And actually one of his early sort of pieces of commentary was why can't I just type natural language to this thing? And that was actually part of the initiation of WolframAlpha came from partly from that term, from that whole story. But any case, for a long time he really knew well mathematical and wolfram language and can do all kinds of things with it. And when it came to doing some piece of modeling about physics or something, he could write down differential equations. And do all those kinds of things and solve them and such like. But he was for a long time a very pure play example of computation, but not math and really knew, you know, understood computational kinds of things I think really very well. But when it came to sort of traditional math, he was like, he didn't really believe in that. He often used to say he didn't really believe in math. And you know, if you asked him what's the integral of x squared? He would have no idea. He'd just say I can type it in and I get the answer. It didn't really matter to him what the formula was because he was going to just use that for something. And the actual form of the formula, if he needed it for something, well, he'd get the computer to do it. It was kind of disappointing in a sense that he eventually kind of learned traditional math. I think even his undergraduate degree was in officially majoring in math, although only for sort of somewhat default reasons, but so that kind of got broken. But for a long time he was a very interesting example of how far you can go understanding computation without sort of doing the traditional kind of understanding of math. And the answer is you can go a really long way. And that's sort of a good, good test case, I suppose, for, for that theory of things. I didn't particularly encourage or induce that just happened that way. But in any case, other. Interesting kinds of things. Well, I suppose, you know, WolframAlpha was a big use case, is a big use case for Mathematica because that's what's inside it. And I think that was a kind of the, the concept of building this extra layer on top was something that was kind of an important use, I suppose of the core technology. Bob asks, how did you get the first funding to make Mathematica? Did you always know it would be successful? I was lucky enough to not have any outside investors in our company then or since. That's kind of how we've been able to focus on long term things and how I've gotten to do crazy stuff like basic science and so on. And we now have a Wolfram Institute for doing basic science. But for a long time that's sort of just been part of my main activities. What happened was the sort of early funding came from pre selling licenses for Mathematica and particularly making bundling deals. The first such deal we made was with Next with Steve jobs sometime in mid-1987. I think to bundle the Mathematica on every NEXT computer that was made. As I mentioned earlier, one of the sort of strange footnotes to history was people bought NEXT computers so they could run Mathematica. And one group that did that was the theory group at CERN Particle Physics Research Organization in Switzerland. And the SIS admin for that group was a certain Tim Berners Lee who decided to take these NEXT computers that have been bought for running Mathematica and network them and start sending things back and forth and then created the web. So that was sort of a strange footnote to history. I don't consider that a use of Mathematica, but it was a spin off to that. But so the first sort of deals we made with well, Steve Jobs was the very first deal and then with Sun Microsystems, with oh gosh, IBM, Silicon Graphics, Ardent, which became Stardent, which became something else with a whole bunch of companies. Mostly they were, well, many of them were deals where there would be the original sort of most visionary deal with the Steve Jobs deal of let's just put a Wolfram language on every NEXT computer. It's been kind of interesting in the years since there have been a few such deals made like Raspberry PI has a Wolfram language on every Raspberry PI and various intelligent assistants. We're going to see going forward what happens with LLMs. I think that's a likely thing to happen with LLMs of sort of doing the visionary thing again 35 years later of kind of bundling this sort of computational language with the kind of stack that is the LLM stack as well as bundling the LLM with the computational language. But that's a different story. But yeah, I think that's the. Yeah, that was, that was. And then when Mathematica was released in, In June of 1988 it was very instantly quite successful. I mean the world moved a bit slower in those days and you know, no social media, no web, but the sort of pickup of usage was, was really quite rapid. I mean there were issues like how were universities going to use it. We kind of invented the idea of site licenses for software at universities and that really hadn't existed. It was only a kind of oh yeah, you can get sort of some kind of educational thing on computers type thing, but not really this kind of sort of broad licensing for universities. That was a thing that, that took a few years to, to develop but has been very successful since. And did I know it would be successful? No, I kind of had a sort of a five year time horizon I would say that my original idea was to build a company like Adobe originally was where they had a technology Postscript and they licensed it to people to bundle in printers. So kind of next was my first example of that bundling the computational language we're making in a computer. And that's still what I think is the kind of right way to do things. But we realized first with the Mac and then with other systems that we really had to build our own sales and marketing organization. And that's not been the greatest focus of our company in all these years since we've really been focused on building the best products more so than the commercial aspects of optimizing those that side of things. But. My time horizon was kind of take see what happens in the first five years. And actually about five years in things were very successful and we were thinking about taking the company public and fortunately we didn't do that. Partly it was a, you know, one of the exercises was okay, we'll bring in a lot of money, what are we going to do with it? And we're like, well, we got a lot of things we want to work on, but there's a certain rate we can work on these things and have them really be good. And just throwing a lot of money at the problem wasn't really going to help that. So thankfully actually we didn't take the company public and we were able to kind of continue all these years operating as an independent organization able to sort of focus on long term kinds of things. And that's been great. I would say that did I know it will be successful? I think I'm a person who does large projects. I think I'm also a person who is intrinsically something of an optimist. I think you need that if you're going to do large projects. And I never really think that much. I always sort of just assume that projects are going to be successful. I, I think I don't really and I always see myself as taking no risks and just, you know, look, I'm just going to do this, do this, do this and I know I can produce something and but you know, in reality, probably from the outside it isn't really that way. Aaron asks, did you consider just working at Symbolics on Maxima or the like instead of building your own tools? Oh, well, that's a complicated story. So that takes us back a long way. It takes us back to 1976 I guess when. So I first started using computers back in 1973 and I used to program an assembly language and I started writing kind of mostly attempting to write physics simulations. One of the ones I attempted to write was one sort of understanding the second law of thermodynamics didn't work at the time. And earlier this year I wrote something which I think kind of ties off the things that I had been thinking about in thinking about the second order of thermodynamics back in 1972. And it's kind of a 50 year span, it's kind of my longest running project was understanding the second law of thermodynamics. And I think checkbox, I think I really do now at this point. But that was my sort of very early experience with computers. 1976, I started to use algebraic computation. At first I was. Well, I was a. I just. I left high school when I was 16 and I went to work at a government lab in England called the Rutherford Lab. And that lab had a big fancy computer. It also had access to the arpanet, which was forerunner of the Internet. But on that big fancy computer it had a program called Reduce, which was an algebraic computation system that nobody used. But somehow it was on that computer and I was able to sort of pick through and use it a little bit. And then at some point I sort of started using the ARPANET. And node 236 of the ARPANET was the MIT MC computer, the multiple access computer of Project Mac, the multiple access computer, I guess that stood for at mit. And on that system had been developed this thing called Maxima, which was sort of an outgrowth of, was built on top of LISP. LISP had been this language developed by John McCarthy back in 1958, originally as sort of kind of an implementation of lambda calculus which could come from Alonzo church back in 1935. Marvin Minsky always used to say that John McCarthy never really understood lambda calculus.

I don't know if that was really true. But.

My relations with John McCarthy were for various reasons which I could explain. Not perhaps as cordial as they might have been, but the. I suppose the reason for that was that when we came to build smp, it was the first time some people had tried to build kind of a symbolic computation kind of system. Not in Lisp, in C. And I think John McCarthy never kind of forgave me for that. But in any case. So Lisp had been a thing, sort of more a theoretical thing, but it had been, you know, early implementations of it had existed from the early 1960s, a very visionary language in many ways. And then there's come, let's See mid to late 1960s, maybe 1968ish timeframe. There was sort of an effort to, you know, we're going to nail artificial intelligence. In addition to language translation and this and that, were going to teach computers to do math and to do calculus in particular. And that was kind of the gold standard. By the time computers can do integrals, we'll know they're smart, we'll know we've achieved artificial intelligence. And they were a lot of kind of humanizing of the computer. Like I think in the early version of doing that it was like, give me a cookie. It would say, and then you would type a cookie and then it would go on. I think it might be an apocryphal story, but I think it is said, I've been told that the cookies of browsers derived from that early give me a cookie to make the AI seem more human kind of idea. In any case, back in 1970 or so, there were early kind of experiments in doing algebraic computation on top of Lisp, the system called Maxima. And then I started using that in 1976. I think I became not too long the world's largest user of that system. And I built a lot of tools in Maxima for doing physics computations, particularly Feynman diagram computations. It was not the world's best programming environment in many ways. Its idea of programming was very Algol, like very procedural. And it tended to sort of just about fit on the KL10 computer that it ran on and then sort of topple over and run out of memory and all kinds of things like that just at the moment when you were about to get the results. But it was a good system in many ways, but still a system that sort of. I would say I was able to use it successfully, but I think other people were not so successful. And it seemed to require much more of a creator babysitting type thing than would be possible if one was going to sort of launch the thing into the wild. So this has come 1979, there were now versions of Maxima that existed on VAX computers. There was a whole adventure of kind of sort of the licensing of the thing for the VAX computer. And the whole government supported software adventures. I'm forgetting many of their details by now. But part of that story had led MIT to kind of spin off Maxima into this company called Symbolics. I don't think it was. I think the people involved would say that it was one of. It was a lousy decision to do it the way that it was done, but at the time, that was kind of very much early days of the interaction between universities and companies, something that I later got tangled up with at Caltech, but this was an earlier iteration with different outcome at MIT. But anyway, then we get to 1979 and I'm kind of, look, one can do better. I could see how to build something better than Maxima. And so I talked to the people who were working on Maxima and I think had symbolic spun out by then. I'm not sure, maybe right around that time. But any case, I talked to the people working on Maxima and it was kind of an interesting sort of cultural phenomenon because the older people said, look, obviously one could do better, but we're way too old and tired. We're not going to start from scratch again. And the younger people said, there'll never be anything better. Forget it. You're never going to be able to do anything useful. So that was what led me in. I mean, actually in my personal story, In November of 79, I finished my PhD thesis, PhD at Caltech and was off to. And I was at that point at the ripe old age of 20 or so. And I literally finished that. And then the next week I flew off to CERN, actually where they were recruiting me there. And I, I briefly considered taking a job that involved kind of commuting between Geneva and Los Angeles, but, but quickly realized that was a really stupid idea. But then the, you know, I went and visited CERN for a couple of weeks and that was when I started kind of writing out the kind of detailed design documents for smp. And so that's how I got to start building that. And I think it, you know, I'm glad I built my own thing. I think I'm glad I built my own thing twice, actually. Although, you know, when I'd been building smp, I certainly was imagining I was building something that wasn't just the first of two, so to speak. I'm pretty happy with number two. I think number two will carry us into the indefinite future. I'm pretty happy with the whole paradigm and structure and it's the permanent thing. And that was kind of what I imagined in 1986 when I started building Mathematica. My kind of calculation was I want the thing that I can use now and forever, so to speak. And that's what I seem to have gotten. Let's see, Ahoy asks, 100 years from now, how do you envision Wolfram's continued enhancements in Mathematica and other future computational Languages. How will the organization continue? Well, sadly, I'll be dead in 100 years and, you know, cryonics notwithstanding, you won't hear from me again. I think it's an interesting question. I think that one of the things we built in the organization that we have is a pretty robust sort of way of innovating and way of moving forward with what we've done. Back in the early years, it was sort of frustrating for me because I felt like I was the only person who, who understood the methodology of doing design for our computational language. But that's no longer true. There are a large group of people who understand that, including many who are quite young. And that's something which I think I'm very hopeful that we can see sort of a continuity there going into the distant future. I think one of the things that we continue to think about evolving is, okay, we have this thing. It's a piece of intellectual property. It's something that we want to keep vibrantly developing. And the best scheme we found for doing that is it's a piece of software and we sell it and, you know, we make it available on the cloud, we make Wolf Malpha available for free, we have free versions for developers, et cetera, et cetera, et cetera. But fundamentally it's a thing where it's bought by the people who use it, or at least it's bought by organizations which contain the people who use it and so on. But we're continually interested in sort of different models for how one can maintain kind of vibrant, innovative development and be able to give access to as many people as possible to the things we develop. And for me, I've watched so many of these kind of indirect methods of kind of having the resources to be able to continue doing sort of frontline development. And so far, the one that we have is the best one I've seen. And, you know, I think our record of continuing to innovate and develop the system for now 36 years, is a rather unique record. And I think it's one that relies on, for us at least, the fact that we can be independent, that we. The thing we're delivering, we're delivering to people who are the people who are responsible for providing the resources to keep going, so to speak. So that's been an important. That alignment has been important to me that, you know, and we don't have to worry about, you know, we, we can very, very simple when it comes to, you know, questions like user privacy, we just. Like we don't have. We're not we're not going to try, so to speak. It's not part of our business model. There's no reason to do that. It's not something where we have some indirect set of of goals. It's something where the people getting value are the people who are responsible for providing the resources to keep going. And I think that maybe there will be a different model for how to do that going forward. I think that's something I've continually looked at and never seen something that's better than what we have right now. But I don't think that that says that there can't be such a thing. I think that I would very much like to see our computational language really routinely available on everything that self respectedly calls itself a computer. And I think that happened in a sort of visionary way with Steve Jobs and Next back in 1987, 1988. It's happened along the way. But I think it's something that's sort of a definite goal for the future. Let's see. Aaron asked about the story of the naming of Mathematica. I think I mentioned some of that. George comments that the SE30 was the first computer on which he ran Mathematica. He Got it in April 1989. Had eight megabytes of RAM. That's more than this one here. This one here has two and a half megabytes of RAM. So that was a. I forget what the 30 meant. 30 maybe was the size of the.

Hard disk or something.

I forget what that meant. Back in the day we used to have two versions of Mathematica. This was an interesting kind of business story. We had the so called standard version, that version 1.1 that I had there was a standard version and we had the enhanced version. Back in those days floating point units were optional in computers or you could do floating point arithmetic. But it will be emulated in software. It's kind of a little bit like GPUs are optional in computers today. And so we had a version of Mathematica for the Mac that the standard version didn't make use of the FPU of the floating point unit and it cost $495 and the enhanced version cost $695 and it made use of the FPU. And one of those early stories of do the economic theories make sense type thing was overwhelmingly the enhanced version was bought much more than the standard version even though the standard version was cheaper. And so we merged those prices and forgot that kind of idea of a price segregation like that that. These are asks do you see VR and AR in Mathematica's future? Sure. You know, the only frustrating thing about that, we started developing VR stuff in, in 1990 for Mathematica. We had nice 3D molecules and all kinds of other things like that. And several times, you know, back at a decade ago, I was again like, we should pay attention to VR and ar. And the people in the company said, you know, you told us that in the early 1990s didn't work out. And now I've been saying this again and people are like, well, we'll wait and see, we'll see. Maybe it'll just be mostly, you know, a television that you can look at in space type thing. I don't. I mean in local space, so to speak, not in. In outer space. But I've certainly thought a little bit. We thought a little bit about, you know, what do notebooks look like in VR? What are some kinds of things that you can do to kind of take the world as you see it and annotate it computationally. That's sort of an interesting direction for ar. M Comments it sounds hard to come from a single computer computation to cloud like environment. You know, here's a funny thing. Version 1 of Mathematica separated the front end and the kernel. And one of the reasons we did that very early on, and in fact version one could run remote kernels. You could run the kernel of Mathematica on a supercomputer of the time while connected through a phone line, for example, to the. To the front end running on a Mac. In fact, it took a couple of decades for us to finally tear out the code that allowed you to actually connect with a telephone modem and so on between the front end and the kernel. But that was a thing. Back in version one, you could do remote computing. Back in version one, the idea of making things run in the cloud, sort of. We could have just made the kernel run in the cloud. We chose to also make notebooks run in the cloud. That was a big pain. I mean, that required re implementing sort of our whole notebook paradigm in essentially JavaScript. In a web browser. We certainly look to alternatives, but that's what we've ended up doing. And web browsers have certain different user interface expectations from the desktop. You know, on the desktop it's useful to have many windows in a browser. It's better to have all the things within a single pane and so on, or within a single window, things like that. And it's just a slightly different set of expectations. But also this idea of the persistent cloud object is a very powerful and useful idea that is something that we've even now emulated in so called local objects locally on your machine. But that's a thing that sort of came to the cloud. Now we invented back, I don't know, a dozen years ago or so now all sorts of things like instant APIs where you can just write API function of a symbolic expression and say cloud deploy that I noticed some new company whose sole purpose is to make instant APIs. It's always amazing to me that these. It's a one function company, so to speak, and one function that we invented like more than a dozen years ago now. But in any case, so yes, there were ideas like that, instant APIs, API functions, those kinds of things which were invented for the cloud. There are yet different ideas that one invents for things like blockchain and for autonomous computations happening sort of autonomous computational contracts being run. That's yet a different sort of form factor for computation. So is running inside an LLM and so is running with an LLM interacting with one in a notebook. These are all different factorings of kind of the interface to the system. And they're all very interesting to look at. I mean, for example, the Wolfram language code that LLMs write isn't quite the same as what humans write. It's different in certain ways. The natural language that LLMs send to WolframAlpha is different from what humans send. The natural language that humans send through things like Siri and so on is different from the natural language that people send when they're just typing on the web. There are always sort of slight differences and it's interesting to see how one adapts to those things and many of those differences, like things like the cloud and so on, they introduce a collection of new ideas like persistent cloud objects. The idea of the function repository, the idea of being able to deploy a resource function that you can then use, the idea of immediately having a resource function that other people can make use of. These are all things that sort of comes with the cloud, so to speak, and super valuable. I mean it's just an incredibly convenient way to develop things things and be able to share what one's developing with other people. Let's see, off asks, what are a few of the most important fundamentals of Mathematica which most people are unaware of? What uses are there that you'd like to see better, more widely explored? Any favorite moments? Well, I would say the main thing is that it's not just about math and there Are it's kind of there's this broad world of computational language and computational X for all X. I suppose the thing that it's really, can you understand that broad kind of concept of computational language? Take the principles from the sort of core of Wolven language and apply them in all these other places and apply the computational knowledge, the knowledge base that we have and so on, use those kinds of things. That's the kind of broad use, I would say, in terms of myself. I've had many aha moments along the way of realizing, oh my gosh, that's just a symbolic expression. You know, oh my gosh, these parallel processes that we're running, each one is just a symbolic expression. It's kind of, oh, we can think of a notebook as a symbolic expression that was from a long time ago. Or we can think of, we can take the paradigm that we've built and we can apply it to yet another thing. There have been many, many, many aha moments of that type. And in a sense, the intellectual structure of saying we're going to take this paradigm and apply it to all these different things has been very useful in kind of forcing one to kind of think clearly about all these different kinds of areas. D0 says AI in the 1970s must have been terrifying. You know, I think a number of things that are interesting happened. I mean people thought that people. One of the things was AI in restricted environments will be easier to make work than AI in general. And common sense for a world of a few bricks will be easier to deal with than common sense in the bulk, in the large. And it turned out it wasn't true. People had tried to build specialized question answering systems before WolframAlpha turned out. Doing it in general for WolframAlpha was maybe easier, maybe it's just different people doing it, but I think was in some sense easier. In the end, with deep learning and so on, and now with LLMs, we kind of get to learn that the big problem is actually easier than the little problems. So one of the things was this reductionism in AI that people kind of assumed was let's solve the micro problem first and then generalize to the big one, rather than let's just try and make everything computational or whatever else. There was the idea of expert systems, of kind of encoding knowledge, which actually is sort of the kind of thing that I've that I think about in, in computational language. I have to say I never worked with those things back in those days and they never made a lot of sense to me back Then because it was kind of like there was a, there was a pinch of magic that never really, I never really understood. It was like, yes, I can write code that does this, yes I can have a representation of this. But this, you know, there's sort of the system will magically become an expert. Never really, never really, I never really understood how that was supposed to work and I think it didn't in the end. I think that the, the story of kind of, you know, different kinds of AI. I mean remember neural nets originated in 1943. By the 1960s there were perceptrons which were, you know, one layer neural nets and so on. There had been, you know, Marvin Minsky and Seymour Pappert's book about perceptrons had kind of killed the field by showing that a sufficiently simple perceptron could only do kind of linear programming kinds of things could only do kind of make linear discriminations and oh, that wasn't going to. And then people made the mistake of saying oh, the very simple perceptron can't do anything interesting. So let's not even bother to look at the more complicated ones. They'll just be more of a mess. And that was, you know, that was a big conceptual mistake, I would say. Let's see. Harry is commenting. I think we'll get a pretty good AI steaming to live on. He's left behind tens of thousands of hours of video. Yes, I, I thought about that. I think that the making a bot of me will be probably easier than for the average human because I've been recording kind of down to the keystroke sort of the things I do for basically 30 something years now. And you know, all the emails I send and receive and lots and lots of details about, about things that I do, plus these kinds of live streams and so on. So there's definitely a lot of me has been for better or worse externalized and yeah, I'm still waiting we'll get to this soon of training the kind of at least the email bot. I'm not sure how useful this will actually be, but maybe it'll be a first cut of hey, here's what my bot has to say. If that's what you need to know, it's all good. Okay, well I think we seem to have reached the end of the questions and comments that I have here. I liked the last one here. The Steven bot will endure. That will be nice. I think it always somehow there's a certain satisfaction to creating things that one thinks will, will have long term relevance and if the bot of me is one of those things then I suppose one should be happy about that. I don't know whether when I look back at things that I did when I was much younger I think by the time I was building smp I don't have too many regrets. When I look at my first science papers that I wrote when I was 15 years old I'm like these could be a lot better. So I don't know. Burning in the bot of me today viewed from the me of the future I kind of hope I'll feel good about the bot of the day but I think it's been the same for a long time so I have what I have. All right, well thanks very much. Thanks for joining us here and I hope you found this look back looking back and looking forward of interest and look forward to chatting with you all on other live streams and so on in the future. So thanks very much and bye for now.