Making Easter eggs

This part of the course can be hard to understand, until you get used to it. Once it clicks, though, it makes your programming life easier. Easy is good.

Let's start with a silly example. There's a ghost company making Easter eggs. There are three parts to the production process.

• Get a cube of clay
• Carve the cube into an egg shape
• Paint the egg

Here are the three product stages, from left to right.

Four ghosts make the eggs. Here they are.

Mainy is in charge. It coordinates production, telling the others when to do their tasks. Mainy doesn't know exeactly what they do. Just what they need to do their job, and what the result of their work is.

The others are:

• Gety gets a cube from a magic cube making machine. Needs: nothing. Returns: a cube.
• Carvey carves a cube into a blank egg shape. Needs: a cube. Returns: a blank egg.
• Painty paints the blank egg. Needs: a blank egg. Returns: a painted egg.

Gety, Carvey, and Painty are specialists. They each do one function. Mainy gives them a thing (except Gety, who starts with nothing). They do something to the thing they get, transforming it. Then they take the transformed thing back to Mainy.

Mainy's job is to give each ghost what they need, send them to work, and take what they make. Then pass it on to the next ghost.

Mainy's program

Here's the program Mainy runs:

We could make this Pythony. Here's the first line:

get_cube is the name of a chunk of code, called a function, that Gety runs. The parens list what Mainy gives Gety. Gety doesn't need anything from Mainy to do its job.

Remember how = works. The thing on the right goes into the thing on the left. So this...

... puts 5.99 (the thing on the right) into the variable price (the thing on the left).

So this...

... puts whatever get_cube returns into thing.

Let's continue with Mainy's program.

That's the task from Mainy's point of view. It doesn't need to know how the tasks get done. It only cares about what it gives each function (each ghost), and what it gets back.

Mainy is a coordinator. It makes sure the right subtasks get done in the right order.

Here's a messed up program for Mainy.

The cube is painted, then carved. Hmm. No good. Even though Gety, Carvey, and Painty all did their jobs correctly, it's a hard fail. The coordination was broken.

get_cube()

Let's see things from Gety's point of view. It hangs around waiting for an instruction from Mainy.

Gety goes and does that job. Just that. It doesn't know how to do anything else.

Here's Gety's code.

Here's Gety, having just arrived at the machine.

Gety works away. Here it is with the cube, getting ready to go back to Mainy.

Gety carries the cube back to Mainy, and hands it over. Gety's doesn't know what Mainy does with the cube. That's not its job.

Now Mainy has the cube.

Here's all the code so far.

get_cube is a function, a block of code with a name. This one sends cube back to whoever called it. In geek language, it returns cube.

I commented out the last two lines, since we don't have the functions yet.

carve_cube(thing)

Let's work on the line:

Mainy hands the cube to Carvey, and tells it to get to work.

Carvey goes to its carving workstation, and gets started.

Here's Carvey's code.

Another function. A chunk of code with a name (carve_cube), that takes something in (thing), and returns something, that is, sends something back, in this case a changed thing.

Here's Carvey taking the egg to Mainy.

Carvey doesn't know what Mainy does with the blank egg. Not its job.

From the outside (Mainy's view), Carvey gets a thing, does stuff, and returns a transformed thing. Mainy doesn't know the deets.

Now Mainy has the blank egg.

Here's the code so far.

paint_egg(thing)

Last step. Mainy gives the blank egg to Painty, and tells it to do its thing.

Painty goes to its paintery, and gets to work.

Paint, paint, paint...

Here's its program:

When Painty is done, it takes the painted egg back to Mainy.

Painty hands the egg over to Mainy.

The easter egg is done!

Here's the final program.

Each function is one step in a longer process. The main program coordinates. It calls the functions in the right sequence, sending them what they need, and taking what they send back.

This is how Python is often written. Functions at the top, main program below. All lines of the main program are kept together. That's how we'll do all our code from now on.

Ooo, good eye, Adela, and good use of archaic slang. The things in () are called parameters, or arguments (more later). It doesn't matter so much what they're called. The first parameter in the call paint_egg(new_thing) is matched up to the first parameter in the definition of paint_egg(egg).

Why do this? It lets you reuse the function with different variables. Imagine you had three eggs being processed at the same time. You could have this code:

carve_cube is called three times, with three different cubes passed in. We don't have to write carve_cube three times. Write it just once. We can reuse it, sending in different cubes.

This doesn't change Carvey's work. It doesn't matter which cube it gets, it always does the same thing: carve it.

The same for paint_egg. Write the code once, call it three times, passing in a different blank egg each time. The same thing happens for each egg. It gets painted.

Big productivity win!

Businesses care a lot about cost control. Functions are the main cost control tool in programming.

Writing the program from scratch

When someone gives you code and explains it, you might think:

"Yo, I got that, dawg. No worries."

Writing it yourself is harder.

Say you had to write the entire program for the ghosts. Where to start?

The biggest problem with programming is programs get too big to think about all at once. Here's the code again.

How many lines? One, two, three... a lot. Brains are good at many things, but keeping track many of details at once, not so much.

Here's the trick:

• Break a task into chunks
• Do one chunk at a time

Here are three developer ghosts. Pinky, Blocky, and Gothy.

Let's have the Pinkster write the program. We'll get to the others later. Let's listen to Pink's thinks. You can do that with ghosts.

- - ENTER GHOST BRAIN SCAN MODE - -

- - EXIT GHOST BRAIN SCAN MODE - -

Write programs like your bromigo Pinky. Write the main program first. It has calls to functions. Then write the functions.

The other ghosts

There were other ghosts:

Let's say they're part of the same team, with Pinky in charge (not a good idea, but that's the way it is). Instead of Pinky writing the entire program, they're going to work on it at the same time, to get it done faster.

The goal: each ghost writes part of the program. They work on the same program at the same time, with each ghost working on different parts of it. They put the parts together, and the whole program works.

For this to work, they need to coordinate their code, so it will all fit together. Functions make that possible.

Let's listen in on a planning meeting.

- - MEETING BEGINS - -

- - MEETING ENDS - -

Blocky knows to write a function called carve_cube, with one param in, and one value out. As long as Blocky does that, its code will work with the rest of the program.

Gothy knows to write a function called paint_egg, with one param in, and one value out. As long as Gothy does that, its code will work with the rest of the program.

A function's name, params, and return type are called its signature. As long as everyone knows their functions signature, and what their function does, the can all work at the same time. When everyone is done, Pinky can assemble all the parts together to get a working program.

What's next?

Leave ghost world for now. Let's see a more humany explanation of functions. Reading different descriptions of the same thing helps your brain make a complete picture.