Putting the Pieces Together

Lesson 8 · taught by Pip

Here is the plain idea: the building blocks you've met don't work alone. A real program weaves them together — a variable holds a value, a conditional checks it, a loop runs over a list, all bundled inside a function. Watching them combine is where it finally clicks.

Let's walk through one small, honest example in plain words.

A grading routine, in plain English

Imagine a teacher with a row of test scores who wants the class average and a count of how many students passed. Here's the whole thing, told as steps.

We keep the scores in a list — one name, many values: scores = [88, 72, 95, 60].

We make a variable called total, starting at zero — an empty jar we'll fill. We make another, passed, also at zero, to tally the passing students.

We run a loop over the list: for each score in scores, we do two small jobs. First, add that score to total. Lap by lap the jar fills: 88, then 160, then 255, then 315.

Second, inside the same lap, a conditional decides: if the score is 70 or above, add one to passed; otherwise, leave it be. So 88 counts, 72 counts, 95 counts, 60 does not — passed lands on 3.

When the loop finishes, we divide total by how many scores there were — a bit of number arithmetic. 315 over 4 is about 79, the average.

And we wrap the whole routine in a function called grade_class, so the teacher can run it on any list of scores by calling that one name.

Look what just happened

Every block from this course showed up, each doing its one job:

• The list held the collection.
• A variable carried the running total and the pass count.
• Types mattered — numbers we could add, a true-or-false behind each pass check.
• A loop visited every score without us writing the steps four times.
• A conditional turned each number into a decision.
• A function wrapped it all under one reusable name.

None of these is clever on its own. The power is in the combination — small, plain parts arranged to do something genuinely useful.

The orchestra analogy

Think of an orchestra. A single violin is a simple thing. So is a drum, a flute, a cello. Alone, each plays a plain part. Arranged together, in the right order, at the right moments, they become a symphony.

Programming is the same. Each building block is simple. The craft is in the arranging — which value goes in which box, which question to ask, what to repeat, what to bundle. The blocks are the instruments; the program is the music.

And that's most of the game. Bigger programs are just more of the same, nested deeper: functions calling functions, lists of lists, conditionals inside loops inside functions. The parts never change.

Your turn

Trace the routine by hand with a fresh list: scores = [90, 50, 65].

Walk the loop three times. After each score, jot down what total and passed hold. Remember the pass mark is 70 or above, so only the 90 clears it. Then divide total by 3 for the average. You should land on 1 passed and an average of about 68.3. If you got there step by step, you just ran a program in your own head.

One last stop — where you go from here. 🔦