Teaching Functional Programming To Kids

I started teaching some of the basic concepts of functional programming to my 8 year old son yesterday, and wanted to write a little about it. The wonderful thing about it is that kids really are ready to learn the concepts at a very young age. I'm not actually teaching him programming, just concepts, but when the time comes, he'll basically already know how to program.

I have what I think is an absolutely perfect example. It's one that all parents and kids can identify with: The Dr. Seuss Star Belly Sneetch machine.




This is a simple machine that takes in a Sneetch without a star on its belly, and spits out a Sneetch with a star on its belly. I'm just going by memory here to say that I think kids can probably understand this concept at the age of 3. In this post I'm going to use this style to represent machines:

               -----------
              |           |  
 Sneetch ---> |     *     | ---> Star Bellied Sneetch
              |           |
               -----------

This is the same as the actual picture above, but works for all cases since I don't have pictures for all the concepts I want to represent.

In the Dr. Seuss book there is also the opposite machine that removes the star from a star bellied Sneetch.

               -----------
 Star Bellied |           |  
 Sneetch ->   |     -*    | ---> Sneetch
              |           |
               -----------

While that seems really simple, it's all we need to start teaching a wide range of concepts to kids. I started with this one, because of its similarity with the machines above (for all the things below, Jacy and I worked them out on a whiteboard. But, paper is just as good):

            -----------
           |           |  
 10  --->  |     +5    | ---> 15
           |           |
            -----------

Here we have a machine that adds five to whatever you put into it. Very simple, very easy for kids to understand. It helps to run a few more inputs through (0, 10, a billion) just to let them know that the box doesn't just take 10 and give 15, it works with all numbers.

After this one I followed up with another very easy one.

            -----------
           |           |  
 10  --->  |     -5    | ---> 5
           |           |
            -----------

At this point he pointed out, "Well it could be a divided by two machine instead." This was unexpected, and impressive, and at some point I'll talk about it further...but not yet. It was great to feel that he was understanding it though.

Now that he was getting it, it was time to change things up just a little bit. I introduced the plus and minus machines, which take two inputs instead of one.

            -----------
 7   --->  |           |  
           |     +     | ---> 19
 12  --->  |           |
            -----------

            -----------
 12  --->  |           |  
           |     -     | ---> 5
 7   --->  |           |
            -----------

These presented no challenge whatsoever. In fact (I guess rather surprisingly), nothing I taught him presented any sort of challenge. Next I introduced the biggest and smallest machines (which we programmers call max and min).

            -----------
 7   --->  |           |  
           |  Biggest  | ---> 12
 12  --->  |           |
            -----------

            -----------
 7   --->  |           |  
           |  Smallest | ---> 7
 12  --->  |           |
            -----------

            -----------
 10  --->  |           |  
           |  Smallest | ---> 10
 10  --->  |           |
            -----------

I guess he was a bit surprised when I showed him the last one. But, it only took showing him the answer once for him to fully understand.

I then added an equals machine that spits out YES! if the two numbers are equal, and NO! if they aren't (true and false, obviously). This is different because now we were no longer working with numbers as the inputs and outputs.

            -----------
 7   --->  |           |  
           |     =     | ---> NO!
 12  --->  |           |
            -----------

            -----------
 7   --->  |           |  
           |     =     | ---> YES!
 7   --->  |           |
            -----------

Simple, but effective.

Now, Jacy and I have done considerable work with logic gates, and I wanted to show him how logic gates are really just like machines. I also taught him the word Function at this point, but didn't push it. Kids can relate to machines, not functions.

            ------------
 ON  --->  |            |  
           |  AND GATE  | ---> OFF
 OFF --->  |            |
            ------------

            ------------
 ON  --->  |            |  
           |  OR GATE   | ---> ON
 OFF --->  |            |
            ------------

            ------------
 ON  --->  |            |  
           |  AND GATE  | ---> ON
 ON  --->  |            |
            ------------

While the logic gate examples seem simple, it tied two worlds that we've been working on together very nicely.

Fun

My son has a really short attention span, and all the while I'm doing this I have to think of different ways to make it fun. If it's not fun, hes just going to go play video games. Rightfully so, video games are fun. There were a few ideas I tinkered with before settling on the Dr. Seuss machine. One was a monster that stuffs stuff into his mouth and then spits out the answer. I thought that one was kind of neat. The point is, if you plan on teaching your child, think of something fun they can relate to.

Combining Machines

I could sense we needed some more fun at this point, and we'd learned enough basic machines that I thought it would be great to start combining them. After trying this, I recommend starting with all alike boxes. We did something a little more complicated and I ended up going too fast, and fell back on this:

           -----------
 7   -->  |           |             -------
          |     +     | --> 19 --> |       |
 12  -->  |           |            |       |
           -----------             |       |
                                   |   +   | --> 39
           -----------             |       |
 10  -->  |           |            |       |
          |     +     | --> 20 --> |       |
 10  -->  |           |             -------
           -----------

After you get this first larger machine done, its pretty easy to add in more complicated machines. However, it might be good to wait until the next day, as Jacy was definitely getting it, but might have been getting a little fried. Here's an example though:

           -----------
 7   -->  |           |             -------
          |     +     | --> 19 --> |       |
 12  -->  |           |            |       |
           -----------             |       |
                                   |   =   | --> NO!
           -----------             |       |
 10  -->  |           |            |       |
          |     +     | --> 20 --> |       |
 10  -->  |           |             -------
           -----------

And obviously, change the 7 to an 8 and get a YES! Different kinds of boxes doing and spitting out different kinds of things. In essence, this is really all we do as programmers.

Types

Being a lover of static type systems, I also talked to him about types, by saying "kind(s) of things". For example, I asked him, "What kind of thing does this machine take in (or what kind of thing do you put into this machine)?"

            -----------
           |           |  
 10  --->  |     +5    | ---> 15
           |           |
            -----------

Answer: Number. I avoided Integer for now. What kind of thing does it spit out? Answer: Number.

I then showed him this next example, which should arguably have a section of its own:

            -----------
           |           |  
 D   --->  |     +5    | ---> I
           |           |
            -----------

This machine looks exactly the same as the machine above, except you put Letters into it, and it spits out letters. We also did months. Both are interesting because they have to loop around. I didn't have to teach him that, he just got it.

Then I introduced a formal notation for types:

            -----------
 7   --->  |           |  
           |     +     | ---> 19
 12  --->  |           |
            -----------

(Number,Number) -> Number

And introduced machines that change the type (he had seen it already, but only with YES! and NO! This, I think, is a better example):

            -----------
           |           |  
 5   --->  | To Letter | ---> E
           |           |
            -----------

Number -> Letter

He understands the notation and can write it if I give him slots to fill in like this:

______ -> ______

or

(______, ______) -> _______

Things I don't know how to teach, Yet

I certainly didn't try to teach him anything about machines that take in machines and spit out machines. Also, some of my boxes were polymorphic, but I don't think I know how to explain that to him.

For now, I think Jacy and I will just do this same stuff for a while, reinforcing it. I'm not sure what the best thing to teach him next is. Some of the stuff here I've skimped on writing up, and we actually spent more time on than it seems.

Anyway, this was all really, really fun, for both of us.