I’m pleased to announce the release today of Version 11.1 of the Wolfram Language (and Mathematica). As of now, Version 11.1 is what’s running in the Wolfram Cloud—and desktop versions are available for immediate download for Mac, Windows and Linux.
What’s new in Version 11.1? Well, actually a remarkable amount. Here’s a summary:
I’m thrilled today to announce the release of a major new version of Mathematica and the Wolfram Language: Version 11, available immediately for both desktop and cloud. Hundreds of us have been energetically working on building this for the past two years—and in fact I’ve personally put several thousand hours into it. I’m very excited about what’s in it; it’s a major step forward, with a lot of both breadth and depth—and with remarkably central relevance to many of today’s most prominent technology areas.
It’s been more than 28 years since Version 1 came out—and nearly 30 years since I started its development. And all that time I’ve been continuing to pursue a bold vision—and to build a taller and taller stack of technology. With most software, after a few years and a few versions, not a lot of important new stuff ever gets added. But with Mathematica and the Wolfram Language it’s been a completely different story: for three decades we’ve been taking major steps forward at every version, progressively conquering vast numbers of new areas. Continue reading
It’s been many years in the making, and today I’m excited to announce the launch of Mathematica Online: a version of Mathematica that operates completely in the cloud—and is accessible just through any modern web browser.
In the past, using Mathematica has always involved first installing software on your computer. But as of today that’s no longer true. Instead, all you have to do is point a web browser at Mathematica Online, then log in, and immediately you can start to use Mathematica—with zero configuration.
We released Mathematica 1 just over 26 years ago—on June 23, 1988. And ever since we’ve been systematically making Mathematica ever bigger, stronger, broader and deeper. But Mathematica 10—released today—represents the single biggest jump in new functionality in the entire history of Mathematica. Continue reading
Last week I wrote about our large-scale plan to use new technology we’re building to inject sophisticated computation and knowledge into everything. Today I’m pleased to announce a step in that direction: working with the Raspberry Pi Foundation, effective immediately there’s a pilot release of the Wolfram Language—as well as Mathematica—that will soon be bundled as part of the standard system software for every Raspberry Pi computer.
Today it’s exactly a quarter of a century since we launched Mathematica 1.0 on June 23, 1988. Much has come and gone in the world of computing since that time. But I’m pleased to say that through all of it Mathematica has just kept getting stronger and stronger. Continue reading
In a few weeks it’ll be 25 years ago: June 23, 1988—the day Mathematica was launched.
Late the night before we were still duplicating floppy disks and stuffing product boxes. But at noon on June 23 there I was at a conference center in Santa Clara starting up Mathematica in public for the first time:
At the core of Mathematica is a language. A very powerful symbolic language. Built up with great care over a quarter of a century—and now incorporating a huge swath of knowledge and computation.
Millions and millions of lines of code have been written in this language, for all sorts of purposes. And today—particularly with new large-scale deployment options made possible through the web and the cloud—the language is poised to expand dramatically in usage.
But there’s a problem. And it’s a problem that—embarrassingly enough—I’ve been thinking about for more than 20 years. The problem is: what should the language be called?
Usually on this blog when I discuss our activities as a company, I talk about progress we’ve made, or problems we’ve solved. But today I’m going to make an exception, and talk instead about a problem we haven’t solved, but need to solve.
You might say, “How hard can it be to come up with one name?” In my experience, some names are easy to come up with. But others are really really hard. And this is an example of a really really hard one. (And perhaps the very length of this post communicates some of that difficulty…)
Let’s start by talking a little about names in general. There are names like, say, “quark”, that are in effect just random words. And that have to get all their meaning “externally”, by having it explicitly described. But there are others, like “website” for example, that already give a sense of their meaning just from the words or word roots they contain.
I’ve named all sorts of things in my time. Science concepts. Technologies. Products. Mathematica functions. I’ve used different approaches in different cases. In a few cases, I’ve used “random words” (and have long had a Mathematica-based generator of ones that sound good). But much more often I’ve tried to start with a familiar word or words that capture the essence of what I’m naming. Continue reading
There aren’t very many qualitatively different types of computer interfaces in use in the world today. But with the release of Mathematica 9 I think we have the first truly practical example of a new kind—the computed predictive interface.
If one’s dealing with a system that has a small fixed set of possible actions or inputs, one can typically build an interface out of elements like menus or forms. But if one has a more open-ended system, one typically has to define some kind of language. Usually this will be basically textual (as it is for the most part for Mathematica); sometimes it may be visual (as for Wolfram SystemModeler).
The challenge is then to make the language broad and powerful, while keeping it as easy as possible for humans to write and understand. And as a committed computer language designer for the past 30+ years, I have devoted an immense amount of effort to this.
But with Wolfram|Alpha I had a different idea. Don’t try to define the best possible artificial computer language, that humans then have to learn. Instead, use natural language, just like humans do among themselves, and then have the computer do its best to understand this. At first, it was not at all clear that such an approach was going to work. But one of the big things we’ve learned from Wolfram|Alpha is with enough effort (and enough built-in knowledge), it can. And indeed two years ago in Mathematica 8 we used what we’d done with Wolfram|Alpha to add to Mathematica the capability of taking free-form natural language input, and automatically generating from it precise Mathematica language code.
But let’s say one’s just got some output from Mathematica. What should one do next? One may know the appropriate Mathematica language input to give. Or at least one may be able to express what one wants to do in free-form natural language. But in both cases there’s a kind of creative act required: starting from nothing one has figure out what to say.
So can we make this easier? The answer, I think, is yes. And that’s what we’ve now done with the Predictive Interface in Mathematica 9.
The concept of the Predictive Interface is to take what you’ve done so far, and from it predict a few possibilities for what you’re likely to want to do next.
I’m excited to be able to announce that today we’re releasing Mathematica 9—and it’s big! A whole array of new ideas and new application areas… and major advances along a great many algorithmic frontiers.
Next year Mathematica will be 25 years old (and all sorts of festivities are planned!). And in that quarter century we’ve just been building and building. The core principles that we began with have been validated over and over again. And with them we’ve created a larger and larger stack of technology, that allows us to do more and more, and reach further and further.
From the beginning, our goal has been an ambitious one: to cover and automate every area of computational and algorithmic work. Having built the foundations of the Mathematica language, we started a quarter century ago attacking core areas of mathematics. And over the years since then, we have been expanding outward at an ever-increasing pace, conquering one area after another.
As with Wolfram|Alpha, we’ll never be finished. But as the years go by, the scope of what we’ve done becomes more and more immense. And with Mathematica 9 today we are taking yet another huge step.
So what’s new in Mathematica 9? Lots and lots of important things. An amazing range—something for almost everyone. And actually just the very size of it already represents an important challenge. Because as Mathematica grows bigger and bigger, it becomes more and more difficult for one to grasp everything that’s in it. Continue reading
I have four children, all with very different interests. My second-youngest, Christopher, age 13, has always liked technology. And last weekend he and I went to see the wild, wacky and creative technology (and other things) on display at the Maker Faire in New York.
I had told the organizers I could give a talk. But a week or so before the event, Christopher told me he thought what I planned to talk about wasn’t as interesting as it could be. And that actually he could give some demos that would be a lot more interesting and relevant.
Christopher has been an avid Mathematica user for years now. And he likes hooking Mathematica up to interesting devices—with two recent favorites being Arduino boards and quadricopter drones.
And so it was that last Sunday I walked onto a stage with him in front of a standing-room-only crowd of a little over 300 people, carrying a quadricopter. (I wasn’t trusted with the Arduino board.)
Christopher had told me that I shouldn’t talk too long—and that then I should hand over to him. He’d been working on his demo the night before, and earlier that morning. I suggested he should practice what he was going to say, but he’d have none of that. Instead, up to the last minute, he spent his time cleaning up code for the demo.
I must have given thousands of talks in my life, but the whole situation made me quite nervous. Would the Arduino board work? Would the quadricopter fly? What would Christopher do if it didn’t?
I don’t think my talk was particularly good. But then Christopher bounced onto the stage, and soon was typing raw Mathematica code in front of everyone—with me now safely off on the side (where I snapped this picture):
Hi. I’m pleased to be with you. I’ve been asked to talk a bit about the background and vision of Mathematica.
You know, this month it’s exactly 25 years since I started building Mathematica. It’s been really exciting seeing Mathematica grow and prosper over the years. But I have to say that in just the last few years, something truly remarkable seems to have been happening. It feels like Mathematica is really coming of age. It’s in just the right place at the right time. And it’s making possible some fundamentally new and profoundly powerful things. Like Wolfram|Alpha, and CDF, and yet other things that we’ll have coming over the next year.
But let me start off at the beginning. How did Mathematica come to be in the first place? Here’s the personal story. Continue reading
I love computer languages. In fact, I’ve spent roughly half my life nurturing one particular very rich computer language: Mathematica.
But do we really need computer languages to tell our computers what to do? Why can’t we just use natural human languages, like English, instead?
If you’d asked me a few years ago, I would have said it was hopeless. That perhaps one could make toy examples, but that ultimately natural language just wouldn’t be up to the task of creating useful programs.
But then along came Wolfram|Alpha. In which we’ve been able to make free-form linguistics work vastly better than I ever thought possible.
But still, in Wolfram|Alpha the input is essentially just set up to request knowledge—and Wolfram|Alpha responds by computing and presenting whatever knowledge is requested. But programming is different. It is not about generating static knowledge, but about generating programs that can take a range of inputs, and dynamically perform operations.
So the first question is: how might we represent these programs?
With the release of Mathematica 8 today, the single most dramatic change is that you don’t have to communicate with Mathematica in the Mathematica language any more: you can just use free-form English instead.
Wolfram|Alpha has pioneered the concept of specifying computations with free-form linguistic input. And with Mathematica 8, the powerful methods of Wolfram|Alpha become available within the Mathematica environment.
All one has to do is to type an = at the beginning of a line. Then what follows is taken as free-form linguistic input.
You don’t have to use precise Mathematica syntax. You can type things in just the way you think about them, in free-form English. But what happens is that Mathematica calls on Wolfram|Alpha to try to interpret your input, and turn it into precise Mathematica code.
Mathematica 8 is released today! It’s a huge and important release. With dramatic breakthroughs—and major broadening of the whole scope of Mathematica.
After 8 versions and 22 years most software systems have decayed to slow and lumbering development. But not Mathematica. In fact, with Mathematica it’s quite the opposite. As the years go by, Mathematica development is actually speeding up.
What has made that happen? Partly it’s our tenacious and broadening pursuit of ambitious long-term goals. But partly, it’s a remarkable reflection—and validation—of the core principles on which Mathematica has always been built.
For nearly a quarter of a century, one of the responsibilities that I’ve taken most seriously is the shepherding of the design of Mathematica. Partly that has involved establishing foundational principles, and maintaining unity and consistency across the system. But at some point all the capabilities of Mathematica must get expressed in the individual built-in functions—like Table or NestList—that ultimately make up the system.
Each one of those functions encapsulates some piece of repeated computational work—often implemented by some deep tower of algorithms. And each one of those now 3000 or so functions requires a name.
We’re currently in the closing weeks of a (spectacular!) new version of Mathematica, and I spent part of last week doing final design reviews for some fascinating new areas of the system. And as part of those design reviews, we were confirming and tweaking some of the names we’re going to use for new functions.
The naming of functions is a strange and difficult art—a bit like an ultimately abstracted form of poetry. The goal is to take the concept and functionality of a function, and capture the essence of it in one, or two, or perhaps three, words (like Riffle, or DeleteCases, or FixedPointList)—chosen so that when someone sees those words, they immediately get the right idea about the function. In even the most succinct forms of ordinary poetry, you get at least a handful of words to communicate with. In function names, you typically get at most perhaps three.
In the middle of last year, we finished our decade-long project to reinvent Mathematica, and we released Mathematica 6.
We introduced a great many highly visible innovations in Mathematica 6—like dynamic interactivity and computable data. But we were also building a quite unprecedented platform for developing software.
And even long before Mathematica 6 was released, we were already working on versions of Mathematica well beyond 6.
And something remarkable was happening. There’d been all sorts of areas we’d talked about someday being in Mathematica. But they’d always seemed far off.
Well, now, suddenly, lots of them seemed like they were within reach. It seemed as if everything we’d built into Mathematica was coming together to make a huge number of new things possible.
All over our company, efforts were starting up to build remarkable things.
It was crucial that over the years, we’d invested a huge amount in creating long-term systems for organizing our software development efforts. So we were able to take those remarkable things that were being built, and flow them into Mathematica.
And at some point, we realized we just couldn’t wait any longer. Even though Mathematica 6 had come out only last year, we had assembled so much new functionality that we just had to release Mathematica 7.
So 18 months after the release of Mathematica 6, I’m happy to be able to announce that today Mathematica 7 is released!
Today is an important anniversary for me and our company.
Twenty years ago today—at noon (Pacific Time) on Thursday, June 23, 1988—Mathematica 1.0 was officially launched.
Much has changed in the world since then, particularly when it comes to computer technology.
But I’m happy to be able to say that Mathematica still seems as modern today as it did back then when it was first released. And if you take almost any Mathematica 1.0 program from 20 years ago, it’ll run without change in the latest Mathematica 6.0 today.
From the beginning, I had planned Mathematica for the long term. I wanted to build a system that could capture the essence of computation, and apply it wherever that became possible.
I spent great effort to get the fundamentals right—and to build the system on principles that would endure.
And looking back over the past two decades it’s satisfying to see how well that has worked out. Continue reading
It’s not easy to make a big software system that really fits together. It’s incredibly important, though. Because it’s what makes the whole system more than just the sum of its parts. It’s what gives the system limitless possibilities—rather than just a bunch of specific features.
But it’s hard to achieve. It requires maintaining consistency and coherence across every area, over the course of many years. But I think it’s something we’ve been very successful at doing with Mathematica. And I think it’s actually one of the most crucial assets for the long-term future of Mathematica.
It’s also a part of things that I personally am deeply involved in.
Ever since we started developing it more than 21 years ago, I’ve been the chief architect and chief designer of Mathematica‘s core functionality. And particularly for Mathematica 6, there was a huge amount of design to do. Actually, I think much more even than for Mathematica 1.
In fact, I just realized that over the course of the decade during which were developing Mathematica 6—and accelerating greatly towards the end—I spent altogether about 10,000 hours doing what we call “design reviews” for Mathematica 6, trying to make all those new functions and pieces of functionality in Mathematica 6 be as clean and simple as possible, and all fit together.
At least the way I do it, doing software design is a lot like doing fundamental science.
In fundamental science, one starts from a bunch of phenomena, and then one tries to drill down to find out what’s underneath them—to try to find the root causes, the ultimate primitives, of what’s going on.
Well, in software design, one starts from a bunch of functionality, and then one needs to drill down to find out just what ultimate primitives one needs to support them.
In science, if one does a good job at finding the primitives, then one can have a very broad theory that covers not just the phenomena one started from, but lots of others too.
And in software design, it’s the same kind of thing.
If one does a good job at finding the primitives, then one can build a very broad system that gives one not just the functionality one was first thinking about, but lots more too. Continue reading
Not a lot gets written in the general press about foundational issues in mathematics, but this afternoon I found myself talking to a journalist about the subject of certainty in mathematics.
It turned out to be a pretty interesting conversation, so I thought I’d write here about a few things that came up.
Mathematics likes to think of itself as a very certainty-based business. If you’ve “proved something mathematically”, then it’s supposed to just be true. No ifs or buts. Complete certainty.
But in practice that’s not quite how it works—at least the way mathematics has traditionally been done. Because in reality a mathematical proof of the kind people publish in papers is something much more social. It’s a vehicle for convincing other humans—one’s fellow mathematicians—that something is true.
There’ve been a few million mathematical proofs published over the past century or so. Essentially all of them are written in a kind of human-compatible mixture of mathematical formalism and ordinary natural language.
They’re intended for human consumption. For people to read, and process. The best of them aren’t just arguments for some particular theorem. Instead they’re expositions that illuminate some whole mathematical structure.
But inevitably they require effort to read. It’s not just a mechanical matter. Instead, every reader of every proof has to somehow map what the proof is saying into their particular patterns of thought. So that they can personally be convinced that the proof is true.
And of course, in practice, proofs written by humans have bugs. Somewhere between the imprecision of ordinary language, and the difficulty of really thinking through every possible eventuality, it’s almost inevitable that any long proof that’s been published isn’t perfect. And even with an army of people to check it, not every bug will be found.
So how do computers—and Mathematica change this picture?
Our 2007 NKS Summer School started about two weeks ago, and one of my roles there was to show a little of how NKS is done.
In the past, it would have been pretty unrealistic to show this in any kind of live way. But with computer experiments, and especially with Mathematica, that’s changed. And now it’s actually possible to make real discoveries in real time in front of live audiences.
I’ve done a few dozen “live experiments” now (here is an account of one from 2005). My scheme is as follows. Sometime between a few hours and a few minutes before the live experiment, I come up with a topic that I’m pretty sure hasn’t been studied before. Then I make sure to avoid thinking about it until I’m actually in front of the live audience.
Then, once the experiment starts, I have a limited time to discover something. Just by running Mathematica. Preferably with a little help from the audience. And occasionally with a little help from references on the web.
Every live experiment is an adventure. And it seems like almost every time, at around the halfway point, things look bad. We’ve tried lots of things. We’ve opened lots of threads. But nothing’s coming together.
But then, somehow, things almost always manage to come together. And we manage to discover something. That’s often pretty interesting. (There are still papers coming out now based on the live experiment I did at our very first Summer School, back in 2003).
I usually make my first live experiment at each Summer School be a piece of “pure NKS”: an abstract investigation of some simple program out in the computational universe.
This year I decided to take a look at an “old chestnut” that I’d recently been reminded about: a simple program (though it wasn’t thought of that way then) that was actually first investigated all the way back in 1920. Continue reading
Mathematica 1.0 was released on June 23, 1988—now nearly 19 years ago. And normally, after 19 years, pretty much all one expects from software products is slow growth and incremental updates.
But as in so many things, Mathematica today just became a big exception.
Some people have said that Mathematica 6.0 shouldn’t even be called “Mathematica” at all. That it’s something so qualitatively new and different that it should be given a completely different name.
Well, perhaps I’m just too sentimental. Or too steeped in history. Or too naive about branding. But to me there’s no choice. We owe it to all the foundations we’ve laid these past twenty years to still call what we’ve built today “Mathematica.”
Realistically, I think it took us ten years after Mathematica 1.0 just to realize what a powerful thing we had in Mathematica.
We’d always talked about “symbolic programming,” and how it let us unify a lot of different ideas and areas. But sometime around the mid-1990s it began to dawn on us just what an amazing thing symbolic programming actually is.
And we began to think that there might be a whole new level one could reach in computing if one really did everything one could with symbolic programming.
Well, that was an intellectual challenge we couldn’t resist. So about ten years ago, we embarked on seeing just what might be possible. Continue reading
(This post was originally published on the NKS Forum.)
Last Friday (April 28, 2006) would have been Kurt Gödel’s 100th birthday. I agreed to try to write something about it for publication in a newspaper … which had the dual misfeatures that (a) I had to compress what I was saying and (b) that it didn’t actually get done…
Still, I thought people on the Forum might find my draft interesting … so here it is. Please recognize that this wasn’t polished for final publication…
When Kurt Gödel was born—one hundred years ago today—the field of mathematics seemed almost complete. Two millennia of development had just been codified into a few axioms, from which it seemed one should be able almost mechanically to prove or disprove anything in mathematics—and, perhaps with some extension, in physics too.
Twenty-five years later things were proceeding apace, when at the end of a small academic conference, a quiet but ambitious fresh PhD involved with the Vienna Circle ventured that he had proved a theorem that this whole program must ultimately fail.
In the seventy-five years since then, what became known as Gödel’s theorem has been ascribed almost mystical significance, sowed the seeds for the computer revolution, and meanwhile been practically ignored by working mathematicians—and viewed as irrelevant for broader science.
The ideas behind Gödel’s theorem have, however, yet to run their course. And in fact I believe that today we are poised for a dramatic shift in science and technology for which its principles will be remarkably central.
Gödel’s original work was quite abstruse. He took the axioms of logic and arithmetic, and asked a seemingly paradoxical question: can one prove the statement “this statement is unprovable”? Continue reading