Re: [kidsUI] About me

[Terry Hancock <hancock@earthlink.net>]

Okay, I think I see where you're coming from, Sanjay. This much
I understand.  I guess I thought that "software agent"
technology must have progressed further than this, meaning 
that you would have meant a narrower definition of the word,
in the same way that "Artificial Intelligence" which used to
mean *any* method of emulating intelligent action on a 
computer has come to be identified exclusively with "Expert
Systems" (and not, say, with "Fuzzy Logic" or "Neural
Nets").

Sanjay Chandrasekharan wrote:
> I think I need to elaborate a bit on my interests and the way I ended up
> in this list.  As I mentioned, I am interested in software agents. What
> exactly a software agent is is still quite unclear, just as it is
> unclear what exactly a human agent is. However, there seems to be a
> general agreement that the agent concept is useful as a high level
> programming abstraction. This is the same story as with objects. No one
> really knows what an object is, but everyone finds it quite useful in
> programming.

Yeah, I want to give an operating system "emotions" as well.  But
maybe that will make more sense later...

> So far so good. Now, if you look at desktop interfaces, you can see that
> they are organised as objects. Programs sit around till someone does
> something to them. Now, fortunately or unfortunately, agents have a
> property that goes against this intuition. They do stuff on behalf of
> the user. Simply put, they are not idle, and they can change their
> characteristics over time. This makes them kinda hard to represent on
> the interface using the conventional object method.
> 
> Cut to the much-hated MS Office Agent. I hope everyone knows this guy.
> It is the animated character that comes up when you do stuff on MSWord
> and other office software. Unfortunately, this irksome character is the
> epitome of agent technology as people perecieve it. And people just hate
> it! (Just like MS to screw things up!) It asks stupid questions and does
> stuff that insults people's intelligence. But, interestingly, people
> hate it even when it gives them the right advice!
> 
> I wondered why this happened. People are quite comfortable with animated
> characters on screen and love them as desktop pets and stuff like that,
> but they hate when it an animated character starts giving them advice.
> My reasoning was: right now we perceive the machine environment as
> consisting of dumb things that sit around until we want those things to
> do something. The character was working against that protocol; it acted
> on its own volition. It was this that people hated. It was doing things
> that went against the mental model the user had of the machine
> environment.

I understand this perfectly.  The problem is this: Agents are
intrinsically
stupid.  People know this.  This is because they are AI, and AI isn't
Human.  The only time they are useful is when: 1) you are stupid too (as
when you are using a completely new environment), or 2) you are not
there
to supervise. 

If you DO know what you're doing, it's really annoying to have some
little
two-bit sprite telling you what you already know!  Also, since you're
coming from this chip-on-your-shoulder attitude about the incompetence
of little AI beasts, you tend to distrust the advice, thinking that
the agent is going to lead you in the "Computers for Compleat Idiots"
direction.  I think distrusting Microsoft's computer agent is pretty
much the same as distrusting Microsoft, which essentially everyone
does (even serious Microsoft users usually don't trust the
company's motivations, these days, IMHO).

These things are okay for BRAND NEW USERS, because they are stupid,
they know they're stupid, and they are ready to learn from even a 
stupid agent, if that's what's available.

For EXPERIENCED USERS, this is a real problem, because a new paradigm
means that you can't depend on your old experience as much.  For
example, we tend to assume that a program will be arranged in the same
way all the time. If, for example, it "adapts" to our writing style
or something (e.g. configuring itself to go straight to what you
need for business letters if that's what you do all the time), then
it will be hard to change to something else (writing a novel, say).
This is something I found fairly annoying in Star Office and 
Emacs -- both try to "correct" what you wrote. The point is it 
becomes less predictable: now instead of having to know what you
want, you have to a) know what you want b) know what it thinks
you want and c) know how to tell that isn't really what you
wanted after all.  Yes, but does it know that you know that it
knows? :)

People are like this too, of course, but they are also *vastly* more 
intelligent than any software agent, so you tend to trust them
more (although some people are using the computer themselves,
precisely because they _don't_ trust someone else to do the work
for them -- and if they wouldn't trust a Human, why should they
trust an agent?).  BTW, I hope you guys realized "agent" was a pun
in The Matrix, right? :) That should tell you something about the
level of trust you're going to get.

> So my reasoning was: the only way an agent can make sense on the desktop
> is to change the whole desktop idea, and replace it with an environment
> where agents can exist, an environment where the general metaphor for
> programs is not objects, but active entities. The user will then be
> intercating in the true sense of the term, like you do in a video game.
> Obviously, you can't do this with Windows and Mac interfaces. The only
> option available was Linux. I figured Linux was a good candidate for an
> agent-based operating system.

The reason this doesn't bother us in video games, IMHO, is that you
are not depending on the outcome in the real world.  Also, you know
that agents in the game won't fiddle with your stuff outside of 
the game.

I think it's this insecurity about what the agent will do that is
probably most annoying.

[ I should probably mention that I've never seen the MS agent software
Sanjay is referring to, so I don't really know what it is capable of]

> Remember, I am not saying that we should replace the components of Linux
> with Agents! I am just saying that the interface for Linux could be
> organised in such a way that people would perceive it as being
> agent-based, instead of object-based. Just think that we are animating
> the OS -- people will see it as having a penguin inside it.(Refer to my
> earlier posting about the file transfer animation).

I can imagine a useful agent would be a Software System Administrator
on Linux (or a Linux-like) operating system, for situations in which
it is impractical for a Human sys admin to be available.  Home PCs are
one such place, but I'm also thinking of embedded applications, such
as might be found in intelligent robots.  You can imagine for example,
a package manager which maintains usage stats on packages, and decides
to uninstall non-critical packages if they are sufficiently rarely
used, especially if disk space becomes a problem.  They could also
monitor common "security holes" actively, and report problems to the
user via a sprite character.

Of course, one way to make people like the agents better, would be
to make them less "authoritative." I haven't seen the Microsoft
agent Sanjay refers to, but I'm visualizing a cartoon guy in a business
suit looking like the "friendly, benevolent, benefactor" type. What
you really want, is an Igor that walks around, says "Yes Master",
and bows and scrapes a lot -- you know, the correct attitude for
your computer to take. :)  Of course, a dopey looking Penguin, could
work too.  The point is, make them non-threatening.

> I talked to someone about this in some detail, and this person was
> invited by Doug to join this list. She couldn't, join, but she forwarded
> the mail to me. I saw that the kids UI idea fitted perfectly with what I
> was thinking. Kids don't come with preconceived notions about what an
> interface should be like. So I decided to push for "my imagination in
> long threads about the revolutionary idea" as Kojima put it! :-)

Kids are automatically new users, of course, so that would help. Also,
they are less easily offended by having their computers tell them what
to do, I suppose.

***

If you think about it, the command line is kind of agent-based, since
you tell a program (an agent?) to do stuff for you, and it goes and
either does it or tells you why it can't.  An animated sprite agent
could simply tell you this in a friendlier way.

A really cooperative agent would learn how much detail you wanted to
hear normally by paying attention to how long you listen before punching
the "enough already" button and asking it to do something else. Or,
you could ask it for more info.  If its just run a piece of Unix
software -- it could always run it in "Verbose" mode in the background,
but only give you the details if you ask for them.  It could use 
an AI to suggest related commands, or suggest different command
switches if it can figure out what it thinks you probably meant
to say (for example, if in my case, I told it to write to my CDROM,
it might ask me if I really meant my CDRW drive, etc.).

> I have a feeling that people haven't really bought the idea. Since I
> don't have anything much to bring to the group besides my revolutionary
> idea, maybe I should now shut up, instead of wasting bandwidth. :-) So
> now I will be lurking for sometime, for a change. Mostly because it is
> term paper time!

I can imagine that the idea has a limited range of applicability
as yet.  But "always in motion is the future," as Yoda would say.
I think there might be applications.

Oh yeah, I mentioned emotions.  I'm thinking of case (2) above, 
"when you're not there to supervise". I've been doing a lot of
thinking about operating systems for semi-autonomous robots
lately.  In that situation, there is no user, so the only agents
ARE software agents.  I've been following MIT "behavior language"
research, and I think you could maybe design a robot operating
system around that kind of paradigm.  In that case, "behaviors"
are pretty much "agents" and much of this stuff should cross
over.  I'm envisioning systems in which a lot of compute cycles
are used for "self-maintenance" like my software sys admin, that
I mentioned above.  One way to abstract behaviors is to couple
them to emotional states, and couple stimuli to the emotional
states (using fuzzy rule bases).  This provides an extra layer
of programming abstraction, since I can now talk about "fear
behaviors" or "idle behaviors" etc, instead of specifying exactly
what conditions trigger the behavior.  This obviously begins to
model the robot as an agent, rather than simply as a bundle
of stimulus-reactions.  That's why I mention it.  This is getting
off the Kids UI topic, though, so I'll stop.

> 
> All the best,
> 
> Sanjay
> 
> -------------------------------------
> Sanjay Chandrasekharan,
> Ph.D Student (Cognitive Science),
> Carleton University,
> Ottawa, Ontario,
> Canada K1S 5B6
> Phone: 520-2600 ext 1568
> 
> http://wabakimi.carleton.ca/~schandr2

-- 
Terry Hancock
hancock@earthlink.net
http://home.earthlink.net/~hancock/index.html