The last installment of my coding autobiography was an introduction to LISP. I’d like to continue that discussion today as a segue to talking about Mathematica, because the way I program in Mathematica is heavily influenced by my experience with LISP.

This week I’ll focus on what are typically referred to as aspects of *functional programming.* Rather than try to explain by using a definition (you can always google it), I’d like to show how I’d perform a simple calculation, like adding the sum of the squares of the first n integers.

Here’s a simple snippet of code which performs this task in Python:

Of course you could embed the *square* function in the loop, but for more complicated functions, this is not usually done. In any case, I’m using this approach to illustrate a point.

Now in Mathematica, I would write:

You might think that there’s no way the code could be shrunk *that* much, but it really is possible. Let’s see why.

We’ll look at the “# * # &” piece first. This is usually called a *pure function,* and is essentially a function with no name. It’s like defining f(#) to be # * #, and then invoking f. But with the “#” as the argument to the function, this syntax allows you to avoid naming the function altogether.

Why might you want to do this? One reason is it makes your code less cluttered if you need to define a relatively simple function and use it just once. I actually use pure functions *a lot.* Once you start thinking about programming with them in mind, it really does help streamline your code. You find you can’t live without them, and when you use a language which doesn’t allow them, you really miss ’em….

What about the “/@”? This is a *map,* and is the alternative to iteration in LISP. What it says is this: “Here is a function, and here is a list of arguments. Apply the function to each of the elements of the list in order, and collect the results in a new list.” So

# * # & /@ {1,2,3}

would return the list {1,4,9}.

In languages like LISP and Mathematica, the use of maps is built in to the heart of the compilers, so that maps are often much faster than iterating. In fact, to add the squares of the first 1,000,000 integers, it’s about 40 times faster in Mathematica to use a map than to use a loop. I can remember a time I was using iteration to create fractals in Mathematica, and it was taking around 10 minutes to generate each one. For fun, I thought I’d try using maps, and the run time decreased to less than 30 seconds! It can really make a difference.

There are more complicated ways to use maps which involve functions of more than one argument, and assembling arguments from lists in different ways. But the example above illustrates the basic idea.

Of course the use of Range[n] is familiar to Python users, and returns a list of the first n integers, starting with 1 — unlike Python, though, where the list begins at 0. Personally, for much of what I do, I much prefer the list to begin at 1. I tend to use “i+1” a lot when I use range(n) in Python.

Finally, what about the “@@”? This is like the apply function in LISP I described in my last post. Essentially, it means take this function, Plus, and apply it to this list of numbers, in this case the squares of the first n integers. It saves having to write a loop which successively adds each next number to a running total. As an example, it is easy to write a factorial function in Mathematica:

Times @@ Range[n].

So that’s how to sum the squares of the first n integers in just a half line of code! Now these ideas can all be implemented in LISP and Python as well, and other languages which include more functional apsects. But for simplicity of syntax, I prefer Mathematica over the others.

The point of using Mathematica code for this example is to show how my style of programming in Mathematica is really very LISP-like. In fact, I’ve had the experience of showing code like this to some Mathematica programmers, and needing to explain it just like I did for you here. This is because if you learned a language like PASCAL, C, or some other procedural language, you can code in Mathematica exactly the same way, without ever knowing anything about the functional aspects.

Back to a little history…. I did all my undergraduate and graduate work at Carnegie Mellon, and beginning with my sophomore year as an undergrad, was working a lot with LISP while teaching with the PGSS. Mathematica was first released during my second year of graduate school, and CMU being the type of school it was, Mathematica was readily available. I can recall working with it on a NeXT computer. (Google it!)

So I was introduced to Mathematica while I was heavily into LISP — and found that I was really excited that I could do so many LISP-like things in Mathematica! More about Mathematica in my next installment of On Coding….

Frankly, I rarely use LISP now. I do recall creating an address book in LISP — having a list of addresses and phone numbers in a long list, and using LISP to output LaTeX code which I could then run and print out a nicely formatted array of addresses. But other than that, little else comes to mind.

But although I don’t use the language itself, learning to program in LISP has definitely influenced my programming style more than any other coding experience. I always encourage my students to study it as a result — although functional programming ideas are now incorporated into many other languages, it’s easy to learn the concepts elsewhere.

For me, I’ll always have a special place in my hacker heart for all those idiotic stupid parentheses….