Wolfram Computation Meets Knowledge

Hidden in Plain Sight

Last month, we hosted our annual technology conference here at our headquarters in Champaign, Illinois, where hundreds of Mathematica users from around the world came to show us what they’ve been working on and to see what we’ve been up to.

A lot of the conference presentations are now available on our website, so you can take a look at them even if you didn’t have a chance to attend this year.

One of the coolest things about this conference was that it was our first since shipping Mathematica 6. So in addition to coworkers talking about what they had done with the incredible technology platform we’ve built, we actually got to see what our users have been up to.

It’s gratifying to see people learning about and making use of all the new features. When that happens, it means that not only is the technology working, but that people are understanding it—and that we’ve succeeded in our design goal of keeping things simple.

That’s especially true with Manipulate. It’s probably been our most talked-about feature since release—and many of the presentations I saw used it in some way. Of course, its popularity is also clear from the 2,000+ Demonstrations we’ve published—all based on the Manipulate function.

But all that “talk” isn’t just amongst our users or in the media (though the reviews have been flattering). Manipulate was also something we couldn’t wait to get our hands on in house.

Yeah, the kernel and front-end developers, QA testers and other techies had been using it since pre-alpha stages, when it was little more than a twinkle in Stephen’s eye—but for many of us, it was kind of a mirage. Something you’d see chugging away on someone else’s computer screen, or when you walked into the tail end of the wrong meeting. But was it really there?

They insisted it would take just a few short lines of code to make a basic interactive interface. And I usually rolled my eyes. Even if that were true, how much could it possibly do?

Well, since then, I haven’t had the time to produce the most sophisticated Demonstrations (though I do have one very simple one that I made when I first tried Manipulate), but that’s not really my job here.

What’s exciting is that I know I can. And anytime I want to look up something I’m interested in (oh, say, the value of every stock in the Dow—even though I have no background in finance or programming), I can write a Manipulate for it.

Mathematica stock ticker using Manipulate

My own little customized stock ticker—updated twice a minute. It exists because I was writing this post and thinking about my portfolio, so I made it on the fly—in less time than it’s taken me to finish this sentence. Not revolutionary, but extremely useful—and a lot easier than looking up each stock individually. Or buying some other piece of software that does that (and little more) for me. And look, ma—no annoying ads.

It’s empowering—and completely unexpected—that even the most basic use of a command can produce such advanced results. It almost reminds me of those little Goto loops you’d program in BASIC, except now instead of just some trivial scrolling text or beep, I’m getting practical computational results.

Of course, that got me thinking about what I could do if I actually knew what I was doing (which I stress, when it comes to programming, I don’t). So last month I took a little time off from writing and editing to attend Lou D’Andria’s technology conference talk, “Manipulate Secrets Revealed.”

I was prepared to be out of my league.

Some of the biggest oohs and aahs in the talk came when he showed the ControllerPath option. It’s a simple setting that instantly gives you access to whatever controllers you have plugged into the computer. Mathematica automatically recognizes them (you can see a list of your available controllers by typing ControllerInformation[]), so functions like Manipulate can use them.

With a few quick additions to your code, you can control the sliders and locators with a gamepad or—even more interesting—with the sudden-motion sensor that comes built in with most laptops. Move your computer and Mathematica responds—one of the few times that dropping a two-thousand-dollar machine could actually produce an interesting computational result (though we don’t recommend dropping your computer).

I quickly made a little Manipulate that plays the piano when you move your computer back and forth.

Mathematica code for sudden-motion sound generator

Try doing that by moving your piano back and forth.

Some day, I might even use Mathematica to try to make an “Etch A Sketch.” Or whatever else I want.

Lou showed off lots of things like this. Big ideas, simple execution. The big “secret” wasn’t really any one tip. It was about stepping out of the box, which is really what this release of Mathematica is all about.

Lou’s notebook is now available here, and it includes some undocumented options that you’ll find useful if you’ve already gone through the introductory and advanced tutorials. Not that you should have any trouble using the function without these tips, but it’s exciting to know that if you want to do something more complicated, there’s really no limit to what you can Manipulate.

By the way, it looks like the Dow is trading down today.