[Edu-sig] rur-ple: pre-release of new lessons (long)

[Douglas S. Blank]

I was asleep at the wheel during this last bit of discussion of RUR-PLE,
and just now catching up.

Some comments below:

On Sun, 2006-01-29 at 09:56 -0800, Dethe Elza wrote:
> > My longer term hope is to see some physical robot offerings on the  
> > market (in addition to the screen based ones) with some kind of  
> > Python capability -- perhaps just a module with pre-defined motions  
> > the user might resequence or trigger based on events (sensor  
> > inputs), per Lego Mindstorms example.

Python is catching on in many places, including real robotics and AI
research. Many low-level systems have Python wrappers. I'll be
presenting at SIGCSE (http://www.cs.rit.edu/~sigcse06/) in a month with
two other colleagues. We all three do robotics, but all use Python in
different ways.

For example, Python now runs natively on Sony's AIBO. It used to be the
case that one would write C++ code, compile it, reboot, upload, run, in
order to program the AIBO. Now, it can be all Python (and the award
winning CMU team is doing just that). As a side note, the AIBO was just
canceled by Sony. Bummer. It was a great platform.

And as Dethe mentioned:

> Pyro (http://pyrorobotics.org/) does exactly this.  It provides an  
> environment for programming physical robots, but you can also run  
> them in a simulator which uses OpenGL to create both the robot and a  
> world for the robot to interact with.  Could be interesting to bring  
> something like this to RUR-PLE.

As one of the developers of Pyro, I wonder about going the other way
too, bringing RUR-PLE pieces to Pyro. In fact, not only can Pyro control
OpenGL robots, AIBO, 2d simulators, but it can also be used to play
checkers, chess, and the like. Also, we have a "wumpus world" that
operates much like RUR-PLE's world.

I co-wrote a paper a couple of years ago, "Avoiding the Karel-the-Robot
Paradox: A framework for making sophisticated robotics accessible" [1].
The point was that instead of teaching a pseudo-language in a
pseudo-world, we should teach a real language/system which remains
constant across all robot platforms. It is an extreme position (and
largely aimed at real robotics systems), but does raise some real
questions:

- Does RUR-PLE limit the student too much? Or is does hiding some parts
of the complexity of Python and real robots make it easier to learn?

- Does learning to rely on the hidden bits make it harder to learn real
Python as the student continues?

- Is it easy to move to Pyro from RUR-PLE, or would it be easier to have
a RUR-PLE world in Pyro?

- Would having to deal with real world issues (like time, inaccurate
sensors, inaccurate wheels) cloud the environment, or does it excite the
student and teach other valuable lessons?

- Do kids see RUR-PLE as silly and too simple? Do kids see Pyro as too
complex? Is there a preferred age for both systems?

- Can kids explore "emergent phenomena" with RUR-PLE? Or is it just too
constrained? Students can have control many robots in Pyro, but is this
too much for them to handle? (Pokemon is vast, and yet not that
interesting because there aren't any interaction effects. Even The Sims
has limited interaction effects.)

- Having real sensors in Pyro allows students to hook up input directly
to output. In RUR-PLE you have to use symbol names (left, right,
beeper_to_left, etc). How does this affect what we learn? Are these
biases put in place when we are young and hard to overcome later?

The programs are more similar than one might guess:

In RUR-PLE:

move()
move()
turn_left()

There are some subtle points in this program: how do you know when you
have gone one grid space? can you move .5 grid spaces? how do you know
when you have turned exactly 90 degrees?

In Pyro (talking to a symbolic, discrete world):

class MyBrain(Brain):
   def step(self):
      self.robot.move("forward")
      self.robot.move("forward")
      self.robot.move("left")

The same questions apply here, and we answer them by going to a
continuous world. In Pyro (talking to a real or simulated, continuous
world):

class MyBrain(Brain):
   def step(self):
      self.robot.move(0, 1) # translate amt, rotate amt
      time.sleep(1.0)
      self.robot.move(1, 0) # values go from -1 to 1
      time.sleep(3.0)
      self.robot.move(0, 1)
      time.sleep(1.0)

A complete intro lesson can be seen here:

http://pyrorobotics.org/?page=PyroModuleDirectControl

Some of these points may be non-issues because RUR-PLE isn't attempting
to teach robotics. But what if it were? Some of these points we could
explore by making RUR-PLE talk to the Pyro 2D simulators (one is written
in pure-Python) and by having Pyro connect to the simulator in RUR-PLE.
I'd be interested in sharing lessons learned from that software which is
designed "for kids" versus "for young adults."

BTW, I use do use Pyro to teach cognitive science students how to
program. Questions of intelligence make a great way to motivate the
learning of programming, and of course Python is great for that. Would
young kids benefit from this same motivation?

-Doug

[1] http://dangermouse.brynmawr.edu/~dblank/papers/aaaiss04-pyro.pdf
-- 
Douglas S. Blank       Computer Science
Assistant Professor    Bryn Mawr College
(610)526-6501          http://cs.brynmawr.edu/~dblank