Leading family learning-by-making workshops in schools around the world is a pure joy. When parents can experience through the eyes, hands, and screens of their children what is possible, they demand a new more progressive educational diet from their school. I have now led three different family workshops at my favorite school in the world. The first one featured a wide range of materials, including: MakeyMakey, littleBits, LEGO WeDo, sewable circuitry, and Turtle Art. Twenty people RSVPd and more than one hundred showed up. The kids ranged in age from preschool to high school.

The next workshop was held the night before Halloween 2018. So, I selected a Halloween theme for our work with the Hummingbird Duo Robotics kits. A few minutes of introduction to the Hummingbird kit and the prompt, “Bring a Spooky ghost, goblin, or monster to life!” was all that was required for 60+ kids and parents to build and program in Snap! spooky creatures in less than ninety minutes.

Last week’s workshop was the best yet. An invitation for thirty grade 3-6 kids and parents to attend a family learning-by-making workshop sold out in no time flat.

Each of these workshops exemplified irrefutable evidence of the efficacy of constructionism and the limits of instruction. However, the most recent workshop possessed a special magic. Last week’s workshop was centered around the BBC micro:bit microcontroller development board. For $30 (Australian/$22 US), each kid would go home with the micro:bit Go kit they used during the workshop.

It is worth noting that while the hosting school has a long tradition of project-based learning and open education, it is not a high tech school and its facilities are not unlike many public primary schools. Furniture, room layout, and projector placement make instruction virtually impossible, even if I were prone to offer step-by-step tutelage, of which I am not. (Kids and parents were working in every nook and cranny of a library and in an adjacent classroom) Besides, the research project that is my work with teachers and students, leaves me convinced that instructionism, the notion that learning is the result of having been taught, is a fool’s errand. Piaget’s belief that “knowledge is a consequence of experience” is central to my work.

Parents brought their own laptops while other families used school laptops. The parents with personal laptops needed to use their phones for Internet access because stupid school Internet implementation doesn’t allow guest Web access. There were more than sixty workshop participants.

This is how the workshop began.


Hi. I’m Gary. This is the micro:bit. It has a 5X5 LED display that can be used to show pictures or display text. It also has two buttons that you can use to trigger actions. The micro:bit also has a temperature sensor, a light sensor, an accelerometer that knows if you move, tilt, or drop it, a compass, and ability to communicate between two or more micro:bits via radio. You can also connect LEDs, motors, buttons, or other sensors to the micro:bit via alligator clips, wire, or conductive thread  if you want to build robots or other cool stuff.

If you program in Scratch, the micro:bit can be used to control a video game you make by pressing the buttons or tilting the micro:bit like a steering wheel. You can even connect the micro:bit to a paper towel tube and make a magic wand to advance a story you program.

We will be using a Web-based programming environment, Microsoft MakeCode, tonight because it uses all of the hardware features of your micro:bit.

  • Go to MakeCode.com
  • Click on micro:bit
  • Click on New Project
  • Drag the Show Icon block from the Basic blocks into the Start block.
  • Select the heart shape
  • Now, we want to transfer the program we created to the micro:bit. The micro:bit works like a USB flash drive. Put a program on it and it runs until you put a new program there.
  • Click Download
  • Find the downloaded file you created, the one that ends in .hex in your downloads folder
  • Drag that file onto the microbic drive in your file explorer or Finder
  • Watch the yellow light on the micro:bit flash to indicate that the transfer is underway.

Voila! There’s a heart icon on your micro:bit!

  • Click on the Input blocks
  • Drag out an On Button blockChoose Button A
  • Make the program show you a Pacman icon when a user clicks the A button on the micro:bit
    Drag out another On Button block
  • Program the B button to Show String (some text you type as a message)
    Download your new program and copy it to the micro:bit

Heart displays

  • Click the A button and see Pacman. Click the B button and display your message!
  • Connect your battery box to the micro:bit and disconnect the micro:bit from the computer. Look!
  • The program runs as long as it has power!
  • Come get your micro:bit kit and a list of project ideas you might try.

90 minutes later, we needed to tell kids and parents to go home. (I am reasonably confident that I wrote more of my two minutes worth of instruction above than I actually said to the kids).

About 1/3 of the participants were girls and many boys were accompanied by mothers and grandmothers. There were plenty of Dads participating as well. Once one kid or family team made a breakthrough, I would signal that to other kids so they knew where to look or ask questions if they were struggling or curious.


Scenes from the workshop

Observations
Many teachers in workshop settings really struggle with the mechanics or concept of finding their downloaded file and clicking-dragging the file onto the micro:bit. Not a single child had any difficulty performing the process of copying a file from one drive to another. I have long been critical of the clumsy way in which MakeCode handles the process of downloading programs to the micro:bit and the way in which the Arduino IDE uploads programs to its board. The fact that upload and download are used arbitrarily is but one indicator of the unnecessarily tricky process. The fact that not one primary school student had such difficulty the first time they encountered physical computing makes me less anxious about the process.

Several kids were very clever and had working understanding of variables despite not having school experience with such concepts. This once again proves that when a teacher acts as a researcher. they discover that kids know stuff or harbor misconceptions . Such information allows for adjusting the learning environment, testing an intervention, or introducing a greater challenge. Some students had little difficulty constructing equations, despite the ham-fisted MakeCode interface. A few kids just wanted the micro:bit to perform calculations and display the result.

Conditionals proved equally logical to lots of the 8-12 year-olds. (It was interesting chatting with parent/student teams because it was often difficult to predict if you needed to engage in one or two conversations at the same time. A clever kid didn’t always mean that their parent understood what was going on or vice versa.)

There is much written about iterative design in education. Iterative design is swell for designing a new toothpaste tube based on customer interviews, brainstorming, pain points, etc. It is terrible for learning history or playing the cello. Iteration is about fixing something; making it right. I am much more excited about activities, such as computer programming in accessible languages, that lead to generative design. Show a kid a couple o blocks and they immediately have their own ideas about what to do next. The degree of difficulty of projects increase as kids experience success. If they are successful, they naturally find a new challenge, embellish their project, or test another hypothesis. If unsuccessful, debugging is necessary. Debugging is one of the most powerful ideas justifying computer use in education.

New prompt ideas emerged. While working with kids, I improvised the challenge to make a thermometer that showed a smiley face for warm temperatures and a sad face for colder temperatures. That was then substituted for a too difficult challenge in my list of suggested prompts.

When chips are cheap as chips, all sorts of new things are possible. You can leave projects assembled longer than a class period. You can use multiple micro:bits in one project. If you build something useful, you never have to take it apart. Giving every child the constructive technology to keep is a game changer! I will reconvene the students who attended the workshop next week to answer questions and see what they’ve been up to. Perhaps, this experience will lead to another article.

In less than the time of two traditional class periods (90 minutes), young children demonstrated a working understanding of computing concepts covering a breadth and depth of experiences many kids will not enjoy over twelve years of formal schooling. All of this was accomplished without coercion, assessment, sorting, worksheets, or more than a couple of minutes worth of instruction. A commitment to student agency and use of good open-ended constructive technology with extended play value allows a beautiful garden to bloom.

Resources


Veteran educator Dr. Gary Stager is co-author of Invent To Learn — Making, Tinkering, and Engineering in the Classroom and the founder of the Constructing Modern Knowledge summer institute. He led professional development in the world’s first 1:1 laptop schools and designed one of the oldest online graduate school programs. Learn more about Gary here.

I started teaching Logo to kids in 1982 and adults in 1983. I was an editor of ISTE’s Logo Exchange journal and wrote the project books accompanying the MicroWorlds Pro and MicroWorlds EX software environments. I also wrote programming activities for LEGO TC Logo and Control Lab, in addition to long forgotten but wonderful Logo environments, LogoExpress and Logo Ensemble.

Now that I’m working in a school regularly, I have been working to develop greater programming fluency among students and their teachers. We started a Programming with Some BBQ “learning lunch” series and I’ve been leading model lessons in classrooms. While I wish that teachers could/would find the time to develop their own curricular materials for supporting and extending these activities, I’m finding that I may just need to do so despite my contempt for curriculum.

One of the great things about the Logo programming language, upon which Scratch and MicroWorlds are built, is that there are countless entry points. While turtle graphics tends to be the focus of what schools use Logo for, I’m taking a decidedly more text-based approach. Along the way, important computer science concepts are being developed and middle school language arts teachers who have never seen value in (for lack of a better term) S.T.E.M. activities, have become intrigued by using computer science to explore grammar, poetry, and linguistics. The silly activity introduced in the link below is timeless, dating back to the 1960s, and is well documented in E. Paul Goldenberg and Wally Feurzig’s fantastic (out-of-print) book, “Exploring Language with Logo.”

I only take credit for the pedagogical approach and design of this document for teachers. As I create more, I’ll probably share it.

My goal is always to do as little talking or explaining as humanly possible without introducing metaphors or misconceptions that add future confusion or may need to remediated later. Teaching something properly from the start is the best way to go.

Commence the hilarity and let the programming begin! Becoming a programmer requires more than an hour of code.

Introduction to Logo Programming in MicroWorlds EX

Modifications may be made or bugs may fixed in the document linked above replaced as time goes by.

While waiting for the 5th grade class to settle  down between recess and their holiday party, I wrote this project starter for creating arithmetic flashcard software in MicroWorlds. While the “math” isn’t particularly interesting or open-ended, there are plenty of opportunities for the students to improve and augment the software.

Bad drill and practice doesn’t become good because it is programmed in Logo, or by kids. However, the person who learns the most from “educational” software is the person who made it.

I thought of doing this because “practice multiplication facts” has been written on the classroom board for months. If the kids “write the software, perhaps they’ll think about multiplication a bit.

This is also an opportunity for introducing concepts, like percent, in order to create a cumulative score.

Download the PDF project starter by clicking the link below:

 A “Math” Game Only A Mother Could Love (PDF)

Last Friday afternoon I experienced one of the most joyous moments of my thirty years in education. I took three fifth grade girls (along with their classroom teacher chaperone) out to lunch. That’s right. We walked right out the front gate of the school, into the sunlight, crossed the street, walked down the block and had a leisurely 90-minute lunch at the restaurant of their choice – regrettably the crime against gastronomy (and pizza), California Pizza Kitchen.

A few weeks earlier, I had challenged the 5th graders to write a computer program in MicroWorlds EX that would draw fractional representations of a circle for any fraction a user requested. Feeling a bit cheeky, I said that I would buy lunch for the first kid or group of kids to write a successful program. After a few class sessions dedicated to the challenge, three fifth grade girls were the first to succeed.

I know. I’m a hypocrite.

I reject behaviorism and its evil friends; grades, punishment, bribes and rewards. However, this felt different. The kids were going to join me for lunch like colleagues celebrating an accomplishment. Best of all, their classmates continued working on the programming challenge, without hard feelings, even after “winners” had emerged. Perhaps they knew that their turn would come. I routinely bring treats from my travels into the classroom. If I worked in an office, I might stop occasionally and buy Dunkin Munchkins for my co-workers. I do the same with my students. Why not?

I loved telling the girls that they could order anything they wanted and learning about their dietary habits and favorites. Conversation covered sick babies, interior decorating, roller coasters, face blindness and Khan Academy. The last two topics were introduced by a girl who matter-of-factly stated, “I watch 60 Minutes.” I was jealous of their classroom teacher who knew more about their parents, siblings, friends and neighbors than I do, but a good time was had by all. The genuine gratitude expressed by the girls (including their teacher) made it all worthwhile.

Perhaps the highlight of our lunch was watching the girls color their kid’s menus at a lunch celebrating their computer science prowess.  Once again, Seymour Papert is correct.

Below is the program the girls wrote. It required figuring out how to “teach the turtle” to draw a circle and utilized a bunch of mathematical concepts, including radius, fractions, variables and angle.

For those of you lacking the skills of a 5th grader and can’t read a Logo program, I’ve included a video demonstrating their program at work.

to Pie
 repeat 360 [fd 3 rt 1]
 end
to fraction :n :d
 cg
 setc "black
 pd
 Pie
 pu
 rt 90
 fd 172
 rt 90
 pd
 repeat :d [fd 172 bk 172 rt 360 / :d]
 repeat :n [rt 360 / :d fillit ]
 end
to fillit
 setc color + 5
 pu
 rt 5
 fd 20
 fill
 bk 20
 lt 5
 end
to mem
 repeat :n [fillit pu rt 1 fd :l / :d lt 1]
 rt 1
 bk :n / :d * :l lt 1
 end

 .

There’s chatter from time-to-time within the edtech community about the lack of women in prominent roles. Yet, some of the most important pioneers in the field are ignored, overlooked or marginalized by the very same educators seeking representation and role models.

If Seymour Papert is the “father of educational computing,” then Dr. Cynthia Solomon is its mother. Cynthia was one of the three primary inventors of the Logo programming language for children and she introduced many of the metaphors used to teach programming to children. She is the author of one of the field’s seminal books, Computer Environments for Children: A Reflection on Theories of Learning and Education. How many of you have read this book first published in 1986?

Nearly 50 years ago, armed with a history degree from Harvard, Cynthia took a job as Dr. Marvin Minsky’s secretary because she wanted to learn how to program computers at a time when that wasn’t an option for young women. A few years later, she, Wally Feurzig & Seymour Papert created Logo and started the educational computing revolution. Watch the recent interview in which Cynthia & Wally recount the birth of Logo.

Wally Feurzig, Cynthia Solomon, Gary Stager

Cynthia Solomon is also the co-author of Designing Multimedia Environments for Children (with Allison Druin) and Logoworks: Challenging Programs in Logo by Cynthia Solomon, Margaret Minsky and Brian Harvey. She most recently put the full text of  Computer Environments for Children: A Reflection on Theories of Learning and Education and Logoworks… on the Web for free.

Ken Kahn, Seymour Papert, Cynthia Solomon & a kid at Logosium '99

We go way back

In 1985, I traveled to MIT for the first time to attend the Logo ’85 international conference. I was 22 years old and had no academic credentials. Memory suggests that the instant I stepped out of my cab, Cynthia Solomon and a handful of other great scholars and educators said, “Hey kid, come to dinner with us.” I’ve been lucky enough to have Cynthia Solomon as a friend, colleague and mentor ever since.

My annual summer institute, Constructing Modern Knowledge, would be unimaginable without Cynthia on the faculty. She returns to CMK 2011 this July 11-14th for the fourth time in four years.

Cynthia Solomon (right) teaches at CMK 2010

There is still room for additional registrants at this year’s Constructing Modern Knowledge institute! Register today!

Originally published in the September 2000 issue of Australia’s Hotsource online newsletter

Now that most of you can be considered advanced beginners in using MicroWorlds, this issue will explore a bit more of the language and data structures available to you.

The following activity explores probability while demonstrating how sliders, text boxes and even the screen may be used to collect and report data.

Who’s for two-up?
The core of this task will be to flip a coin numerous times and record the number of times heads and tails appear.

  • Start a new project.
  • Name the turtle, coin.
  • Create two coin shapes in the shapes centre. Name one heads and the other tails. Be sure to make them appear different in some way so that the user can clearly see which one side of the coin lands faceup.
  • Change the turtle’s costui-ne to one of the coin shapes. Create a Many Times button with the instruction, flip.

Recording data with text boxes
This part of the project will flip a coin in FLIP, and change the value in the textboxes, headscount, tailscount and totalflips. If you name turtles, text boxes or sliders with unique name you may change them even ii they are on different pages. This allows you to have some action going on between the scenes.

  • Make a Startup button on the first page.
  • Create a new page from the pages menu.
  • Create text boxes named, Headscount, Tailscount and Totalflips.
  • Show the names of the text boxes so the user knows what they are reading
  • Click the Startup button
  • Type the following procedures on the procedures page.

to flip
ifelse coin = ‘heads
[recordheads]
[recordtails]
settotalflips totalflips + 1
end

to coin
if 1 = random 2 [output “heads]
output “tails
end

to recordheads
coin, setsh ‘heads
setheadscount headscount + 1
end

to recordtails
coin, setsh “tails
settailscount tailscount + 1
end

to startup
everyone [settext 0]
end

Click the flip button to start and stop the experiment. You may wish to make the flip button run many times if you want it to keep flipping the coin.

Recording data with sliders
Sliders may be used as reporters (input devices) to change the value of a variable or they may be used as indicators (output devices) displaying the current value of that reporter. Let’s experiment with sliders on a second page of our coin flipping project.

  • Create a new page from the Pages menu
  • Create two sliders ‘heads and tails, with a minimum of 0 and maximum of 300 at the bottom of the new page
  • Optional: Create buttons to switch between the two pages of our project.
  • Make the following changes to your procedures.

To recordheads
coin, setsh ‘heads
setheadscount headscount + 1
setheads heads + 1
end

to recordtails
coin, setsh “tails settailscount tailscount + 1
settails tails + 1
end

to startup
settailscount 0
setheadscount 0
settotalflips 0
settails 0 setheads 0
end

Type Startup to init-ialise the variables, click oA the flip button and switch between pages.

Do you see the sliders changing their values?

Extra bonus! Adding a histogram to graph our data
It is easy to add simple graphing functionality to our probability lab with the creation of two turtles and a bit more Logo programming.

  • Hatch two turtles on the same page as the sliders.
  • Name one turtle, headsgraph, and the other, tailsgi-aph (for heads graph and tails graph)
  • Place those turtles above their respective sliders.
  • Create two different turtle costui-nes consisting of blue and red horizontal bars. Name the shapes hline and tline.

Make the following changes to your procedures.

To recordheads
coin, setsh ‘heads
setheadscount headscount + 1
setheads heads + 1
headsgraph, fd 1 stamp
end

to recordtails
coin, setsh “tails
settailscount tailscount+l
settails tails + 1
tailsgraph, FD 1 stamp
end

to startup
settailscount 0
setheadscount 0
settotalflips 0
settails 0 setheads 0
headsgraph, setpos [-170 1451]
tailsgraph, setpos [200 145] page2 clean pagel
end

Type Startup and click on the flip button to set the experiment in action! You may even want to figure out a way to stop the graphing when a bar reaches the top. How about a textbox reporting the experimental standard deviation?

The magic of MicroWorlds’ parallelism allows the coin to be animated, text boxes to change, sliders to report and a histogram to be created all at once. You can use lots of software to generate random numbers, but no other title allows all of these things to happen at once. I am confident that you can figure out exciting ways to integrate these programming techniques into much more complex simulations and experiments.

Originally published in the September 2000 issue of Australia’s Hotsource online newsletter

LogoWriter and MicroWorlds have done so much for interdisciplinary projects that it is useful to remember that MicroWorlds can play a major role in the development of mathematical knowledge. This issue and next will explore the numerical side of MicroWorlds.

First the Boring Stuff
MicroWorlds procedures come in two categories, commands and procedures. Most Logo-users are quite comfortable with commands such as CG, FD, RT and SETC. Commands may or may not take inputs and they always produce an action. Every Logo expression (line of code) must begin with a command. This is why typing HEADING in the command centre produces the error message I don’t know what to do with HEADING. SHOW HEADING, FD HEADING, RT HEADING * 2 will all work because HEADING reports the turtle’s current orientation and hopes a command is listening. Commands may have any number of hoppers, but they never have a spout. REPEAT is an example of a two input (hopper) command.

Every one input command beginning with the prefix, SET, has a corresponding reporter with no inputs. For example:

Command Reporter
SETC COLOR
SETH HEADING
SETPOS POS
SETBG BG
SETX XCOR
SETTEXT1 TEXT1 (where text1 is the name of a textbox)

At the core of it all
Reporters are procedures that may or may not take an input, but they always output a result. Reporters are also known as functions or operations. Reporters are absolutely essential for most mathematical and interactive MicroWorlds projects. They pass information that can be used by other procedures or turtles. Reporters may have any number of hoppers, but they always have just one spout.

It’s your call
You can write your own reporters if you remember one simple rule. Every reporter procedure contains one output. When Logo encounters the OUTPUT reporter, the procedure is terminated. To create a new reporter you need to remember the rule about OUTPUT and decide how many inputs the reporter needs. For example, if we wanted to write a procedure to double a number, we would only need one input.

to double :number
output :number * 2
end

or

to double :number
output :number + :number
end

Type: DOUBLE 45 in the command centre and see what happens? Why did you receive an error message?

Many people who wish to double a number would write the following procedure.

To dumb.double :number
show :number * 2
end

Then if they type, DUMB.DOUBLE 45 in the command centre they will get what they think is the desired result. This is the result they need only if they want to see the number 90 appear in the command centre.

Try typing the following instructions in the command centre:
FD DUMB.DOUBLE
45 DUMB.DOUBLE DUMB.DOUBLE 45

Now try typing:

SHOW DOUBLE 45
FD DOUBLE 45 RT DOUBLE 45
SHOW DOUBLE DOUBLE DOUBLE 45

Our DOUBLE procedure is much more flexible and versatile than DUMB.DOUBLE.

They can speak to each other
Reporters can perform a manipulation/operation on an input and then report that result to another reporter. Logo (MicroWorlds) reads reporters from right to left since you can’t type from top to bottom. The following graphic illustrates FD ADD5 DOUBLE DOUBLE 5.

Logo is a prefix language. That means that inputs always follow the procedures. Since humans like the standard arithmetic operators (+-*/), Logo will tolerate them, but often requires parentheses for grouping. These infix reporters tend to give the turtle indigestion. Logo much prefers PRODUCT 3 4 to 3 * 4. See how SHOW DOUBLE DOUBLE 3 + 4 behaves if you add parentheses, like SHOW (DOUBLE DOUBLE 3) + 4.

Make it simple
Young children can use similar simple arithmetic reporters to leverage their own turtle graphics. For example, a child incapable of calculating twice the distance for the turtle travel could use a DOUBLE or TWICE reporter and operate algorithmically. These procedures could be written by a teacher ahead of time or by the student herself.

Operation of fractions may also be explored with simple reporters.

To 3fourths :number
output :number * 3 / 4
end

to 2thirds :number
output :number * 2 / 3
end

to 1half :number
output :number / 2
end

To “play with” multiplication of fractions, try typing:
SHOW 3fourths 100
SHOW 1half 100
SHOW 2thirds 3fourths 100

You may of course use these fractional reporters to command the turtle. Type the following BAR procedure on the procedure page.

To bar :height
pd repeat 2 [fd :height rt 90 FD 25 rt 90]
pu rt 90 FD 35 lt 90
end

See what happens if you type the following in the command centre.

BAR 100
BAR 3fourths
100 BAR 1half 100
BAR 2thirds 3fourths 100

Battle of the Functions
You can make a game out of all these arithmetic reporters. Put kids in groups of four or five and have them each contribute one new arithmetic procedure in the style of DOUBLE. They may use their own imprecise names for the reporters if they wish (as long as they can explain its function to their peers). Each kid takes turns inventing a number problem consisting of stacked-up reporters and one numerical input. The object of the game is to invent a problem that is difficult, but not impossible to solve in one’s head. Wiseguys are penalized by the rules of the game.

Originally published in the September 2000 issue of Australia’s Hotsource online newsletter

Since the 1960s, Logo was intended to have no threshold and no ceiling. It derives its magic from how little kids and graduate students find the same environment challenging, exciting and expressive. Although a variety of forces have conspired to make MicroWorlds use most common in years five through seven, little kids can use it in quite creative ways. Much has been written about how MicroWorlds can be used to enhance the learning of secondary school concepts. This column makes the case for using MicroWorlds in the lower primary grades.

Great Value

Schools that own MicroWorlds site-licenses already have a “free” multimedia paint, animation, music and web-page creation software appropriate for young learners. There are many entry-points through which children may enter the world of MicroWorlds.

Why should little kids be limited to mindless drill or painting pictures? Even early readers can program MicroWorlds to perform simple animations. Write or print the names of simple turtle graphics commands (FD, BK, RT, LT, SETSH) with sample inputs on cards next to the computer. Names of the standard turtle shapes next to their pictures may also be placed on cards.

Baby animation

  • Hatch a turtle
  • Turn it in the desired direction by clicking and dragging its nose
  • Open the shapes centre and select the shape you wish for the turtle to wear
  • Click on the turtle
  • Click the eye tool on the turtle to edit its instruction
  • Type the command, FD 5, in the Instruction: line
  • Select Many Times
  • Click on the turtle to make it go and repeat the process for additional turtles
  • Encourage kids to change the distance (number) by which the turtle goes forward and observe what happens.
  • Kids can even program colours to make a turtle reverse when it hits the brown mountain (see the MicroWorlds online help or users guide to learn how).

Toddler animation (flipbook animation)

Follow the same steps as above, but add a command such as, SETSH [bird1 bird2] FD 5, in the Instruction: line of the turtle. These instructions may be written on student reference cards.

You can find out the name of turtle shapes by opening the shapes centre and holding the mouse over the shape (in Windows 95) or double-clicking on the shape (Macintosh).

Making Magic

Five year-old John Richardson uses MicroWorlds to tell stories, create insect reports and even design copies of his favorite commercial software products like The Logical Journey of the Zoombinis. Making software is not beyond the imagination of young kids. Why not make your LEGO rocket fly on the computer screen? In the past it was impossible for pre-readers to program computers.

Kids like John can hatch turtles, design turtle costumes, paint backgrounds, create multiple pages, compose music and record narration and sound effects without assistance. They can even create simple animations by typing the commands prepared on teacher-made reference cards.

After John creates all of his desired objects, he directs his Dad in how to program motion and interactivity. This process is quite similar to when pre-writers dictate a story to an older student or adult. However, a MicroWorlds project requires the use of mathematical processes, different senses and action.

The success of early-childhood MicroWorlds projects is dependent on three factors:

  • sufficient computer access
  • adult support
  • a great open-ended tool (MicroWorlds)

After little kids spend a few years “messing-about” with MicroWorlds they will have the fluency required to tackle more complex problem solving in specific school subjects. These children will appreciate the intellectual satisfaction and joy associated with teaching the computer to do something it may never have done before.


Originally published in the June 2000 issue of Australia’s Hotsource online newsletter

The recent success of Rick Park’s brilliant Wallace and Gromit films has inspired a resurgence of interest in claymation (stop-action animation made with clay figures). Claymation may be used in a language arts context, for telling stories across disciplines or for just plain fun.

MicroWorlds and MicroWorlds Pro provides a studio for creating claymations long on story and short on technical obstacles. Students wishing to tell a story do not need to learn Adobe Premiere or own a digital video camera – a digital still camera, QuickCam, Polaroid or even a disposable 35mm camera is just fine. This project provides a great deal of bang for the high-tech buck.

There are five simple steps involved in creating your own claymation with MicroWorlds or MicroWorlds Pro:

  1. Design a small number of posable characters out of clay.
  2. Photograph the characters one motion at a time.
    • Use a tripod and a flash to ensure the same frame and lighting. You may wish to mark the camera position with masking tape.
    • Move the characters, take a picture, repeat as necessary.
  3. Get the pictures into the computer (and save them).
    • Import digital still images using your camera’s image capture software.
    • Scan photographs with a flatbed or photo scanner (Polaroids, 35mm or APS).
    • Have your photos developed and placed on a Photo CD or floppy.
    • Snap the pictures with a PC camera like the QuickCam.
  4. Paste each photo into the MicroWorlds shapes centre.
  5. Animate the photos.

Steps 1 and 2 may be tedious, but are technically simple. Start out with a simple plot with few characters. Kids will amaze you with what they will produce.

Step 3 requires you to import the photos into your computer via capture software, a scanner or Photo CD. It’s not a bad idea to number the photos in a consistent way like, photo1.jpg, photo2.jpg, etc… Placing the files in the same folder with MicroWorlds will help you find them if you are less comfortable with ugly path names.

Step 4 requires some fluency with cut and paste (the doctoral level of computer literacy). The goal is to turn each photo into a MicroWorlds turtle costume. If you can figure out a way to paste each successive image into the MicroWorlds shape centre, then you can ignore the rest of this step.

Strategy 1 (high-tech solution for project with lots of frames)
• Use the getshape command (in MicroWorlds Pro only) to import one photo at a time or write a short procedure to do automatically.
Getshape “filename shape_number for example, getshape “photo1 1
• The image in the file will then be placed in the position of the shapes centre specified by the second input.
• You may wish to try a fancy procedure like the one below if you wish to automatically import files with similar names and successive numbering. Don’t worry about the error message. When you run out of photos to import, the procedure will crash.

to getshapes :number >>
loadshape (word “C:\WINDOWS\Profiles\ >>
Jackel\Desktop\marsion\Dsc002
>>
:number “.jpg) :number
getshapes :number + 1
end

Note: >> indicates line wrap

Strategy 2 (open the photos in a graphics program and switch between MicroWorlds and that application)
• Open each photo one at a time or together
• Copy each image
• Paste the image in a successive MicroWorlds/MicroWorlds Pro shape
• Close the original image file
• Remember to save your MicroWorlds project often!

Strategy 3 (use MicroWorlds only)
• Import the photo file into MicroWorlds using the File/Import menu
• Cut the image
• Paste it into the next shape in the shapes centre
• Remember to save your MicroWorlds project often!

Step 5 is the simplest step of all and demonstrates the elegance of MicroWorlds/MicroWorlds Pro. This project can be easily completed by a very young child. However, like all programming projects you may make the program more complex.

  1. Hatch a turtle and put it in the center of your page (you may use the home command)
  2. Click on the first shape in your animation photos
  3. Click on the turtle to make the turtle wear that costume
  4. With the shift-key held down repeat steps 2 & 3 (above), but change to the next shape in your shapes centre until you run out of photos for your animation. This is a cool trick to tell MicroWorlds to change shapes every time it gets a forward or back instruction. You can of course write a procedure containing lots of setsh commands if you are a rigid old Logo programmer who doesn’t like to make life too easy on yourself.
  5. Click the eye tool or right-click (Ctrl-Click in MicroWorlds Pro for the Macintosh) on the turtle to edit it.
  6. Type the instruction FD 0 wait 4 into the instruction field and choose MANY TIMES.
    THAT’S IT!
    FD 0 counts as movement, but stays in place – thereby changing the turtle costumes automatically. You may wish to adjust the input to wait to change the pace of the animation.
  7. Click on the turtle and premiere your claymation!!

You may wish to gain more control of your claymation with a procedure like the following and then put the name of that procedure in the instruction for your turtle. You can play music or narration, change the pace of the flipbook animation and even turn pages.

to animate
launch [soundtrack] ;soundtrack is the name of a sound file, recording or melody
setsh 1
wait 2
setsh 2
wait 2
setsh 3
wait 4
setsh 4
wait 2
page2
end

Publish your claymations on the web or share them with Hotsource.

Go make something!

Originally published in the October 2000 issue of Australia’s Hotsource online newsletter

Most MicroWorlds users are familiar with the local and global variables built into the language. Logo, MicroWorld’s underlying computer language, prefers the passing of values between procedures via local variable inputs. Global variables, created with MAKE or NAME, are containers that remember their contents across all procedures. Local variables are like short-term memory and global variables are useful for remembering things like the name of a player so that such data may be recalled later on in a program. MicroWorlds adds additional variable types, including the very powerful TURTLESOWN and project variables which save with the MicroWorlds project file.

What Do Turtles Own?

MicroWorlds turtles can now keep track of all sorts of properties. This enhances their intelligence and makes it easier to get turtles to do tricky things without the programmer needing to keep track of too many variables.

Whenever you want one or more turtles to remember some information about its state or behavior, the command, TURTLESOWN will help you do so. Remembering a state or behavior is one thing, but in MicroWorlds you will also want a way of reporting that information to a procedure or other turtle.

Understanding Turtlesown

a) State variables

Turtles already own several state variables including SHAPE, COLOR, HEADING, POS, XCOR, YCOR and SIZE. Each one of these reporters has a corresponding one input command beginning with SET. In other words, you may change a state and report its value/condition.

Command Reporter
SETSH SHAPE
SETC COLOR
SETH HEADING
SETPOS POs
SETX XCOR
SETY YCOR
SETBG BG

Try typing the following and observe the results. Be sure you have at least one turtle on the page.

setsh “car
show shape
setpos [50 -75]
show POs
show xcor
show ycor
setc color + 10
seth 90
fd heading
repeat 5 [setsize size + 5]

TURTLESOWN is used to create other variables for every turtle in a current project. TURTLESOWN takes a word as input and that word is the name of the variable being created.

Turtlesown “speed

There are three actions associated with TURTLESOWN.

  1. Telling MicroWorlds to give a state/variable to every turtle in the project
  2. Assigning a variable to that state
  3. Using that state variables in some way

b) Introduction to turtlesown

Let’s try a few simple examples.

  1. Create a new project
  2. Hatch two more turtles so that three turtles appear on the page
  3. Change their colors so that we can tell them apart:
t1, setc “red
t2, setc “blue
t3, setc “yellow

Tell MicroWorlds to give every turtle the property, speed

turtlesown “speed

Set the speed value for each turtle and tell them to go:

t1, setspeed 1
t2, setspeed 5
t3, setspeed 10
everyone [forever [FD speed]]

In this case, everyone tells all of the turtles on this page to go FD by their speed value speed.

Let the turtles run wild and type the following to see what happens.

t2, show speed

There is another way to check a turtle’s property value by using the apostrophe as follows.

show t3’s “speed

You might want to use the apostrophe form in the following way.

t3, setspeed t2’s “speed

Now t3 and t2 are traveling at the same rate. What happens if you type: t3, setspeed -10 in the command center?

Turtlesown may also be used to restore a turtle to a previous state. Let’s say you want to give each turtle a random home on the screen, instead of [0 0], and after running around a bit want the turtles to go home. Try the following to see what I mean (Be sure there are at least three turtles on the page. The more turtles, the merrier!)

turtlesown “oldhome
everyone [setx random 2000 sety random 2000]
setoldhome POs ;this stores the turtles current position in oldhome
everyone [rt random 360 FD random 3000]
everyone [setpos oldhome]

An important thing you need to understand is that TURTLESOWN is a command that will tell all of the turtles in a project to remember a particular variable during your work session. The best thing about turtlesown is that the state of each variable is stored with the project upon saving. This allows you to use these values at a later time.

Activities

You can use TURTLESOWN in all sorts of ways. It can be used to count laps around a track or keep track of a turtle’s age. Here are a couple of simple ideas for storing information other than screen conditions. What kind of clever uses can you imagine for using TURTLESOWN?

Example 1 — Turtle Track and Field

In this exercise, we will keep track of how many times a turtle completes a circle.

  • Create a textbox and name it COUNTER. Make the font size nice and big so you can read the contents of the textbox.
  • Type the following in the command center:

CG
turtlesown “laps
setlaps 0
forever [FD 1 rt 1 if POs = [0 0] [setlaps laps + 1]
forever [setcounter laps]

Try typing before the above instructions and see what happens.

Example 2 — Dodge ‘em Turtles

In this exercise, we will keep track of how often a turtle hits an object on the screen. If a turtle hits the red circle, it will make a random U-turn of between 150 and 209 degrees.

  • Create a new project
  • Hatch two more turtles to be sure that there are three on the page
  • Make each turtle a different color so we can tell them apart
  • Draw a red circle in the middle of the screen
  • Double-click on the color red in the command center and type the following instruction:

setcollisions collisions + 1 rt 150 + random 60

  • Click on the ONCE button and then click OK
  • Click the eye tool or right mouse button on each turtle and give them the same instruction:

FD speed

Click MANY TIMES and OK

Type the following in the command center:

turtlesown “speed
turtlesown “collisions
everyone [setspeed random 10 setcollisions 0]
everyone [clickon]

Let the turtles run and bounce around the screen for a while and then check on their collision status.

t2, show collisions
show t3’s “collisions

Example 3 — The Aging Turtle

We can ask turtles to keep track of their age as time elapses. The command, RESETT, sets the clock to zero and the reporter, TIMER, reports the number of tenths of a second that have elapsed.

Program each turtle to run the instruction, FD 5 MANY TIMES

  • Create a new project
  • Remove any turtles on the page
  • Type the following procedures on the procedures page

to startup
dolist [x turtles] [remove :x]
carefully [remove “age] [] ;remove the age property if it already exists
turtlesown “age
resett ;reset the MicroWorlds timer to 0
end

to hatch
newturtle word “t ((count turtles) + 1) ;hatch a new turtle and name it t1…
setage 0
setx -250 + (count turtles) * 30 ;line the turtles up along the x axis
st
when [0 = remainder timer 10] [everyone [setage age + 1 setc color + 1 Seth age * 10]]
end

to turtles
get first pagelist “turtles
end

The when statement in the hatch procedure checks for each second that elapses and then asks every turtle to adjust it’s age, color and heading to show the aging process. Turtles is a reporter that reports the list of turtles on the current page. It is a good tool procedure to have in your toolbox.

  • Create a ONCE button with the instruction, HATCH.
  • Type STARTUP in the command center
  • Click the hatch button occasionally to hatch a new turtle and watch time fly

You can check the age of a turtle by typing an instruction like, SHOW t1’s “age.

Part II – Project Variables

MicroWorlds adds another new data structure called project variables. The data in these project variables are saved with the project. Therefore, you can remember a piece of information within a project, even after your quit MicroWorlds

Local and global variables have their particular strengths and weaknesses, but neither hold their value when the file is saved. Project variables do. Therefore you can set the value of a project variable and use that value at a later time.

Understanding Project Variables

The createprojectvar “container command creates a variable, named container. You can then assign a value to that variable by typing: setcontainer 57 or setcontainer [Joe Smith] or setfoo “tails. In this way, SET is used to change the contents of a project variable, just as it is with a text box.

You can find the value of that variable by using its name. For example, typing show container would report the value stored in the container variable.

You can report the current project variables in a project by typing, show projectvars.

Delete a project variable by typing remove “variablename.

Project variables may also be used to keep track of things like high scores in video games.

Activity — Collecting Probability Data

We already explored flipping a coin in the Running Text in Text Boxes section, but let’s build on that idea in a way that uses project variables so that you may continue collecting data the next time you open the project. This variation on the coin tossing theme does not use text boxes to display and record the data. All of the record keeping is done in invisible variables.

  • Create a new project.
  • Create three text boxes named, table, headscount and tailscount.
  • Create a many times button with the instruction, toss, on it.
  • Write the following procedures on your procedures page.
  • Type the procedures (below) in the procedures page.
  • Type reset in the command center the first time to initialize and create the various variables.
  • Click on the button to start the experiment.
  • Stop the procedures at some point and save the file.
  • Close the project.
  • Open the project again and click the button. You should continue counting the trials.

Procedures:

to reset
setheadscount 0
settailscount 0
carefully [createprojectvar “heads setheads 0] [] ;if the project variable already exists do nothing
carefully [createprojectvar “tails settails 0] [] ;if the project variable already exists do nothing
table, ct
end

to toss
ifelse 1 = random 2 [gotheads] [gottails]
end

to gotheads
table, print “heads
setheads heads + 1
setheadscount heads
end

to gottails
table, print “tails
settails tails + 1
settailscount tails
end

to clearvariables
setheads 0
settails 0
end