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):

His demo was pretty neat. He had a potentiometer hooked up on the Arduino board. And he’d set it up so that all he had to do was type a command into *Mathematica* to get its value:

Then it was `Dynamic[ArduinoAnalogRead[0]]`, and *Mathematica* is dynamically displaying the value in real time as he adjusted the potentiometer.

Then he makes it into a gauge (er, that’s actually from a future version of *Mathematica*, but Christopher is a keen user of internal development builds):

And then he says he’s going to make a dynamic plot of it. And pretty soon he’s typing the *Mathematica* program, confidently presses Shift-Return—and it actually works:

Then he’s on to using an ultrasound sensor, and having it produce musical notes based on distance.

And then he’s on to the quadricopter. He’d been going back and forth with someone at our company for a few days before, trying to get the kinks out of the interaction with the quadricopter’s API. I had seen the quadricopter fly that morning, but I knew Christopher had changed the code quite a bit since then.

His plan was to have a single line of *Mathematica* code that would make the quadricopter fly a specified 3D path. He had a list of points for a square, entered the line of code, and pressed Shift-Return, and… nothing happened!

I guess Christopher has debugged quite a lot of code in his 13 years. And now he set about doing it in front of the audience. A missing function definition. A missing command to connect to the device. He was finding quite a few things. And I was getting ready to call out that he should just give up.

But then… the sound of quadricopter blades, and up the quadricopter goes… flying its loop on the stage, and landing.

It had actually worked! It was pretty neat, being able to just type one line of code into *Mathematica*, and then having some physical object fly around in the pattern one had specified:

After another flight, the audience had questions. One person asked if the quadricopter could respond to its environment. Which set Christopher off on some more “spectator programming”. And actually, it took him only a line of code to get the real-time video from the flying quadricopter, and feed it through simple *Mathematica* image processing:

I was pretty impressed that all this worked (here is the full video). And, yes, Christopher was clearly right that his topics were very relevant to Maker Faire. In fact, it seemed like Arduino and quadricopters were two of the three main technical themes of the show. The third was 3D printing.

I’d actually mentioned that in my talk (at Christopher’s suggestion), pointing out that Wolfram|Alpha Pro (as well as *Mathematica*) can immediately make STL versions of any 3D graphic it generates.

And I was reminded that one of my own early applications of 3D printing years before had been connected to another of my children. In 2006, my daughter Catherine (then 9 years old) was very into 3D geometry, and liked exploring the 3D polyhedra that we had introduced in *Mathematica* 6.

We were just starting the Wolfram Demonstrations Project, and as a sample, we added a little application of polyhedra that Catherine had created with my help:

Catherine had 2D printouts of many different cases, and one day we decided to try making them 3D. It took a little wrangling, but before long Catherine and I were off to a little “3D print shop” full of plastic dust, from which a little zoo of polyhedral koalas emerged:

Every year there’s more and more for me to learn from my children. My oldest child, now age 16, has become a rather successful and uncannily sophisticated entrepreneur—from whom I’m trying to absorb what business wisdom I can. The other three are not yet as “launched”, but each has their definite interests.

For Christopher it’s technology and product design. Learning about every new and emerging technology he can, and developing his own ideas—and often strong opinions—about it. (At Maker Faire, I noted with interest his enthusiasm for getting a Raspberry Pi… and his long discussion about what it would mean to have *Mathematica* running on it…)

Christopher has always been an energetic explainer of things. But it was pretty interesting last weekend to see him for the first time “explaining” to a large audience. He was definitely the star of our joint speaking slot. And—despite a few tense moments—it was pretty fun for me to see two progeny of very different kinds—Christopher and *Mathematica*—work together so nicely.