30 Minute - Awesome Algorithms (1-12)

Description:

This segment is intended to show that the same task can be completed many different ways, with some methods being better than others. We'll learn about algorithms, including their speed and efficiency by making butter & banana sandwiches as well as sorting students and finding the most efficient way to fold paper!

Supplies:

Butter & Banana Activity:
        6  slices of bread (some may get destroyed)
        2 bananas
        1 tub of butter
        1 plastic spreading knife

Folding Activity:
        1 piece of construction paper per group
        1 piece of pre-folded paper for demonstration

Sorting Activity:
        8  pieces of paper with ascending numbers (sequential or random)

Outline:

This is a very important lesson for allowing the students to see that correct answers are not always "efficient" answers.  To get the concept across, we will sneak the idea up on them. Begin by telling the students that this is a very special day.  We're going to do some activities and try to guess what they all have in common.  First, a little snack.

Butter and Banana:

This is a classic exercise, which is usually done with peanut butter and jelly.  In our school system, we are increasingly finding that children have peanut allergies (even to the touch) so we have adapted this for butter and bananas.
We want this activity to show students the importance of being clear with their instructions. Knowing how to accomplish a task is not sufficient when that idea must be communicated with a machine. How might one translate thoughts into something that a machine is sure to understand?

Here, the instructor will seat the class in front of them, presentation style.  The instructor will then spread all ingredients out, and ask if anyone knows how to make a butter and banana sandwich.  Inevitably, several hands will go up.  If no hands are raised, ask if anyone knows how to make a sandwich at all, or if anyone is willing to give it a try. 

When your first volunteer comes to the front, have her sit with her back to you (preferably behind you, with her back also to the class).  If you have the volunteer sit with her back to you while facing the class, the class may give her cues that help or hinder the process.   

Now that your volunteer is situated, have her explain how to make a butter and banana sandwich.  As the instructor, you will do your best to take her literally, messing the sandwich up intentionally when the instruction is ambiguous.  As the first volunteer, she will probably be quite general, leaving several steps to the imagination. Here is an example of how it could go, and how the instructor might react:

Volunteer Says	Instructor Does
Pick up the bread	Lift the whole loaf (or plate) of bread
Put butter on the bread	Lay the tub of butter on top of the bread stack
Cut up the banana	With peel still on, cut the banana in half
Put the banana on the bread	Place an entire half of the banana on the stack of bread
Put the top on the sandwich	Use the top of the butter tub to complete the stack

One might think they see how this is going, but students are often full of surprises. The second and third volunteers usually make huge improvements. The limiting factor to this is generally the bananas, which I will cut in half (either as part of the first try, or purposefully) to get more milage.  In the end, I generally cut the successful sandwiches up and allow the students to have a quarter-piece.  You can use your own judgement on that!

Once the activity has wrapped up, ask the students what they learned. Help them see that giving instructions to a finicky teacher is an awful lot like programming a computer. The coder may think they know what they want the machine to do, but if their instructions are ambiguous (or unclear, or incorrect) then they may end up with a surprising result.

Folding for Fun:

With this careful and clear attitude in mind, gather students into groups of 2-4. Give each group a piece of paper, and show them an example of what they're trying to make.  Illustrate with your paper how the creases divide the paper into 16 squares.  DON'T FOLD IT FOR THEM AT THIS TIME. Just show them the end result once it's been re-opened, and ask them if they can figure out how to re-create the look.  If you feel it's necessary, you can provide each group with a paper that has been folded and opened, so they can inspect it as they go.

Give the class about 5 minutes to re-create the fold.  If you see they have finished sooner, you can regroup at any time.  Once the class has come back together, ask if anyone wants to share their folding method.  Once they have, ask if any other groups have done it differently.

Send the students back to their groups to try again.  Challenge them to find as many ways to fold the paper as possible.  Have them try to keep track of all the different ways there are to fold that one piece of paper into the specific shape required. After about 10 minutes, gather them again and ask them how many ways they came up with.  Try to find the group who came up with the most methods.

Ask the class what the most number of folds was that they were able to fit in.  Then, ask what was the least number of folds that they could manage for the same pattern.  Does anyone think they can beat either of those numbers?

Follow up on this activity by discussing the idea that the exact same thing can be accomplished with more or less work depending on the method that you use.  Can your students think of any other place that this is true?

Sorting it Out:

This exercise can be as simple or complex as your class can handle.  If the students are young just explore different ways to sort numbers without getting into how fast or slow the methods are.  With older students it's a good idea to go through the specific algorithms and use the algorithm names so that students can get ready to use the methods in coding activities.

Ask for 8 volunteers. Have your volunteers come to the front of the room and line up shoulder to shoulder facing the class.  Give each student a number picked randomly from a pile and tell them to hold it in front of them.  Let the class see that the numbers are all mixed up. Ask one student to come to the front to help you sort. 

Ask the student to describe how she would sort the numbers if she was asked to do so.  Often, the first volunteer will describe a method that requires human help ("I'd take the littlest one and put it there, then move this one between these two where it belongs...") In that case, it's a good idea to explain that a computer can only inspect one list item at a time, which means that it can't observe order without first going through each item individually and storing information.  If a demonstration is necessary, describe a simple algorithm, like Insertion Sort, Simple Sort,  or Selection Sort.


Insertion Sort

Selection Sort

Now, have the student try sorting the group using insertion sort or simple sort.  Does the class have any other suggestions as to how the list could be sorted without going through the line directly from start to finish in just one go?  As they suggest ideas, try to relate their discoveries back to algorithms that are fairly standard, such as:

Bubble Sort



Merge Sort



or Quick Sort


If your students are old enough to understand powers (at least what it means to square a number), you can take this opportunity to compare how quickly each algorithm sorts  a list of numbers.

Start with a list of three. There probably won't be a difference in how long each takes at all.  On a list of five, you may see a slight difference, but attempt to sort a list of eight students and see what happens!

What you will have stumbled upon is called the "complexity" of an algorithm.  Essentially, that means that you can expect any given algorithm to perform at or below a certain number of steps, depending on the specific items being operated on.  In our case, we can expect Insertion Sort to never take longer than it takes to compare each item to every other item in the list, for as many times as there are items in that list.  That is to say, if there are X items in our list, we will compare each item to fewer than X other items, X (or fewer) times. Altogether, that's at most X*X steps, which is equal to X². We call this "Big-O of X²".

Mergesort, on the other hand, still compares X items, but it only has to compare each item to about half of X each time through.  That means for each item of the list, you're comparing to about half the items of the time before.  This constant chopping in half is estimated to be a maximum complexity of "log X".  Therefore, the complexity of Mergesort  is "Big-O of X*logX", which is better than X².

If you're running short on time, just allow the students to see that some perform better, some perform worse, and some are pretty similar...but they all do the same thing in the end!


Here's an example comparison:

Helpful resources: 

Graphic Sorting Algorithm Animations
Sortlab Applet

30 Minute - My Robotic Friends (K-12)

Description:

Using a pre-defined "Robot Vocabulary" your students will figure out how to guide each other to accomplish specific tasks without discussing them first. This segment teaches children the connection between symbols and actions, as well as the invaluable skill of debugging.
Note:  This works best as an entire group activity for younger children (K-2) and a small group activity (3-5 students) in the older grades.

Supplies:
6 Paper or Plastic Cups/Group
1 Robotic Instruction Packet/Group
1 Blank sheet of paper/Group



Outline:

As the instructor, you will begin by thanking the class for letting you come visit. It is very important that the instructor be pleasant and up-beat.

Start by covering the importance of Thinkersmith's three pillars of responsible computing. From there, you will want to ask the class if anyone has ever heard of robotics.  Has anyone seen a robot or touched one?  Does a robot really "hear" you speak?  Does it really "understand" what you say?  The answer is: "Not the same way that we do."

Teach them that, when it all comes down to it, robots operate off of "instructions", a specific set of things that they have been pre-programmed to do.  In order to accomplish a task, a robot needs to have a series of instructions (called an algorithm) that it can run.  Today, we are going to learn what it takes to make that happen.

Here is a list of symbols that our "robot friends" are able to do.

A more simple way of writing the
symbols in order to speed up "programming".

(Do these for them as you read each one.  Make sure you've practiced in advance so that you don't lock them in to an action that's too limited.  Use as much of a liberal definition as you believe is appropriate for your age group.)
Make sure you have your plastic cups in a stack on a nearby table.

1.) Pick up cup - Show them what this looks like
2.) Put down cup - Put your cup back down
3.) Turn Right - Turn the cup clockwise
4.) Turn Left - Turn the cup counterclockwise
5.) Step Forward - Move the cup one "step" to the right
6.) Step Backward - Move the cup one "step" to the left

It can be helpful to specify that one "step" for the robot is actually one half width of a cup. So, in order to set one cup down beside another, you will need to move it two "steps" before you put it down.  Remember to "step backward" all the way to the cup stack before you ask them to pick up a new cup!

If your student asks about rules that haven't been defined, you can either define them according to your exercise, or ask them to define that rule within their group.

Now it's time to go over an example with them.  I will usually have them help me come up with an algorithm to make the first structure shown in the Robotic Instruction Packet using just three cups.  I'll use that time to make sure the rules are completely clear and that they understand what the job of the group is and what the job of the "robot" is.  It helps if you require them to write their algorithms out before they tell it to their "robot".

This is where we need to get creative.  Once you have handed out a "secret card" (in the form of a picture of the cup stack that they will be making) you cannot let the "robot" see it!  It becomes necessary to have the robots away from their groups.  I will usually make a "robot library" at a separate table, where the robots can all stand with me and practice the steps while they're waiting for their group to come "check them out".  Once the group has a decent algorithm written, they can come show it to me and I will allow their robot to go back to their group area to try it out.  They are welcome to revise non-working algorithms either with the robot around, or after "checking the robot back in" to the library.

After a successful stack, I have begun to gather the groups back together to ask about the complexity of indicating that a cup has to move 6 steps, or 8 steps, or more.  I point out that often, the instructions for

• Pick Up Cup
• Move Forward x Steps
• Put Down Cup
• Move Backward x Steps

are packaged together.  We then work to create a new symbol that can stick these all together, removing some of the monotony of programming.  The symbol that I chose usually looks something like this:

Where the number indicates how many steps you move before you put the cup down.  The teams are usually *extremely* relieved to have this new "function" as we proceed with more difficult stacks. 

Be sure to identify what we just did as creating a "function" to replace code that appears multiple times in our program.  If the class is particularly enthralled, you can also identify the number portion as the "parameter" or "input" to the function.

It's time to send a new robot to the library and work on algorithms for more difficult stacks!

This can continue until everyone has had the chance to be a robot, or until time runs out.

30 min - Fun with Functions (K-12)

Use posters to represent functions

Description:

This segment is intended to show one of the many benefits of using functions, namely how much easier it can be to use functions for repetitive tasks.  Students will follow an algorithm to make a chain for their backpacks, utilizing no fewer than two functions along the way.

Kindergarten through 2nd modification: Young children sometimes have a problem tying knots, so we modify this exercise into making bookmarks with stickers.

Note:  We have discovered that students as old as 8th grade are having a difficult time tying knots.  If you are in doubt as to whether your class has that ability, please take a moment to test their skills by having them tie some string around a pencil.  If more than a quarter of the class is unable to do this without help or demonstration, this lesson may take 50 minutes rather than the original 30.

Supplies:
3 large sheets of paper, sectioned off for 8.5x5.5 rectangles or
1 printout for document camera

4 each of 8.5x5.5 K-2 symbol sheets or 3-12 symbol sheets


Kindergarten through 2 -
1.5" x 8.5" strips of cardstock/chipboard (1/student)
1" glue-on or sticky-back squares in black and white (8 b&w/student)
    * You can use strips of contact paper, or
        simply have kids glue squares of construction
        paper to their bookmarks.

Third through Twelfth -
Cording (1yd/student)
Pony beads or Hex Nuts (4/student)
Jewelry Rings or washers (4/student)


K through 12 adaption* -
Pipe Cleaners folded around rubberbands (1/student)
Pony beads or Hex Nuts (4/student)
Jewelry Rings or washers (2/student)
Fancy Buttons (1/student - Optional)


Outline:

As the instructor, you will begin by thanking the class for letting you come visit. It is very important that the instructor be pleasant and up-beat.

I like to hand out supplies for this exercise in advance.  That way, the kids can make the connection between the images that they see on the screen (board) and the items that they'll be using.  For kindergartners, supply timing is highly dependent on the nature of the classroom.

Place the three over-sized sheets of paper on the board.  If you have a document projector, you can use this alternate layout.

Explain that the center area is where we put the "directions" for the "program" that we'll be following (when working with the lower grades, you can pretend y'all have been turned to robots).  Tell them that at the end of the lesson, you will all be following these directions -- called an "algorithm" -- to make your craft.

Give them this scenario:
"We are all going to be machines who make these expertly-crafted bookmarks (or zipper-pulls).  But since machines don't think on their own (yet) the robot director must first spell out their instructions in the language that they understand.  For us, that language will be these symbols:"

Symbols from kthru2symbols.pdf 

or

Symbols from 3thru12symbols.pdf 

"As robots, we will do what is on this 'program' grid and see what we come up with! To start, we want to put glue on the top of our bookmark, lay down a black square, then move down to the next section. That would look like this:"

1) Glue 2) Black square 3) Down

"But what if we wanted to do: glue, black square, move down, glue, white square, move down? We'll have to add more symbols:"

1) Glue 2) Black square 3) Down

3) Glue 4) White square 3) Down

"And what if you want to do:
glue, black square, down, glue, white square, down, glue, black square, down, glue, white square, down? We don't have enough slots for that!!! And we need to do the 'glue, black square, down, glue, white square, down' sequence FOUR times to finish our bookmark."

At this point someone might remind you that you have two more pieces of paper...labeled f1 and f2. If they don't, you can pretend to discover it yourself. Tell the students that these pieces of paper are special. They are called "functions" and they allow you to save a complicated or repeating sequence all in one place, so that you can call them later simply by using the function's name as a symbol.

Ask the students if they see any steps in your program that repeat. They may point out the entire "glue, black square, down, glue, white square, down" sequence. If that's the case, go ahead and start with all of it in f1 and ask them what they should put in the program to let the robots know that they have to look in f1 for the sequence of bookmark making. Once they understand that (or if they go straight to saying f1=glue, black square, down and f2=glue, white square, down) you can separate the sections into the two different functions and ask them how to get the ideas across to the robots *now*.

Walk through the program with them a few times. Tell them that you will be the "program counter", pointing to where you are. Each time you reach a slot in the program that has a function name (f1 or f2) in it, hop over to that function's piece of paper and go through the steps listed on it, calling the symbols out as you touch them. Once the entire class is chanting with you, it's time to actually make your bookmarks together, while following the patterns.

The above scenario was obviously for the lower grade level, but the majority of it stays the same for the older students, just replaced by "tie, tie, bead" and "tie, tie, hoop". If your older students are getting the ideas rather quickly, you may have time to mix things up by placing an f2 call inside f1 at the end. They should see that this automatically calls f2 when f1 has finished.

What happens when instead of calling f2 inside of f1, you call f1 inside of f1?!?! That's called "recursion"...which comes from the word "recur" which means "to happen again". So calling the function inside of itself makes it happen again, then that call makes it happen again, which makes it happen again! Recursion could be dangerous!

Act as the program counter one last time while you walk the class through each of the steps to finish their zipper-pulls (or bookmarks). Congratulate the children as they finish their crafts and let them know that they just learned one of the most handy things in computer programming! Functions!

* I recently found a solution for those who have difficulty tying.  

Before the lesson, I fold a pipecleaner around a rubberband for each student.  

From that point, they only need to slide the beads up one side of the wire and twist to keep them on.  

Space is limited, so we only use one hoop per cycle.  


At the end, we add a button (the kind with the loop on the back) and roll the end up like a little snail to keep the wires from getting pokey.

30 min - Binary Baubles (K-8)

Description:

Students learn about representing numbers and letters in binary, as functions of on and off. At the end, we'll make magnets or bracelets with the students' initials in binary for them to take home.

Kindergarten Modification: Students will make bead & pipe-cleaner bracelets instead of refrigerator magnets.





Supplies:

ASCII Poster
Power Button Pictures
Picture of Computer Insides
Dissected Hard Drive or Picture

Kindergarten - 
Bit-Shelf
4x6 paper in B&W
Pipecleaners (1 per student)
Pony Beads (8 of each in B&W per student).

Higher Grades - 
Display Grid
Duct tape squares
1" squares of quad graph paper (1/student)
1" self-stick epoxy resin square (1/student)
1" strip magnet square (1/student)


Outline:

As the instructor, you will begin by thanking the class for letting you come visit.  It is very important that the instructor be pleasant and up-beat.

To warm up the room, the ask: "Who has seen a computer?"  This question gets the room buzzing and helps the children quickly gain a sense of confidence that they are already prepared for the lesson ahead.  In a few cases, there will legitimately be children who have *not* seen a computer, especially in kindergarten.  In those cases, don't overly praise those who have, but otherwise proceed in the same manner. Ask the following set of questions to get everyone's mind on the same page:

1)  Is a computer an animal?
Almost every child will say "no".  Shake your head and acknowledge that a computer is, in fact, not an animal.

2)  Is a computer a vegetable?
Children should be yelling "no" more confidently now.  Imagine having your parents telling you to "finish your keyboard or there will be no dessert!"

3) What *is* a computer?
At this point, children should be eagerly raising their hands.  You don't need to seek out a "correct" answer here, but listen to the types of answers they give you.  The farther away from correct that they are, the more likely it is that you're going to need more time at the end to help with the technical part of the activity.

Bring children out of the question/answer session by confirming that a computer is a machine.  Ask what they think they would see if you opened a computer up?  Are there magical monkeys inside?  Rocks with special powers?  No, but there *are* lots of cords and circuits which carries electricity from place to place. Tell them that a computer relies on electricity (through a cord or battery) to work correctly.

At this point, pull out SWITCH.PDF and show them page 1.

Ask the students if they've seen a switch like this before.  They will probably offer up some places that they've seen switches like that, or argue about the shape and color.

Share with them that this is an "On/Off" switch.  Describe how pressing the "1" turns electronics ON and pressing the "0" turns them off.  Ask them if that makes sense, and to really hit the point home, ask what position the button is currently in.  What would we do if we wanted to turn it off?

Next, show page 2 of SWITCH.PDF and ask if anyone has seen a button like this.  This one happens to be from an Xbox, but they may have seen one on their home computer or even in a fancy car.

Have them look really closely at the symbol in the middle.  Can they tell what it is?  It's a 0 with a 1 in it!  That's right, this button can turn something both on AND off by pushing in the same place.  Cool, huh?

If you feel like you will have time, you can show them a hard drive and explain how computers send on & off signals to magnetize and de-magnetize sectors.  Let them know that *that* is how information is preserved and not by saving words in English, Spanish, or pictorial form.  There is a benefit to having a physical hard drive for showing-off, in that you can really let the students see that there's no paper to write on and no compartments to "store" stuff.

Now that children get the relationship between 0&1 and on & off, tell them that you are going to introduce them to a special secret code, called "ASCII", that computers use to save and transmit information.  At this point, you can either project this ASCII.PDF onto the screen, or hang a printed poster version of it (I prefer to do both).

At this point, I like to ask if we have any "secret agents" in the room.  It puts a playful and adventurous mood into the atmosphere. Once the poster is displayed, explain to the room that the black squares are "off" and the white squares are "on".  Tell the kids that each letter is made up of eight squares (which we call "bits"), each is either on or off.  Let them know that a grouping of eight bits is called a "byte".  Chances are that several eyes will light up as they recognize the word.  You can help them along by mentioning "kilobyte", "megabyte", and "gigabyte".

The next thing we do is play a little surprise game.  If you're going to be making a magnet, start with an 8x1 grid of 2" squares and double-sided duct tape pieces (these are made by sticking the back of white tape to the back of black tape and cutting into 2" sections).

Tell the students that it's hard to demonstrate using an 8x1 grid, so you are going to move it to two rows and use a 4x2 - For this, you can cut the provided grid in half. This will help to prepare them for their final activity where they will be filling in squares on a 4x4 grid (I cut quad size graph paper into 1" squares for this activity).

For kindergarteners, you can demonstrate with beads on a pipe-cleaner (fuzzy wire stick).  I personally like to use a "bit-shelf" for large classrooms without a document projector.  It's made of foam-core board.  scored the long way, and folded into a pocket.  A couple of magnets in the back will secure it to a typical whiteboard.  I then indicate the bits with 4.5"x6.5" pieces of black and white paper.

In either case, you can show students how to represent the letter of your choice using the pattern on the poster.  Repeat as necessary.

Once you're comfortable that they're familiar with the method, tell them that you're going to leave the room while they choose their own letter.  Let them know that they have one minute to choose *and* have their teacher "code" it on the grid (or pipe-cleaner or bit-shelf).  Make sure it takes only about a minute, because you'll need the remaining 10 minutes for an activity.

Leave the room for one minute, then return.  They may, or may not, remove the ASCII poster.  To more easily guess the letter,  try to memorize 'P'.  The letter 'P' is the letter where the first nibble changes from 0100 to 0101.  That means you have a clean slate on the second nibble with 0000.  Therefore, 'P' is 01010000.  To figure out letters after 'P', you can ignore the 0101 and just translate the second nibble to decimal.  That way if they give you 0101 0011, you translate b0011 = 3 so they've chosen the 3rd letter after 'P', which is 'S'.

If the letter starts with 0100, there is a trick for that, too.  Invert the second nibble, translate, and count back from 'O'.  That means if they give you 0100 1111, you invert the b1111to b0000 = 0, so 0100 1111 is 'O'!  Along the same lines, if they give you 0100 0011, you invert b0011 to b1100 = 12, which means you count 12 back from 'O', giving the letter 'C'.  They'll think you're a mind-reader!

Once they have had fun trying out their coding/decoding skills, it's time to let them encode their own initials (I usually have all kindergarteners encode the same letter...maybe K?)  For those using a bit-board and/or fuzzy wire sticks, demonstrate the group's letter on the bit board for them, then walk around and help the class emulate it with beads.

For students making magnets, the process is just a bit longer.  Have each student choose their two favorite letters. Have them color the first 2 rows of their graph paper with the binary code for the first initial, and the second two with their last.  Let them know that mistakes are okay, and even if they mess up the letter that they were thinking of, the binary that they end up with does *something*.  This helps with confidence in getting started, and also helps conserve supplies by not re-doing items after a "mistake".

After the graph paper is colored, have them take one of the clear epoxy domes off of the backing and carefully stick it on to their graph paper.  Tell them to be cautious, because once it's on, it can't be peeled off without damaging their craft.

Finally, peel the paper off of the magnetic square and adhere it to the back of the graph piece.





Congratulate the students on a job well done and ask them if they had a good time.  This whole lesson should take around 30 minutes if you have an adequate number of room helpers (a teacher plus one?) slightly more if you are the only one available to troubleshoot during the craft.

Some Do's and Don'ts for Teaching CS

As we mentioned in another post, it *is* possible to negatively affect children by bringing technology into their lives too early.  This is partly because of the power that computers can have over a young life, but it is also due, in part, to intimidation factor.

When children are first introduced to computers, much of their attitude has been formed by their parents' technical comfort level.  Studies performed by the FCC indicate that nearly half of Americans are effectively computer illiterate.  That can increase the negative bias felt by their children.  Thinkersmith wants to be careful not to introduce young children to technology in a way that makes them feel overly frustrated or a sense of imminent failure.

When Thinkersmith visits elementary schools, we are cognizant of the reassurance that we hand out.  We praise valiant attempts at solutions, highlight solutions that didn't work (but teach the student how to step closer to victory), and remind children that learning through trial and error is essential to computational thinking.  While teaching, here are some of the ideas we try to keep in mind:


DON'T

• Don't lavish praise on students for being "smart".
  That can make nearby children feel inferior and indicate that success is attainable only for those who already have an intellectual label.  

DO

• Instead, try to point out how hard a child is working, or how focused they are being. Give credit for listening, persistance, and teamwork.  Praising an action, rather than a quality is a better way to encourage other children to adopt positive behaviors.

------


DON'T

• Don't take over a project for a child when they request help.
  Making quick adjustments or completing the "last few steps" for a student may be tempting for an adult on a time-crunch, but it reaffirms the notion that if a child gets stuck they can benefit from giving up.  Even worse, taking over a project can deflate an eager child's enthusiasm if they feel that they weren't understanding as quickly as you expected them to.

DO

• Offer suggestions in words.  Lead children to figure out the last steps on their own.  If the task is physical, encourage them to try it in several different ways to see if there is a technique that works better for them.  If they decide that they just "can't" do it, remind them that a positive attitude is the best learning tool.  If it starts to look like their project might go home unfinished, remind them that sometimes it's better to set difficult problems aside and come back to them.  Encourage them to take another look at it when they get home or over the weekend.

------


DON'T

• Don't let the students take over.
  Students love to ask questions and share their stories.  This can be a good thing, but it can also derail one of our short little lessons.  It's important that the kiddos stay on track and listen so that we can get to all parts of the lesson.

DO

• Encourage children to share their stories in writing or pictures.
  Once in a while, a child will claim to have a question and begin on a long, fluffy story.  You want to pull the class back on track quickly.  Try folding your hands in the steeple position (pointing or shooshing can be seen as aggressive), then interrupt the child with a line like "I can tell this story is going to be amazing and I don't want to rush it, since time is so short right now.  Would you mind writing your story down for me and having your teacher send it to me in the mail?" Take an additional moment to remind the class that you love it when kids put stories on paper and redirect back to the activity.  If a frenzy of hands continues, let the students know you will give them time for questions at the end.

------


DON'T

• Don't forget the quiet ones.
  Quiet and patient students rarely get tended to as quickly.  Because of that, we can easily reach the end of our time segment before we realize that they have a problem.  

DO

• Give students a way to ask for help discreetly.
  Sometimes students don't ask for help because they are embarrassed that they don't know what's going on.  You can ask if anyone has questions, but there are often children that won't raise their hands because they don't want anyone to know.  During complex activities, tell students that they can raise their hands with questions, or they can fold a piece of paper on their desk.  Giving students a nonchalant way of gaining your attention is the first step to letting you help build their self-confidence. 

The Three Pillars of Thinkersmith

Believe it or not, it *is* possible to negatively affect children by bringing technology into their lives too young.  Even still, our high-tech world is here to stay, and kids need to be equipped with some very important skills if they are to be prepared for the digital world ahead.

At Thinkersmith, we believe in introducing children to computer science as soon as possible.  As part of that position, we recognize that it has to be done in a safe and balanced way to prevent negative consequences.  If computational concepts are presented too ambitiously, it can effectively frighten students out of computer science altogether.  If it is presented with careless frivolity, it can entice children to a life of screen-dependency, causing their real lives to suffer.

Proper education in computer science and computational thinking must be done with a great sense of responsibility to the future of our children and the future of humankind in general.  That's where Thinkersmith's three pillars come in:

1)  Balance activity with screen time:
Children can easily be sucked into the entertainment that comes along with computation.  If we intervene in one's life enough to introduce a student to technology, we must also educate them on the risks of living a sedentary lifestyle.  It is imperative that we teach children to spend no more time in front of a screen than they do running and playing.  At Thinkersmith, we like to encourage children to spend at least as much time in a given day running, skipping, jumping and hopping as they do looking at a screen.  We encourage outdoor play and attempts to solve problems with real-life tools whenever possible.

2)  Balance environment with technology:
It's no secret that gagets take up a lot of electricity.  Technology necessitates the consumption of additional resources as well.  For this reason, Thinkersmith encourages our students to unplug.  We teach children to shut down and unplug their computers when not in use.  We also ask that they turn lights off when they leave a room and actively recycle.  In truth, we believe that users of technology need to do whatever they can to reduce, reuse & recycle, in an effort to offset the extra footprint that tech creates.

3)  Balance philanthropy with self-benefit:
Sure, computer scientists have the potential to make a lot of money.  Government projections indicate that this will be the case for decades to come. While some people may use this as a platform to leverage personal gain, Thinkersmith encourages children to give back, every chance they get.  We promote open-source coding, paying-forward computer science education, and volunteerism.

Thinkersmith truly believes that by engraining these three principals into our students, we will have a much higher national rate of success than we would if these areas were neglected.  We encourage you to keep these ideals in mind as you teach, for *whatever* you teach, as a way of maintaining responsibility for the wellbeing of your students' futures.

Introduction

Welcome to Thinkersmith's Traveling Circuits!  Here, you'll find projects, materials lists and demos for the Traveling Circuits classes.  Thinkersmith takes these activities on the road to introduce large groups of kids to computational concepts in a very short period of time.

These activities currently range between 30 and 50 minutes, and are designed to be simple, inexpensive and unintimidating.  Give these activities a try with your classes.  They're a ton of fun and everyone comes away with something new!