Sugar Labs @ NDSU

Building a smarter computing culture in Fargo, ND

su -l :: How soon is too soon for kids?

When and how should kids “View Source”?

Keep it secret, keep it safe[?] — Gandalf the Grey

Modified Sugar Favorites View

This post examines my thoughts on when and how to reveal the architecture of code to the Tech Team at Madison Elementary, which is comprised of 4th and 5th graders.

Helen J. Burgess, in From A to A, writes about her two favorite moments in her classroom: the first is watching her composition students react to the view source feature in their browser, and the second is when they later begin to understand how markup works. I wanted to do the same, but in Sugar, and with 4th and 5th graders.

To do so, and in a creative way, I thought about conducting a session around the modification of the Sugar Home file, It was my initial hope that a “successful” attempt to have the students modify their favorites view would prompt them to see the potential fun and freedom of learning how to program. But, I couldn’t do it alone, so I recently requested help on the IAEP (It’s All About Education) email listserv, asking advice on how to modify the Sugar Home file. The series of responses were very thought provoking, leading me to wonder as a teacher-researcher, how soon is too soon to see the more complicated stuff?

Before I jump into that question, I must say that I love this Sugar community. I received numerous responses that were all very helpful with a variety of different suggestions and tips. Walter Bender even chimed in with information regarding the development of a sandbox of sorts for tinkering with the Sugar toolkit without destroying the OS, and in our case, the SoaS. It’s this kind of willingness to help one another that gets me even more excited about opensource projects.

Looking at the question, when and how should kids start computer programming, through the lens of this particular introductory exercise, I see three main possibilities, if I were to go ahead with the activity:

    The Good: the exercise goes well with a few expected issues that require debugging and teamwork. The students find it pretty cool that they can change these features, if they learn more about programming. This would be the desired goal.
    The Bad: Too much goes wrong, and the kids get tired of trying to debug the mod, and they are turned off by the notion of learning how to program.
    The Ugly: It goes really wrong, someone breaks their SoaS. Walter noted in his IAEP email that the Sugar Labs team hasn’t quite worked out how to create a Sugar sandbox where kids can break Sugar without destroying the system. Yikes! Bye, bye school project portfolios! And bye, bye to the desire to learn how to program.

Now, if I were to keep the activity limited to the first set of instructions as seen in the hyperlinked FLOSS manual, all they would need to do is “uncomment” the file prompts by removing the “#” set before the command line that is already there. This lesson then highlights not just the change effected with the GUI, but also the hierarchy of files that are called upon, which could lead into a good mini discussion on the architecture of software. Some crazy big picture stuff! Almost Matrix, red pill caliber… It also gives them some good practice with the Terminal window, which, I think, builds some new inventory tools for the smart computing culture and more apt computer literacy skills that we are after.

So, is this an activity good for 4th and 5th graders? I still think so. The young minds that I’ve worked with thus far can take in a good amount of information and aren’t afraid to climb some tall debugging walls (except on some bad days). Keeping the code secret and safe from the kids isn’t going to help them engage the computer at a more nuanced level.

As an educator and beginner-coder, myself, I think this activity could propel us (myself, Kevin, and the Tech Team) into some nice, meaningful Turtle Art sessions mixed in with some Pippy, which would be a new activity for the everyone. I suppose this makes us stop and consider what parts of programming are we really highlighting when we’re doing these activites, which is just another good application of constructivist learning.

# Next stop
>>> print “Hello [New] World!”
Hello [New] World!


2 comments on “su -l :: How soon is too soon for kids?

  1. kevix
    July 22, 2011

    you have to prepare. That is part of proper computer ‘hacking’. You dont start to mess with a file without backing it up. You dont mess with important OS stuff without dong a backup. So if you describe the steps that ‘real world’ hacker do before, during and after they hack, that should limit ‘the damage’. But ‘in the real world’ hackers mess-up too (like the a misplaced ‘rm -rf’) and then they learn from that, too.

    • Chris Lindgren
      July 22, 2011

      I agree, Kevin. This entire project is one giant lesson for me. I can share in the experience of writing, though. Researching, reading, processing and synthesizing information is all a part of the process of preparation before the really good writing can come out of it all.

      Thanks for the comment!

Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out /  Change )

Google+ photo

You are commenting using your Google+ account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )


Connecting to %s


This entry was posted on July 21, 2011 by in OLPC, smartcomputing, Sugar and tagged , , .


Enter your email address to subscribe to this blog and receive notifications of new posts by email.

Join 952 other followers

%d bloggers like this: