I will have my new incoming CS freshmen (HS) for a week-long summer orientation in August. The kids don't know each other yet, so Ice Breakers are in order! Has anyone encountered fun, physical CS-themed games for helping kids to loosen up and get to know one another?

Criteria: the students are not required to come in with any background, though they will be learning some very basic programming concepts over the course of the week that we see them. Ideal games would either directly expose kids (in a non-technical way) to CS concepts, or could be referenced later (days, weeks, months, or years) in lessons to help explain concepts down the line.

Answers where you have direct experience with the game (and can vouch that it is fun!) are doubly appreciated.

  • $\begingroup$ Would you be interested in non-physical games too? I have a few activities + materials from a week-long summer orientation for college freshmen, but mostly in a seated group work format with Peer Instruction style discussion. $\endgroup$ – nova Jul 18 '17 at 15:31

Get them to line up (preferably on a wooden gym bench), then get then ask them to get into alphabetical order. You can use this to help learn names, and to introduce sorting algorithms.

I could also recommend CS-unplugged, it is part of the computational thinking, so aimed at very young pupils (primary school < age 11years old), but can also be used with older students.

  • $\begingroup$ Great ideas. The first one also helps the teacher learn the names. $\endgroup$ – Buffy Jul 12 '17 at 22:09
  • $\begingroup$ Also birthdays and home cities. If you have enough students in the class (roughly 25) two of them will likely have the same the same birthday which leads to one kind of interesting conversation, and then sorting by distance gets into another. $\endgroup$ – Dave Kanter Jul 13 '17 at 20:35
  • $\begingroup$ @DaveKaye With 25 pupils you only have a 58% probability of two sharing a birthday. $1-\prod_{i=0}^{25} (1-i/365)$ or 1 - reduce(lambda x, y: x * y, [(1-i/356.0) for i in range(25)]) $\endgroup$ – ctrl-alt-delor Jul 14 '17 at 16:20
  • $\begingroup$ Sounds to me like a great opportunity to discuss the Birthday Problem, no? That's much more my point. $\endgroup$ – Dave Kanter Jul 14 '17 at 16:38

David Levine and a few colleagues at St Bonaventure developed what is called the First Day Role Play that sounds like what you want provided that your course will have OOP elements. They have a paper on it in the ACM Digital Library, I believe.

There is also a large movement in Computational Thinking that is directed mostly at youngsters to help them think computationally without programming. Some of their activities might be useful to you. https://www.cs.cmu.edu/~CompThink/

The song/poem There was an old lady who swallowed a fly mentioned in the recursion analogy page is another possibility.


A fun exercise is giving the teacher directions to, say, get to and open the classroom door. Of course, the teacher must act like a computer. My engineering teacher did this and it was rather entertaining because one kid forgot to tell him to stop at one point. Another fun exercise in this vein involves having the students tell you how to make a PB&J.

Another cool thing is having them play with a robot or major project past years have done - that excites people, even if it isn't super CS related, and provides them with a taste of the awesomeness of your class =)

  • $\begingroup$ +1000 for the pbj game. Google "peanut butter jelly instructions challenge" or "exact instructions challenge" for a ton of fun results and videos. Honestly this process of breaking things down into smaller steps is probably the most important skill in programming, so introducing it as early as possible (in a fun way) is a great idea. $\endgroup$ – Kevin Workman Jul 18 '17 at 23:18

Another game that comes to mind is Nim. It has a lot of interesting variations, and I particularly enjoy the subtraction game.

In the subtraction game, you start at N and two players take turns subtracting 1, 2, or 3 from the total. The goal is to force the other player to remove the last number.

For example, you could play against the whole class. Let the students pick a starting number (let's say 11). You take away 2, so the total is 9. The students take away 3, so the total is 6. You take away 1, so the total is 5. Students take away 1, so the total is 4. You take away 3 so the total is 1. The students lose! Play a few rounds, letting the students choose the starting number each time.

There is a trick that makes this game very easy, but it's hard to spot if you've never seen it before. Students will realize that they can't win if it's their turn and they have 5, because no matter what they pick you'll be able to leave them with 1 in your next turn. Can they extrapolate and realize that they can't win if they have 9, because you can always leave them with 5? What number allows you to force them to 9? (Hint: the trick involves modulo.)

I like this game so much because you can use it to talk about basic AI topics. For example, you could start by creating a program that plays against a human player by just choosing randomly.

Or you could take the modulo trick and create a program that plays a perfect game each time. Or you could add variation by adding some randomness to the computer's choices instead of always choosing the correct answer.

A more advanced example is a program that solves this using weighted averages that it adjusts after every game (so it "learns" from experience and thinks about the game in the same way humans do: it can "know" that 5 is bad without "understanding" the underlying trick).

You could then make this AI program face off against the perfect computer player. The weighted average computer will "learn" pretty fast. Compare this to what happens if you make this AI program face off against the randomized computer player. The weighted average program will have a much harder time against the randomized player!

Anyway, Nim is a simple game that you can easily play against students, gives them a fun "ah-ha!" moment, and leads pretty naturally to more advanced topics.

  • 1
    $\begingroup$ I have also used Nim as a get-to-know-you activity to good effect. Students were randomly split into groups of 4. Within that group of 4, each possible pair played each other 3 times. I used the version where you draw out tick marks, but the subtraction version seems great too. After everyone played all their rounds, I led a discussion about what students thought was an optimal strategy for the game. $\endgroup$ – nova Jul 19 '17 at 2:01

The board game "Robo Rally", published by Avalon Hill, is good for getting people to think about simple programming as well as being fun for up to 8 players.

The basic idea is to navigate robots around a factory, with a limited set of instructions, such as move forwards n, rotate left/right etc. There are traps and walls, as well as other robots that you have to contend with.


You could have them act out Fizz Buzz.

Players generally sit in a circle. The player designated to go first says the number "1", and each player thenceforth counts one number in turn. However, any number divisible by three is replaced by the word fizz and any divisible by five by the word buzz. Numbers divisible by both become fizz buzz. A player who hesitates or makes a mistake is eliminated from the game.

Make it more interesting by adding rules as you go: multiples of 7 become bang, for example.

This will also allow you to introduce a program that executes Fizz Buzz when you teach about loops.


The ice breaker used in my school is a brainstorming:

Each student throws in something they know about computer science. They each say their names and what they know. It's very important to explain that it's good if some students know some things, but it's not the goal. Make absolutely sure no student feels bad that he\she doesn't know anything about cs.
To do this, you can say "Hey, it's great that you don't have background! Why? because you are here to learn".

This way, students know the names of other students, and also they know names of stuff in computer science. It's introductory in both senses.

It's not so much of a game, but it can be made into one:

  1. Each students is assigned an index.
  2. Each student gives their name and knowledge $\,\,\,$(does this count as alliterative?)$\,\,\,$
  3. A random number generator gives the index of the next student in the "game".
  4. repeat steps 2-3 until a fine dough until all students are familiar with each other.

you can mix it up a bit $\,\,\,$(I'm sorry for the cooking recipe jargon in this last part)$\,\,\,$ by changing what students say when their turn comes. They can possibly give their favorite color and something they know about CS. Pairs of <? extends PersonalInfo,? extends CSBackgroundInfo> are usually a good way to go about this.


Although I frequently use a variation on the TV show Jeopardy as a review of terminology later in a course, with everyone serving as contestant, it could be adapted to your needs here. One of the things you would like to know is the current state of knowledge of your students.

One of the things you may do when teaching is motivate the study of a new topic by using analogy/metaphor for various technical issues. I envision a Jeopardy game in which the Answers are various social memes and real life situations for which the student "contestants" think up questions. This can be fun, building some sort of "We are the Champions" mindset in the whole class, but also gives you a sense of what will work later and what might not.

Building the software to support such a game is pretty easy as it needn't be very sophisticated. However, thinking up the "Answers" requires time and thought in this case. You might be able to find supporting software for Jeopardy online as it is a fairly commonly used educational tool.


Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.