# The R&D Pipeline for *Mathematica*

Stephen Wolfram kicked off the International *Mathematica* User Conference 2009 with an inside look at what he calls an incredible research and development pipeline for *Mathematica*.

During last year’s keynote address, Stephen surprised attendees with news about the release of *Mathematica* 7—just 18 months after *Mathematica* 6. This year, he said our development pace has become even faster.

The following video clip includes a few examples of what our R&D team has in the pipeline for future versions of *Mathematica*. (You can see the first part in our series of highlights from Stephen’s keynote here.)

**Transcript Excerpt:**

People sometimes say that software rots.

That’s not what’s happened with *Mathematica*.

In some areas, there’s a decade or decade-and-a-half cycle where individual algorithms end up being swapped out.

But the overall structures have been incredibly robust.

Probably because they are based on incredibly robust core principles, like unity of design, and automation of operation.

Well, other keynotes at this conference are covering some of the specific things that are in our R&D pipeline.

But let me at least give a few examples.

One big area is PDEs. Strong, general, PDEs.

This is one of those areas where doing it well requires already having a huge stack of other capabilities.

Symbolic analysis. Computational geometry. Fast linear algebra. Lots of other things too.

There are huge design challenges.

How does one specify boundaries, and equations, cleanly and efficiently?

I think it’s been nearly 20 years since I started talking about "PDE special functions".

The analog for PDEs of ordinary special functions for ODEs.

Well, it’s finally possible to implement those in a nice, general, efficient, way.

Which will immediately open up all sorts of new applications for *Mathematica*.

OK. Another area.

Probability and statistics.

In Version 7, we added the whole `FittedModel` structure, for handling statistical models.

With a clean, but fairly traditional, approach.

But what’s coming is an amazing whole structure that only *Mathematica* can ever even get close to.

A whole symbolic mechanism for representing empirical distributions, and doing computations with them.

It’s going to make handling probabilistic models as easy as doing algebra.

In one fell swoop generalizing and making accessible a vast swath of probabilistic methods that exist in many different fields.

Making *Mathematica* not just *a* system for doing statistics, but the *only* system that has a core understanding of statistics—and that lets one in a unified way apply all the modern methods for handling data and models.

Oh, yes, and in a very nice, clean way, being able to check off from my old to-do list: handling numbers and data with statistical errors.

OK. Something else.

In *Mathematica* 7 we introduced discrete calculus, and things like integer sequence recognition.

Well, coming soon in the pipeline is a vast amount more discrete mathematics.

Especially in graph theory.

You know, in Version 6 we introduced `GraphPlot` and its friends for automatically laying out networks.

They’re incredibly useful functions. I use them all the time.

Well, to really do the kind of unified job of graph theory that we want to do in *Mathematica*, we need tight integration between this kind of visualization, and actual computation with graphs.

And that’s what’s coming.

With lots of very strong algorithms for handling essentially arbitrarily huge graphs.

I happen to be looking forward to that for some basic science applications of my own.

But I think that there are going to be a huge number of applications of what’s in a sense consumerizing heavy-duty graph theory.

What else?

Well, I mentioned before that every decade or decade and a half or so we’re finding it’s worthwhile to revisit algorithmic areas.

Because sometimes there are general advances in algorithms in those areas.

But usually more importantly, there are enough ambient developments in *Mathematica* that we can really rethink the way we handle the area.

We did that for symbolic differential equations in Version 6. For sums and products in Version 7.

Well, that same kind of process is rippling through other areas.

An example in the pipeline is symbolic linear algebra. Doing matrix operations efficiently on matrices with symbolic entries.

Very useful if one can make it work fast. And with all the supporting functionality that now exists in *Mathematica*, together with some clever mathematical algorithms, we can.

Then there’s equation solving. We introduced strong `Reduce` functionality in Versions 4 and 5.

There’s a much stronger general `Solve` in the pipeline. The first really major update to `Solve` since Version 1.

Oh, yes, another algorithm breakthrough area: `NIntegrate`. We’ve developed a whole bunch of new algorithms for handling functions that oscillate.

`NIntegrate` is sort of a black-magic function—that has to get an answer efficiently without taking the time to look too much.

Well, it’s symbolic analysis that allows it to work.

We’ve been pouring all sorts of sophisticated ideas into `NIntegrate` for years. But just recently we had a breakthrough that’s really going to extend it for a lot of practical cases.

OK. Here’s another algorithmic area: tensors.

Manipulating tensors has been a classic symbolic computation activity for more than 40 years.

I worked on it myself a zillion years ago.

And in *Mathematica* there are several very good tensor packages that have been developed.

But somehow I’ve never been satisfied.

It’s always seemed like tensors can only be introduced as a bolt-on—a subsystem with its only separate syntax and structure.

Well, the exciting thing we have coming in the pipeline is fully integrated tensors.

And in doing that integration—which is a really difficult piece of design, I might add—we’re getting a whole lot of other things.

Generalizations of arrays. Sophisticated handling of permutations. Et cetera.

An old problem in tensor analysis is canonicalization of tensor expressions; telling whether one can swap indices around to establish equivalence or not.

I worked on this a bit myself a zillion years ago. I always thought some kind of graph theoretical approach could work.

Well, that’s now happened.

And it’s going to make doing serious tensor analysis feel pretty much like doing ordinary algebra.

Oh, by the way, a spinoff of the tensors project is going to be—finally—a nice, clean, consistent handling of vector analysis.

OK, yet another area.

It almost made it into Version 7, but we weren’t quite happy with it.

A general subsystem for dealing with wavelets.

Integrating wavelets into everything they can be. Images. Signals. And symbolic computation.

Dealing in effect in a quite general way with nested as well as periodic decompositions.

OK. In Version 7 one of the very nice enhancements was symbolic charting.

Bar charts. Pie charts. Histograms. But all based on a clean, symbolic design that lets one maintain data in a structured, symbolic way and propagate it through computations and plots.

Well, in our pipeline is a whole zoo of chart types.

It’s a little like special functions. In the history of visualization in all sorts of fields, different ideas have been invented.

Candlestick charts in finance. Radar plots in data analysis. Plots in the complex plane for complex analysis. Whatever.

Well, we’re going to be introducing all of those into *Mathematica* in a nice, clean way.

So you can use them not just in some special hacky way in the field where they were invented. But in a nice general way across every field.

Oh yes, and we’re going to solve one of my decade-plus favorite problems: introducing general scaling functions to let one handle any kind of functional transformation on the scales of a plot.

OK. Well, there’s a lot with core graphics too.

Some of it is algorithmic. Some of it takes advantage of advances in things like graphics hardware.

On the algorithmic side, we’ve got a lot with computational geoemetry, and meshing, and region descriptions coming.

These are core capabilities that let us do exciting things where we can move the frontiers of what’s possible in computer-aided design and so on.

There are also core visualization enhancements. Like generalized texture mapping for surfaces, all fully integrated into the system.

You know, the list of things in our R&D pipeline is really long.

It’s such fun right now. We’ve built up so much in *Mathematica*. We’re really just able to go on adding and adding.

And—at a least with a lot of hard work in design analysis—the whole system really fits together.

So that the things we’re adding have impact not just in their specific areas, but all over.

In Version 7 we introduced integrated image processing.

And I must say that I’ve personally found it quite amazing how often I want to use image processing for all sorts of things that I wouldn’t usually ever have thought of as image processing.

But because it’s all integrated into the *Mathematica* system, I can just do it.

Well, the image processing in *Mathematica* 7 is pretty impressive. But it’s nothing compared to what’s coming.

Lots of sort of higher-level image processing.

One of the ways we implement automation in *Mathematica* is with superfunctions. Things like `Solve`, that just goes off and solves equations—and takes care of how it happens.

Well, we’ve got a bunch of image processing superfunctions coming. Some pretty surprising stuff.

Oh, and it’s all really efficient. Efficient enough that one can use it not just on static images, but on video too.

And to support that, we’re making it so that things like `Import` and `Export` get generalized to real-time streams of data.

Yet another giant project that we’re now able to do in an integrated way.

OK, here’s another thing.

Control theory. There are a lot of interesting methods that have been developed in control theory over the last few decades that actually deserve to be better integrated into general analysis, and model-building, and so on.

Well, partly building on the add-on *Control System Professional* package, we’ve figured out how to real integrate control theory methods into core *Mathematica*.

It’s very strongly based on nice, clean, symbolic representations of control systems.

But what’s important is that we’re bringing all this stuff right into *Mathematica*.

So it can interact with our statistics functionality. Our graph theory. Our linear algebra. Whatever.

You know, it’s really a spinoff of the unity principle for *Mathematica*.

The idea that everything should be built in.

That you don’t do your work by buying a bunch of separate add-ons, each its own strange world.

But that you just get one integrated system: *Mathematica*.

It’s a lot more powerful that way. Because you can count on being able to draw on anything you need.

You’ve got the biggest, strongest building blocks to use.

OK. Well. One general direction is integrating methods from lots of areas. Figuring out how to design them in general ways.

It’s difficult work. But the good news is that we’ve gotten faster and faster at it over the years.

I think some of the design challenges that we now routinely solve in a couple of hours we’d just have gotten stuck with a decade ago.

Probably that’s one of the reasons we’re able to see such growth in *Mathematica* in these years. So many things coming off my to-do list from 20 years ago.

We’ve needed to build all the ambient algorithmic capabilities. But we’ve also needed the experience to do design.

And it’s tremendously satisfying to me how many old design chestnuts we’re cracking these days.

In fact, I think they’re almost all gone. Though now that we can see further, there are definitely some challenging new chestnuts on the horizon.

Well, back to areas that we’re integrating.

GIS is an example. We’ve already got various import/export formats, and in Version 7 we added very strong geodesy capabilities.

Well, that was a precursor to comprehensive GIS and mapping support. Which is coming.

Another area that we’re integrating is financial computation.

Since Version 6, we’ve had financial data capabilities.

Well, now we’re adding all sorts of financial computation, built right into *Mathematica*. Both simple stuff, for cash flows and time value of money and so on.

But also really elaborate stuff with valuing fancy financial instruments. That relies on really crunchy numerical and algorithmic capabilities.

All right. What about user interface capabilities?

That’s a whole ‘nother story.

I think people will be happy to hear that our user interface group is finally convinced that paper and printing are not going to go away.

So in the pipeline is lots of polishing and enhancement to our printing capabilities.

To help one make beautiful PDFs and things with *Mathematica*.

Oh yes, and there’s also a bunch of new capabilities for defining and manipulating styles and stylesheets.

Making all that more streamlined.

There are things coming, like `Overlay` and `MultiscriptBox`.

These may sound straightforward, but they’re really tricky to design so they really work smoothly.

Talking of which, there’s a lot of smooth going on in our drawing and graphics editing capabilities.

There are metaphors for using those tools that come from drawing programs, or image editors, or whatever.

But the *Mathematica* case is much more general. And it’s really a challenge to fit all these general capabilities into a small collection of gestures that are really smooth to use.

It’s been an interesting exercise for our usability group. Really watching how people use these tools.

And figuring out how to smooth things out—so the graphic never jumps in some confusing way because it’s redoing its plot range, but still manages to take advantage of the best plot range heuristics, and so on.

Well, talking of metaphors. One standard computing metaphor that we’ve never particularly captured in *Mathematica* is the spreadsheet metaphor.

And that’s another thing that’s coming: a `SpreadsheetView`, that lets one get all the advantages of spreadsheet-like data entry, but integrated into the generality of *Mathematica*.

OK. Another big direction.

In *Mathematica* 1.0, the basic metaphor for the *Mathematica* language was linear text, like ordinary human languages are written.

In *Mathematica* 3.0, we introduced 2D input—real math notation that we could parse and understand.

Well, we’ve been thinking for about 20 years about how to smoothly go beyond that: to have whole networks as input.

In *Mathematica* 6, when we integrated graphics right in with typeset input, that became somehow structurally possible.

But what we’ve really wanted to do was to invent a way for people to smoothly make use of such capabilities.

"Drag and drop" is a metaphor that’s pretty nice for some applications, and some interfaces.

Flow charts or block diagrams are nice for some other interfaces.

We’ve now for the first time in the *Mathematica* front end got the raw material to generalize all of this, and make a whole new level of interface.

Well, we’re making very interesting progress on that. I think it’s going to be demonstrated elsewhere.

And there are still some serious problems to be solved.

We keep on saying "there’s a `Manipulate`-like function lurking here". Something clean and simple that really unlocks a sophisticated set of capabilities.

Well, we haven’t found that yet. Maybe it’ll come in the next few weeks. I’m pretty hopeful.

But it’s a breakthrough that’s been a decade or perhaps two in the making.

Alright. So that’s a little on our core *Mathematica* R&D pipeline.

There’s a lot going on in the way *Mathematica* is interfaced to the outside world as well.

More on parallelism.

Work on GPUs.

Still more import and export formats and capabilities.

And here’s a big direction: embedding the *Mathematica* interface into things.

Making *Mathematica* notebooks be smooth plug-ins.

Coming very soon is a complete browser plug-in for all the common browsers and platforms, so you can seamlessly run a *Mathematica* notebook inside a web browser.

So that if you click on a `.nb` or a `.nbp` file, it’ll just automatically download a plug-in—typically a version of *Mathematica Player*—and it’ll just open in the frame of your browser.

The same idea is coming for example for PowerPoint. So right in the middle of a PowerPoint presentation, you can have a live *Mathematica* notebook, with `Manipulate` and everything.

Well. There’s a huge amount in *Mathematica* already today. And new things are being added at an incredible rate.

It’s becoming easier and easier for people in all sorts of fields to immediately use *Mathematica* in their work.

So another big initiative we have is to define specific *Mathematica* solutions for all sorts of different areas.

You’ll see some that emerging right on our main website.

That’s what the Solutions tab is about.

There are already a few dozen specific areas that are covered. We’re going to be going even more deeply into these, and we’re going to be adding a lot of other areas.

Really defining in each case the ways to use *Mathematica* in each area, and communicating the definition to people working in that area.

Over the course of the next year, people are going to be hearing a lot more about *Mathematica* in a lot of different fields.

We’ve got a spectacular set of capabilities for people; now we’re really defining how *Mathematica* can immediately be used.

Both within individual fields, and for all the innovative stuff that happens in the boundaries between fields.

Where unity of design and automation are absolutely crucial. Where it’s no good to have a canned system that was just built for one field or another.

Where you need *Mathematica*, and nothing but *Mathematica*. Because that’s the only way to bridge the methods and techniques of different fields in a smooth and integrated way.

I feel like I’m going to explode. This is so much. I can’t wait. Please tell me we get this for christmas…

This is fantastic news! It is exciting to see several ideas (such as generalized interfaces including ones for spreadsheets, image editing, etc.) I had proposed over the years now in the release pipeline.

A truly powerful core capability would be boundary/edge detection. Boundaries are ubiquitous, and I am convinced the ability to detect boundaries/edges at ever higher levels of abstraction is the key to real fluid intelligence and concept formation. Building this capability into Mathematica would enable it to detect patterns in the increasingly rich world of data and experience. This would take Mathematica beyond traditional data mining and into the realm of true conceptual intelligence.

See http://www.physorg.com/news177095786.html for a recent breakthrough in the field of visual intelligence. The same principle can be applied in any domain.

Yes, please tell us, when can we expect the release of Mathematica 8???

I’d think the timescale involved is a couple of years, not months.

Let WRI use that time to get it right. Any releases with such amazing features should be industrial-strength, not proof-of-concept. (Please, no more proof-of-concept.)

I wish the Image Processing Toolbox could connect to Photoshop the way Matlab does.

I second Vince. Take the time to make sure that when it is released it is as near to bug-free as possible.

It seems now the present and not the future where we will have access to parallel power of computers using architectures like the CUDA from Nvidia.

Will wolfram research include developement of Mathematica in these new hight performance highly parallel architectures? in new versions of Mathematica or at least provide ways to hook into it?

I’d like to see Radon Transform (and its inverse) in Mathematica. I am surprised that this is not yet implemented. (I am talking about Radon transform applied to digital images, i.e. a discrete version of the transform.)

I have looked at the new functions in image processing, and do not see it.

With Radon transform, I can rewrite all my Matlab simulations of Computed Tomography and filtered backprojection using Mathematica and Manipulate instead.

I have one example of such code and how Radon transform to simulate CT on my page here

http://12000.org/my_notes/EE518_CT_project/index.htm

I hope this function will be added to Mathematica in the next release which I am already looking forward to using.

–Nasser

Mathematica has become certainly a very good option to do aything drastic things…..

Here is the explanation for the poor quality of most existing computer software. It is created by rewriting everything from scratch instead of reusing proven work. I got a long way by using the same subroutines/flowcharts in many differrent programs. I just re-linked them and added a bit extra.

I would like to have Fractional Calculus, Fractional Partial Differential Equations, all capabilities of Gimp and Photoshop in Mathematica, may be finite elements like comsol and Integrodifferential equations.

Hi, I am Jorge again, well i would like to have online image editor in wolfram alpha, Thanks and see you.

Using the GPU is a great idea.

Open CL would be the best choice as an open standard.

This will make you an alternative to Matlab Image Processing capabilities.

Instead of “Mathematica Player” why don’t you use some of the HTML5 functionality?

Any plans for adding Algebraic Data Types into the core language?

Hi:

I was afraid that Wolfram Alpha would stunt the growth of Mathematica, by taking away the lion’s share of the Mathematica brain pool for development of Wolfram Alpha. After reading the above article by Dr. Steven Wolfram, I now feel that Mathematica will continue to go forward unimpeded in it’s continued quest of excellence.

Regards,

Bill

Hi,

You mentioned that the future SpreadsheetView function will let the user enter data in a Spreadsheet fashion way.

I was wondering if it will also let the user place functions inside the “cells”, possibly pointing to other “cells” of the same SpreadsheetView instance, returning results in some kind of dynamic way.

This would mimic the main functionality one can find on spreadsheet interface software’s, and extremely facilitate the approach to non Mathematica users.

Thank you,

Pedro

Hi,

Will we be able to input Mathematica commands through wave (Google)?

This would be a great way of developing collaboratively!

Everyone entering lines of code at the same time, sharing the same memory workspace, and creating static or dynamic outputs, manipulatable by everyone accessing the wave.

Regards,

Pedro

This is a short time to do a new release. Will version 8 be out so quickly?

This is a short time to do a new release. Will version 8 be out so quickly?

Can’t wait for version 8, has a firm release date been set yet?

I desperately wanna see the version 8 of it.

Mathematica 8 definitely would be great as all already.

Look at this page. But it’s probably months off.

http://www.wolfram.com/mathematica-8-coming-soon.html?src=google&400+mathematica+8&gclid=CPzP353O46QCFQICbAodVhV4Iw

actually it shouldn’t be too long of wait now:

http://twitter.com/#!/stephen_wolfram/status/2939412262428672