[I know it's an old thread, but I'm catching up, and had a few
experiences today that I'd like to share. -- Michael]

Danny Faught <[EMAIL PROTECTED]> writes:

> Vicki Brown wrote:
> > Just to get things straight as I lurk on this thread.  Are we talking
> > "experiential" as the subject states, or "experimental" as people have used
> > in their replies... the two words do not really have the same meaning...
> 
> It's a strange word, isn't it!  My original question was about
> "experiential" training.  (As in, the Association for Experiential
> Education, http://www.aee.org/ - little to nothing about technical
> training there, though.)

This quote from the home page sounds technical:

    Tell me, and I will forget;
    Show me, and I may remember;
    Involve me and I will understand...

> It's encouraging to hear that people have been using some semblance of
> experiential exercises for perl training.  I'd love to hear any other
> examples or experiences.

Seriously, now.  I'm in the middle of teaching a ksh class.  I have a
little "skit" to illustrate the differences between the "intermediate
temp file" solution and the pipeline solution.

  grep green_ink | nl 

  grep green_ink > tmp1
  nl < tmp1; rm tmp1

I pick 2 folks to play the parts of each of the Unix utilities.  I
play the part of grep's stdin by handing grep paper, one sheet at a
time.  Since my pen has greeen ink in it, those with my scribbling on
it has green ink and are passed to stdout, the others get rejected.
The job of 'nl' is to put a serial number on whatever flows through.

In the temporary folder version, I hand them a manilla folder.  As
they quite naturally "open" it, I note that for the class, and again
as they close it.  Then I have the person playing the shell (usually
me) clean up the process and set up the next one, passing the file
folder.

In the pipeline version, I have someone stand in as a pipe.  They have
to accept grep's stdout, keep it in order, and pass something to nl
when requested.  On occasion, I'll have them "fill up" and ask their
grep to sleep, or to "empty out" and have nl sleep.

The simulations contrast/contrast the sequential and parallel models.

I got this idea from doing mailing lists for paper newsleters.
Occasionally, we'd get a whole assembly line going on a line of
tables.  The queues in between the stations (sign, collate, fold,
staple, address, stuff, stamp) just naturally seemed like pipes (or
intermediate temporary files) to me.  We quite naturally scheduled and
reallocated resources to get the job done (after all, we were a 1 or 2
CPU team), and I saw the illustration as useful for a KornShell or
Unix class.

My best Perl example actually crosses many of the courses I teach
(Perl, C, C++, shell) because it's actually related to the short
circuit logical operators.  I assign roles to some folks to act as
functions, then have them stand in line.

$go_to_movies = ask_mom() 
                || ask_dad() 
                || call_gramma() 
                || whine_miserably();

We have fun with it.

I had great results illustrating "guard conditions" (much better than 
$div != 0 && $num/$div) by asking a student to volunteer a hobby, then
asking what is required for them to practice it.  Sometimes I have
them "play act" getting the prerequisites.

$read_book = evaluate_reviews()
             && buy_book()
             && make_time()
             && prepare_tea()
             && (illuminate_room() || find_sunny_location())
             && enjoy_reading();




As my .sig indicates, I try to find ways to add play into the learning
process.  When it works, I'm really proud.  My struggle is to have the
sense of fun be in support of the learning, not a palyful distraction
from it.  My current feeling is that most courses cover way too much
material for students to absorb, and that a force-feeding (liver pate
anyone?) approach doesn't lend itself to playful excursions.  But I'm
always looking and trying different things.

Today was a good example.  I do numerous check-ins by asking folks to
rate various things on a 0- to 5-finger quickie show of hands.  (A
trick I kearned from Mel Silberman, principal for Active Training
(www.activetrainig.com)) For example, "on a scale of 0 to 5 fingers, 0
being complete lack of knowledge to 5 being proficient, how are you in
<insert programming language here>" It's a great way to figure a basis
on the first day of a class.  This weeks' class scored in the low 2-3
fingers on programming background, so I knew that I'd have to spend
more time on most topics, especially flow of control.  When that
lesson came up today, I noticed that one of the students only raised 1
finger.  Bad news!  This was a student that had previously been very
involved, but was starting to fade out.  During a discussion at a
break, without mentioning the low rating, I worked the conversation
around to how he thought I could better serve him.  After listening, I
proposed a new way to work the exercises, and found out that most of
the class preferred it.  Rather than singly (or pair-wise, supported
by an XP promotional talk) working on the examples, we worked it as a
class.  I was shocked at the number of folks that joined in to the
group-wise programming (about 8 of 10), but on reflection I realized
that they all lacked enough prior programming experience to get going
on the overall algorithmic structure of program.  By having them talk
out loud, propose ideas, and talk among themselves, I had them draw
out the collective wisdom of the group.  And of course, it didn't hurt
that I was moderating the white board construction of the class
script.  I'd support quickly inking the ideas that I knew would work,
and (without squashing them) ask questions around the ideas that I
knew would dead end.  I made sure to tell them to watch what kinds of
questions I was asking, not merely at the code we developed.  I played
"lead developer" as a student played "architect" by reading out the
specifications (i.e. the exercise description).  I'd have him read the
whole thing a few times, then have him focus on one or two phrases,
then have them watch as the English language was turned into Computer
language.  I think it worked well.  Drawing on some of my dance
background, I think that what worked well is that the students got a
chance to model my behavior.  That's how I teach and learn dance --
being or watching someone perform the action.  Programming, although
it's very much in my head, can be drawn out for others to observe.
That lets them model behavior.  I think that's experiential.  Perhaps,
like mammals, it's modeling and playing, too.

-- 
Michael R. Wolf
    All mammals learn by playing!
        [EMAIL PROTECTED]

Reply via email to