Order to teach looping constructs in a non ideal language

Question

In an ideal teaching language

If the language directly supports them then the order to teach looping constructs seems simple.

• Infinite loop: forever.
• Simple finite (bounded) loop: repeat n times.
• Bounded loops: for i in list or for i = 1...6 (I am not sure which order these two should be in).
• Simple unbounded: while condition
• Complex loops: all the rest.

However often the teaching language does not directly support these. This may be an argument for choosing a different language for teaching programming.

The problems that I am having

(I am teaching in Python).
I was teaching in the order I outlined for an ideal language, but are getting problems.

For an infinite loop we use while True in Python, however students ask or struggle with this. I can not explain it without explaining while condition. So pupils have to hold something that they do not understand in their head.

Similar for repeat n times in Python it is for n in range(5):, this is a lot to keep in ones head without understanding.

The question

So the question is “what to do?”. Do we start with

• Bounded loops: for i in list:
• Bounded loops: for i in range(n):
• Simple unbounded: while condition:

Or do we do it some other way?

Answer 1

I prefer to teach while loops as part of my unit on if/else statements since the syntax and thought process are virtually identical.

I then introduce for loops when teaching lists (in Python) or arrays (in Java). With for loops, language impacts which style you likely use first. With Python, I use the for item in list structure first. In Java, I use the C style (for i=0; i<...) loop first.

I don't try to introduce all styles of looping at once as I prefer to develop the concepts across units.

Answer 2

All of the IF and Loop structures are based on two fundamental operations: Test and Branch. The only difference between an IF-Else and a Loop of any kind is whether you branch downward or back to the top. On a flow chart this just knocks you in the nose: the only difference is the arrowhead on one line.

When something so varied and complex can be reduced to such simplicity, you know that it is a fundamental idea. Teach that idea first, and then show how it is implemented in all of the various structures as you introduce each one. Now your students understand that programming is not magic, it is not about memorizing incantations and syntax: it is about simple, logical analysis of a problem, exactly how people and animals have been breaking down problem solutions in to basic steps all along. There is nothing new or surprising here, and it need not be confusing.

With this understanding, your students can absorb new structures and languages themselves, knowing that it has to be simple underneath, because circuits are simple, and people are not really able to do vastly complex things without breaking them down in to steps. Test. Branch. Done.

Answer 3

While your ideal order makes sense, you really should try to plan the course based on the limitations of the language that you're working with. In this case, instead of thinking about the different conceptual loops, you should think about the different loop syntaxes that the language provides.

In this case, the order in @Bryan R's answer (if/else -> while -> arrays -> for) makes the most sense to me. Then, once you've finished teaching all the different sytaxes for loops, you can talk about how some loops are equivalent, for example:

a = 2
i = 0
while i < 5 do
  a = a*2
  i = i+1
end
# Ends with a == 64

is the same as

a = 2
for (i = 0; i < 5; i++) {
  a = a*2;
}
# Ends with a == 64

(also, see my answer to a different loop-related question about how for loops and while loops are really the same thing)

and then show them your ideal loops, because those are a far better way to classify different types of loops than based on syntax alone, but they won't be able to see the importance of that classification until they are comfortable with the syntax for the different loops.

Answer 4

Perhaps you are creating a problem where none exists. You seem to be assuming that looping needs to be covered all at once and all together, rather than distributed over some some longer range interspersed with other topics.

The two fundamentally different kinds of looping are definite in which the program knows how many iterations are necessary prior to the loop and indefinite in which it does not. Those two concepts can be taught back to back so that the essential concepts are there. The others can wait a bit. Looping over a range or list can wait until you teach collections, for example. Infinite looping can be taught as either definite or indefinite (while True:...) depending on your language.

I certainly would not choose a language based solely on its direct syntactic support for all of the possible loop forms. Most of them are excluded, in fact, to keep the number of keywords in a language to a reasonable number. Once the language is Turing Complete things can be built using idioms of the language and a student needs to become familiar with that idea (idiomatic programming) in any case.

In any case, looping, like everything else should be taught in a Spiral framework in which ideas are introduced correctly but incompletely early on and then returned to, reinforced and expanded later on. This is useful when teaching programming since languages are themselves recursive and so difficult to teach strictly linearly. But a Spiral pedagogical technique is also essential due to the way the mind works and the way people learn - via reinforcement and repetition.

Therefore simple ideas of looping can come early and more complex ones later. The level of explanation changes, since the early, simple, explanations fertilize the ground for the later ones, both expanding and deepening the knowledge. Spiral is one of the fundamental Pedagogical Patterns.

Answer 5

For an infinite loop we use while True in python, however students ask or struggle with this. I can not explain it without explaining while condition. So pupils have to hold something that they do not understand in their head.

Could you restructure this to something that makes sense to your students in plain English?

Something like:

programShouldRun = True

while programShouldRun:
    doStuff()

Call your boolean variable whatever makes sense in the context you're working in, whether that is programShouldRun, answerNotFound, fileStillHasLines, etc.

Answer 6

I only ever taught my fellow students but this method was the one that everyone seemed to get.

There's a track, and there's a runner, he's running forever. When you type that while in, you're telling him to do something while he runs. Then you put a condition near the while, which is almost the same thing as a hurdle that is put in on the track. The runner has to pass this hurdle each time he completes one lap around the track, that's your loop. Your loop has to pass this check every single time it starts.

Then I give an example:

While (People are watching)
    Run()

The runner will stop after all the spectators have stopped watching him at the start of the next loop. He will get to the hurdle and notice that nobody is watching him and he will lose all motivation and then fall over.

Now if we want to tell the runner to run forever, we just have to make the hurdle so low that it can't possibly be false:

While (You are running)
    Run()

This is the same thing as the following:

While (True)
    Run()

Of course, this isn't formatted for python or anything else, you can modify this to suit whatever coding language you're teaching.

I hope this helps someone.

Answer 7

Maybe you could use physical objects to help students visualize how to utilize these loops.

For example for the bounded loops: grab 5 apples, label them with some number, and show how you go through each apple (e.g., bite each of them one at a time).

For the simple unbounded, try this: put a set of brand new apples on the table, ask if there are any of them that haven't been bitten yet. If so, then bite one, then ask again and bite another non-bitten apples until all of them are bitten.