Tip:
Highlight text to annotate it
X
>> Welcome everyone to today's Techtalk on the Alice programming language. I'll point
out, we have Peter Norvig here today. He's one of the biggest fans of Alice. Peter and
his daughters I believe, right? I'm pleased to welcome my friends from Carnegie Mellon,
who are here today, to talk briefly about the Alice 3D authoring environment. And they'll
show us how it fits into Computer Science Education. As many of you know, Randy Pausch
started working on Alice back in the early 1990s. And these are the folks--this is the
team that he is entrusting with her future. I've known Randy for many years and I've been
keeping a close watch on the Alice team and the progress going forward. Today, we'll hear
from Dennis Cosgrove and the team about the future of Alice. Dennis was discovered by
Randy Pausch. And then I'm told carefully conscripted into indentured servitude for
the Alice project right from the beginning. Dennis has co-authored several papers and
presented at various conferences including SIGCHI. And able to be with us today is Caitlin
Kelleher, an assistant professor of Computer Science at Washington University in Saint
Louis. Caitlin's graduate work at Carnegie Mellon featured the development of storytelling
Alice, which is--which introduces programming as a tool for telling stories. However, we
are pleased to welcome Wanda Dann and Dan Jenkins from Carnegie Mellon. Wanda recently
accepted a position, a faculty position at Carnegie Mellon and now serves as the director
of the Alice project. A role for which she was hand-picked by Randy Pausch. Please join
me in welcoming the Alice team to Google. >> DANN: Thank you. I wish to begin by thanking
all of you for being here today and thank you to Jeff Walsh for arranging this meeting
and to all of you for allowing us to give this presentation today. We want to particularly
extend our thanks to Google for your continuous support of this project. The Alice project
has been a part of Carnegie Mellon University for the last 10 years. And I have been very
pleased to join in that research group. As an overview of our presentation today, we're
going to first talk about what Alice is. Then we will take a look at the current version
of Alice, how it is being developed and researched, and its impact on pre-CS1 and high school
students. By CS1, we mean the first rigorous course in computing majors at colleges and
universities nationwide. Then we will take a look at Caitlin Kelleher's work with a special
version of Alice called Storytelling Alice that she has tested with little schoolgirls.
And finally, we will take a look at the future of Alice and the next version, which will
be Alice 3.0, and our push in to CS1. Alice is a 3D graphics and animation environment.
It has a drag-and-drop interface. It allows the students to create a virtual world in
which they put various objects and then tell a story, create a game, perform an animation
task. You're going to see a demonstration of this environment in a few minutes. What
are the research goals of this group and how does Alice 2.0 fit into or reach those goals?
Well, basically when we began to work in developing Alice 2.0, our goal was to better prepare
students for a rigorous CS1 course. I do want to stress the preparation part of this. We
do this in introductory programming courses in high school and what are called pre-CS1
courses at the freshmen level in college. I do want to make absolutely clear that we
are not trying to dumb down CS1. What we have been trying to do is to better prepare students
to do a good job in CS1 and we want to allow professors who are teaching the rigorous CS1
course the opportunity to actually strengthen the curriculum in that course. So how do we
better prepare students for success in a rigorous CS1 course? Our goal has been to focus on
the fundamental programming concepts. So we aren't really departing from the traditional
kinds of concepts. We simply want to go about preparing students for understanding these
concepts to greater depth. And we also want to make it easier to add into the traditional
curriculum the object-oriented concepts. This has been a struggle for Computer Science instructors
in college and university level because we still have the 14 weeks during the semester
to teach the same traditional concepts we've been teaching for 25 to 30 years, but we are
now adding in the object-oriented paradigm and classes and objects to not make this process
any easier. So we want the object-oriented concepts to actually be easier to learn so
that we can focus on the traditional concepts of decision making, repetition, sorting, the
various algorithms that we all know and love, and we want the students to be good problem-solvers
and we very much like them to understand and be able to use effectively the logic involved
in the programming. As I mentioned a minute or so ago, we really haven't changed the fundamental
concepts that we want to teach. But, what we are looking at is how we are doing that
teaching and what tools we are using to do the instruction. Just to be honest, I started
to teach Computer Science in the mid-1980s. And when I did so, I was teaching in C and
in Pascal. And the first program that I taught was the Hello World program and I'm sure you
recognize that this programming Java is the same type of program. It's just somewhat different
syntax. Maybe a little more complicated. All it does is print out "Hello World". When I
start to teach a class of this type to today's students, what I find is if they looked at
all of this code and they realize on what they have just done is they printed out to
the screen "Hello World" in this little black box. And then they look up at me and they
say, "And this is supposed to be exciting?" I can just take a cellphone and type in Hello
World as a text message and send it out. That's cool. This is no longer considered to be a
cool thing to do. And so really in today's world with today's students who have iPads
and cell phones and all kinds of multimedia in their world everyday, the traditional programs
that are still in our introductory level courses are just not exciting. So the question is
how do we turn today's students on to programming? How do we introduce them to programming in
a very effective way and still not dumb down the curriculum. Well, what we've decided to
do is somewhat revolutionary. We wanted to take the traditional concepts and the traditional
problem solving techniques and not loose those, but add some new ways of going about it. So
we decided to change the design technique to story boards. This is a technique that
students are familiar with. They're very into the animation film industry. They love the
films coming from studios such as Pixar and Disney. And so they understand this process
and we found this an easy way to get them interested in the design. We also wanted to
use program visualization. We knew that the change of state that occurs in the depths
of the computer somewhere were simply not visible. We wanted to make that change of
state visible. To do that, we use a technique called Program visualization. And that's another
talk all by itself. But we also wanted to talk about the highly motivating features
that we felt we could use from Alice, the 3D graphics and the animation. The students
find this very interesting. They do enjoy working with the animation. So what we're
going to do is a brief demo of the Alice 2.0 system to give you a flavor of this. And then
we will talk about did we or didn't we succeed. Dennis?
>> COSGROVE: Okay. So I'm going to give you a little demo of Alice 2.0 which is currently
available for free on the web and everything like that. And this is Alice. And the idea--what
you--I want you to take away from it is it's like the world simplest--it's an IDE that's
designed to make it really easy to learn to program. And so first thing I'm going to do
is I'm going to add in an ice skater. And so I go to our gallery and I scroll over to
people. And I've sort of set up half of the scene. As you can see, there's already this
frozen lake and we're going to have a little ice skating demo here. I'm going to drag her
in. And so then I can move her around in the scene. And what I'm going to do is just set
her up so she's facing this way towards the hole. And I can click on the ice skater over
here in our tree which has all the objects there in the system. You can see that the
ice skater has a number of methods. So what I'm going to do is I'm going to start to program.
I'm just going to drag and drop this method to tell the ice skater to move forward one
meter. And I'm just going to play that and watch my program execute. Okay? And so then
when we're done, let's say after she's--we're going to do a little routine here. So let's
have her--after she's done moving forward, let's have her turn all the way around. And
so I'm able to quickly explore and play and learn to program, but I don't have to worry
about where the commas go, where the parentheses go, if there's a semicolon or a colon, and
those other things. You can actually--you know, we commonly think of things like parallelism
and synchro as being a complicated process, but we just sort of make it complicated. Little
kids actually have no problem at all with handling the Do together construct. So let's
say while she's moving forward, we want her to lift her leg while she's going. And so
we'll select her right leg and have it turn forward a quarter. So while she's doing this,
she'll do a little routine. So if you noticed, I had this little hole precariously located
over here let's place it right in front of her. And right now I want to introduce some
conditional programming. So let's grab the if-else clause. And the ice skater, in addition
to having a whole bunch of methods that, you know, animate and you can watch the state
change over time, also has some questions or functions that you can ask her. And so
let's ask, "Is the ice skater within let's say two meters of the hole?" And if that's
the case then let's just have her move down ten meters. And so now when I play it, what's
going to happen is she's going to go over the hole, skate, and fall. And that wasn't--that
wasn't what I wanted, right? I want--I don't want her to do her turn over the whole. What
I really want to do is have this turn happen down here in this else clause. But because
it's not some hidden data and it's not summing up all the numbers and then taking the average
and at the end, getting the wrong number, not knowing where it went wrong along the
way. It's--you can see it execute so you can figure out really much more quickly where
your problems are. So just to blaze through and get some more things that you will commonly
encounter in a Computer Science class or all the concepts of computing, let's make a new
method and we'll call it skate up to and around, okay? And what I'm going to have the ice skater
do is--in skate up to and around is I'm going to teach it to--teach her to skate around
the red cone. And so that's our first task. So we're going to have it turn to face the
red cone, okay? Let me move the whole out of the way so we can actually get some stuff
on it. I'll move these cones out into the world a little, okay. So first of all, we'll
turn and face the cone and then we'll have her move forward some distance. We're not
sure how much but let's just have her move forward a meter for now. And then we'll drag
this in just like the other methods and have her skate up to and turn around when she's
done with her--move forward, turn, and then she's going to turn to face the red cone and
move forward some amount. And again, we want to--want to be able to use a function here.
And so we're motivated to use functions at this point because we want to know how far
away to this particular thing. So rather than moving forward a meter, let's move forward
the distance to the red cone, okay? And again, I'm able to explore all of these concepts
of computing without having to worry about syntax and everything sort of happens in front
of me. I can watch it happen and kids are able to tell these stories and make these
games that are motivating as well. We don't want to go all the way to the red cone. We're
going to skate up to and around, and so let's drop off a meter from there and then we'll
have her turn left say a quarter and then turn all the way around the cone. And we'll
do that by just using the cone as a reference very much. Sort of a legacy thing from back
when Alice was a 3D graphics system designed for making SIGGRAPH papers a long time ago.
Okay? Further, you can then parameterize this method so you can say "Well, what do you want
to skate around?" And then I can drop this in wherever there's the red cone, okay? Let's
see what I got here. Now let's hook it up to skate around the blue cone instead. Let's
see if [INDISTINCT]. Okay? And one last thing, you can do, you know--a lot of people's first
reaction to Alice is that it's, you know, just a toy and everything like that. But you
can really introduce--you can do recursion. You can do all sorts of things in Alice whatever
the teacher decides that they want to teach. And in this case, I'm actually going to just
run through like the iterating for-loop construct where now we're going to iterate around all
of the cones and have her do a little routine. So that's just a little flare, a little taste
of what the Alice 2.0 system is about and at this point, I will hand it back to Wanda.
>> DANN: Thank you. So as you have seen, we really haven't dropped all of the fundamental
concepts. We've just made those concepts a lot more interesting, a lot more attractive
to today's students. Alice is downloadable from the web. And this has helped us to have
the system adopt--adopted by many schools, many colleges. We'll talk more about that.
One of the things that we found out in our research was that in order to have the software
in use in classrooms across the country, we really needed to provide some instructional
materials. Why is that? Well because in addition to coming up with a 3D animation system that
could be used for teaching, we had to teach the teachers how to teach with the software.
And so we developed many instructional materials for this. And in our philosophy of let's make
it free, these instructional materials are also free for instructors on the web. As with
any good research group, we now have to determine "Well does it work?" "Is it effective in teaching
what we want to teach?" "Are we better preparing the students for success in CS1?" We immediately
found out that it's a highly engaging approach. It's very motivating. We get hundreds, literally
hundreds of emails every semester from instructors around the world. And they tell us that for
the first time in their teaching career, they have students who linger at the end of class.
They have students in closed labs who do not want to leave the room to let the next group
of students come into the lab. The students are quite clearly enjoying the process enough
so that they sneak extra time to work with the software. They download the software on
their own and put it on their own machines and work on it for many hours on the worlds
that they are preparing. Fun? Oh my. Well, what this means is you're going to get the
Statlers and the Waldorfs out there who are going to say, "Well, if the students are having
all that much fun, are they really learning anything?" Well, it's a reasonable question.
Are they really learning anything? So we decided to do some formal studies in which we set
up this pre-CS1 courses. We put in there the students who had the previous programming
experience, who are typically at risk of not doing so well in a rigorous CS1 course. Then
we followed them into CS1 and we did that tell the CS1 teachers who the Alice students
were. These students took the regular rigorous CS1 class and they took the same exams as
every else, and we just wanted to know how did they do. We found their grades improved
by a full-letter grade and we found that the retention of these students following them
from CS1 into CS2 was nearly doubled. Text book publishers tell us that the eight textbooks
which are already on the market are selling like hot cakes. No kidding. One publisher
tells us that their one textbook is now in--have been adopted in approximately 10% of colleges
nationwide. That's a great success story. Backing that up, what we're finding is increased
downloads from the alice.org website. We are approaching one million downloads at this
point in time. So to sum up, what we found was that this no syntax-based frustration
from the drag and drop interface and the fact that the objects are now visible and that
the change in state that can be seen as the program runs and the highly motivating context
of Alice has given us higher achievement and improved retention. So now what we're going
to look at is well, first goal, check. What next? Dennis?
>> COSGROVE: All right. So I'm going to talk about another research goal which is, so we
talked about retaining the students who come into--who want to be CS majors but then end
getting turned away somehow. What we're going to talk about now is "How do we attract more
students into computing?" And with this, I'm going to talk about Caitlin Kelleher's Ph.D.
dissertation. She just received her Ph.D. in Computer Science from Carnegie Mellon.
It's always tricky, I think, when you try to presents someone else's work because it
always gets blended in, you know, especially when they've moved on to a new university
and everything like that. So, one of the nice things about being at Carnegie Mellon is that
you--it's got this great Fine Arts department. So you make friends with these artists who
can draw pictures of your friends. And so this is Caitlin. And I try to--and she would
probably kill me if she realized that was putting this. It's now on YouTube so I'm sure
she'll find out. But I'm going to put a little picture of her in the bottom corner just as
a subtle little reminder that this is Caitlin's work, which is especially important because
now, she's a--she's an assistant professor at Washington University in Saint Louis and
continuing in this arena. So I just definitely [INDISTINCT]. So we have this big problem
where we need more and better computer scientists. And they're just dropping out, all right.
We actually have lost over half of our computing majors in the last seven years, which was
pretty startling. It's even more disturbing, to me at least, is that we have this ever-widening
gap between the men in Computer Science and the women in Computer Science. So, the dotted
first line is the men's coming into--basically declaring themselves as probable CS majors.
And the bottom, we have the women. And what you'll notice, what's really disturbing is
that, you know, we've actually reached new lows here. We actually got the lowest level
since in the last 30 years as far as women coming into Computer Science. And so how do
we address this? And so if you want to get more women into computer science, right, you
have--the basic--the basic idea is that you have to get them early. And that's before
they turn away from Math and Science, which is generally considered to be you have to
get them by middle school. So what Caitlin set out to do with rather ambitious goal was
to build a system that will lure--that will lure middle schoolgirls into programming,
okay. So how you do this? Well, the first observation is that easy isn't enough. And
that, we on the Alice research group were--you know, the other people, you know, the boys
in the group--were essentially just working on making it easier to program. So we're just
trying to lower all the barriers. We're getting the syntax out. We're making this program
visualization. We're just making it so it's easier to learn how to program. This is an
actual quote from an actual 12-year girl who is going to one of our tutorials where you're
going to play with this stupid bunny. And she's like "Okay, so I can move the bunny
around, but why would I want to?" And what Caitlin found was that if you can build, if
you can provide the support for our storytelling, if you can present programming as a means
to the end of programming, you can to actually lure--lure the middle schoolgirls into computing.
And so just as a comparison, there's a whole bunch of really good results that she came--that
she discovered in her dissertation. And I'm just going to highlight a few of them here.
And one of them, just a sort of compare the differences between generic or Alice 2.0 to
storytelling Alice system that she built, is in Alice 2.0, all the objects are created
equal. If you noticed when I brought in the ice skater, I went to the gallery and I went
to the objects and I sort of scrolled over to people because it's listed alphabetically
which when you think of it now, it's pretty embarrassing that people are somehow just
at the same level as chairs. And because we built this system that was designed to be
generically useful for everything, so we have these generic methods that come from our,
you know, legacy of being a 3D graphic system. So we have move, turn and roll, and resize,
which sort of--which are now goes to translate, rotate, and scale from the graphics community.
And these are sort of useful. These are, you know, they're--they make it possible to do
anything but they're not really well-suited to do things for articulated figures like
people which is, you know, something we really want to be able to do. And so she draw this
this formative evaluation where she's got all of these people coming in and using her
system and keeps iterating on it. And she basically determines that what you need to
do to support story telling is you need to start it of with all--it has to be people-centric,
and then those people need to be able to communicate, they need to be able to walk around, they
need to be able to change posture, attend to things, interact with things, which actually
these methods are really bad for, especially when you start accumulating [INDISTINCT] angles
on joints. It's just a disaster. And it's a disaster for everyone, not just on seventh-grade
girls. So, she comes of with all of these methods, she builds this wonderful system,
and then like any good Ph.D. student, she does a summative evaluation. And she gets
these representative students. She draws from the girl scouts to the not so selecting. She
decides this wonderful sort of classic control group vs. experimental group thing. It's really
got all of these clever little things which, you know, I suggest you all go and look into
it. It was really fabulous. I'm just going to point out a couple of little thing, but
just one thing about it. And so while the students are using the two systems, she's
comparing sort of Alice 2.0 as the green bars and storytelling Alice of the blue bars. She
tracks what everyone does. And basically, everything you do in Alice can be pretty much
fit into three categories: doing scene layout, so moving the ice skater around on the lake
if you will; editing your programs; and running your programs. And obviously, if you want
people to be--if you want people to learn how to program, you can get them to spend
more time editing their programs and less time doing interior decorating and just moving
stuff around, that's good. But you actually have to do something to pull them into programming.
And so nicely, if you compare the bars, it's over here in--this is just how much time they
spend in each activity. And you can see that the girls who are in the Alica 2.0 condition
spent a lot of more time doing scene layout than editing the program, all right? We got
all of these people. We draw these girls into programming. And I find it even more encouraging
than that. So if we look at this scatter plot, this is all the girls who are in--all the,
you know, girl scouts who are in the generic Alice 2.0 condition. And over here, we have
the time spent on scene layout. And on the horizontal, you know--vertical axis, time
spent on scene layout, horizontal axis, time spent editing their program. So just to be
a gross metric, lower and further to the right are good, okay? You see this whole population
of girls who do nothing but play out the scene, because either they try to edit the programs
and there's just nothing they want to do or they just don't get drawn into it, but there's
this whole population of girls who don't do any program. The overlay on top of that, all
the girls in the storytelling condition, all of them do some healthy amount of programming.
And as you might imagine, all of the girls in this group learned a lot more about programming
than those girls. So like I said, Caitlin is continuing this research. And if any body
is interested in this whole thing, I suggest that you contact her. This is her web page,
but you can also just type in Caitlin Kelleher into Google or Caitlin Alice into Google or
Alice into Google, or storytelling Alice, okay. So I've been telling you all of these--we've
been going on about how storytelling is good. If you bring it in, you can bring all of these
new people into computing. So I think I'll take this moment to tell you a story. So I'm
at the airport and I got my Google T-shirt on. And I get-up to go to the bathroom. And
you know sometimes when you're waiting for your flight and you've been working and you're
tired and you're not really paying attention and you're sort of spaced out a little. So
as I wake--make my way into the restroom, I'm confronted by all of these women. And
I immediately realized I've walked into the ladies room. So I sort of sheepishly turned
around and start walking back out, and this woman behind me says, "You're feeling lucky,
all right." So there you go. That's an actual true story. So, with that pathetic attempt
at humor, we'll talk about what's next. And so, the biggest demand that we get from Alice
right now is from CS1 professors. You might--as you might imagine, you can show people that
if you add a new pre-CS1 class, you can improve everyone's grades and retention. And everyone's
like, "Well, that's fine but I either can't or don't want to do that." So what a lot of
people want to do is simply take Alice and use it for the first couple of weeks, introduce
them to the concepts and then immediately get them to a professional programming language.
And whether or not you think that's a good idea or not, I personally would think, you
know, you could wait longer. But whatever they want to do, we're trying to support them.
The problem with this is that if we get--when we get feedback from people right now, this
is what they're having their hardest time with is that they're able to introduce people
to the concepts of computing and that's working really well and it's helping them. It's obviously
helping them. Their grades are going up by a full letter grade later. But if you think
about it, we've just taken out one part of the problem. And then when they--when they
get--when they go to move to Java, what happens is all at once, right, [INDISTINCT] with the
syntax, then some professional IDE, which is really complicated. If they're lucky, there
are actually a lot of people who still use Makefiles in CS1. They change the API on them,
so they're used to using, you know--they're used to telling the ice skater to move and
turn or use these higher level methods and all of a sudden, we change that on them and
we force hidden datum--hidden data on them as well. So we take out the program visualization,
do all of this at once, and you actually have this, you know--it's better than not having
Alice beforehand, but it still could be--it still could be better. And one of the big
mantras for the Alice project is one hard problem at a time. And so, like we've said
before, we don't want to dumb down computer science. We're not trying to make it out like
this isn't a field without its challenges. But the way I think of it a little bit is
that it's like, if you want everyone to be able to park an 18-wheeler at the end of your
course, the way we approach computer science is a little bit like we sit them down in the
18-wheeler on day one of the class, have them deal with everything from day one, and say,
"And look, some of them make it through at the end." Another approach would be to start
people off in an automatic little compact car and get them familiar with that. And once
they get--they can deal with that, they move on to the standard transmission, "And okay
you've got that, and now we want you to deal with just the tractor. We're not going to
put the trailer on as well," and then we add the tractor and the trailer. And I like this
analogy because--a little bit because a lot of people think syntax is important, right?
And to drive an 18--to park an 18-wheeler, you do have to know how to do a standard transmission,
right? But once--you don't have to handle them all at once, right? And once you've got
the standard transmission down, it really isn't a problem there on out and neither is
syntax really. It's just a problem at the beginning. All right? Once you've got it down,
it's not really a fundamental problem. So what are we going to do? We're going to apply
all the lessons we've learned from--and build Alice 3.0. So we're going to keep the drag-and-drop
to prevent syntax errors. We're going to keep the program visualization. We're going to
have--we're going to have this transition to Java which is going to be--going to make
it so that people can just seamlessly move on. And we're going to provide the storytelling
things, so we're going to focus on the people. We're going to have all these higher level
animations. It's going to be all these social animations. We're going to let people create--there's
going to be all these characters that they can make in their own image. It's like, "How
are we going to pull all this off?" is the real answer to the question--or the real question.
If you look at it, these are the sort of things that you're your sort of typical academic
computer science research group can do, right? But to do this right requires a lot of modeling
and animation talent, a lot of artistic talent that you don't typically have. And so, it's
right about this time that Randy comes to me. We're like talking about doing Alice 3.0
and he's like, "I've got a shot at getting all the assets to the Sims 2," which to me,
at the time, seemed about as likely as this incredibly ambitious spider's plan. But the
spider is right. If we pull this off, we'll eat like kings. And as I've already alluded
to you earlier in my embarrassing story, I'm feeling lucky. So, let's go. And for those
of you who don't know much about the Sims, I certainly didn't at the time. I hadn't played
it before, but I started playing. The Sims is the bestselling PC game of all time. It's
the bestselling franchise. And unlike most of the things on this list, it actually has
more female players than male players. And when this whole thing was starting to come
to reality and it looked like it was actually going to happen, I started playing the Sims,
and I got to see exactly why. It's absolutely the perfect match for what Alice wants. And
so, when it was becoming a reality that this was actually going to happen, people at EA
actually they asked us, "Was there a different game that you'd rather have?" because maybe--you
know, they make a lot of games. It's like, "Is there something else that would be better
suited?" And I was like, "No, it's perfect." And the reason why it's perfect is not just
from all the things we learned from Caitlin's research, but there's also this called "Unlocking
the Clubhouse" which is a really--it's a great book and it's been very influential on me
and it really opened my eyes to a lot of the reasons why we had this gender imbalance in
computing. But they described this study by Brenda Laurel at Interval and one of the things
they determined was what would be the ideal adventure game for girls. And it would have--it
would--it would basically take place in everyday real-life settings, it would have new places
to explore. It'd have a strong storyline, but the characters in it would be everyday
people, as real to the girls as their best friends. And success in the game would be
determined by development of friendships, which is exactly what the Sims is. It's just
a perfect match. And so, one of the things I want to make sure I emphasize is that, you
know, we're talking a lot about how we're going to make this so that we can attract
girls into computing. But just like the Sims seems to have this characteristic that you
can bring females in would not turn away the males. Alice also seems to have this property
where you can provide these higher level animations, provide the storytelling theme, bring in some
of the girls into computing, but not turn off the boys. Okay. So why would electronic
arts do this, right? The first thing is never underestimate the power of executive vice-presidents
who have middle school daughters who've just turned away from math and science. Okay? It
really hits home. You show them the results of Caitlin's work and they know exactly what
you're talking about. Their daughters just--you know, they were fine, they loved math and
science, and all of a sudden, middle school hits and they decide it's not for them. And
the other thing is that they believe--that they determine that it's in their best self
interest, right? It's in their vested self-interest to improve the talent pool because they hire
a lot of computer scientists so if they can make--if they can bring more and better people
in, then they'll have better people to hire. And they're also--they're especially concerned
with bringing more women into computer science. You know, they want to bring more girls and
women into computer science so that they can hire more women to build more games, then
maybe they can tap better into the female game market. Okay. And what--so what is Alice
3.0--Alice 3.0 going to be? Okay. Just to reiterate, it's going to be drag-and-drop,
program visualization, line for line Java. So when you're executing things, the old Alice
sort of had its own virtual machine and sort of interpreted things and had its own way
of doing things. But like we were talking about earlier, like when you want to do overriding,
how do you do overriding? You just override. It's going to be Eclipse underneath so that,
again, to facilitate this transition to--when the--when the professor decides to do that.
We know the storytelling theme from Caitlin's dissertation. I'm going to use the Sims 2
assets to pull it off. We're on track for having our alpha test next fall; it's at Carnegie
Mellon and Ithaca College. In the next semester, we're going to open her up to a wider beta
test. And one of the things we found that works really well there is the reaction to
just demoing Alice 3.0 is you can show them in any half baked form and they just want
it. And so when you have a lot of people who want to use it, you can basically make them
assign a bug catching TA to each class so that a lot of times, what happens when you're
in a classroom and the software has bugs in it, the TAs will want to help the student
get past it because they've already wasted some time and--which makes sense. I mean that's
good. But while you're in the beta testing part of the process, you want to have a TA
who's solely responsible for going around, finding a bug, helping chronicle it and sending
it in to us so we can fix it. And so with that, I'll give you a sneak peak into Alice
3.0. There you go. And so, oops... So the first thing that, you know, as I said, on
the slide, it's going to be ready for alpha next fall. So as you can imagine, it's not
all done. So I'm going to show you a number of pieces to the pie, and hopefully you could
be able--we'll be able to pull it all together at the end. And this part is just to give
you feeling for what it's going to look like. This isn't exactly how it's going to look
like--what it's going to look like. But, you know, we'll have, you know, the--you'll have
the sort of the scene that you're working on over here in the top right. We're actually
able to--if you recall--and Alice 2.0 is actually kind of busy, right? There's a lot of stuff
going on. And what I like about this system is that it's becoming more complicated underneath,
but the interface is actually becoming simpler. And because we are going with these higher-level
methods and people-centric approach, we can get rid of that whole tree where you had to
see the skeleton of everything and all the cones and all these other things and just
go with the people. So you can actually collapse these two things into the same. So here we
have the methods, you know, actions, questions and properties and you'll be able to pick
up and drag and drop and all that other good stuff. I'm going to show you a little bit
of how it's going to react because although Alice is pretty successful, it does a really
bad job of giving--no, it doesn't do a good enough job of giving enough feedback. So just
giving people a little bit more feedback on, you know, how it's going to look. This is,
again, just a little demo of how it's going to feel. Another thing is--oh, and just to
let you know, this is a little bit of a demo I'm going to show you in a minute which is
a daughter trying to [INDISTINCT] her dad to get into shape. Another thing I'm going
to show you is just having these docking bays and trying to give people cues about type.
And so, for instance, you know, this is whether or not the daughter is facing something. You
can see like the Boolean things would light up and go in there where that goes, and again,
if you look at the dad, you'll be able to--you know, when you pick this up, the dad's name
is a string so it fits into the string docs and everything like that. So we're just going
to try to give some people some feedback there. Moving on, I'm going to show you just the
person builder. This will just give you a little a feel for just how many--you know,
just the vast change in the content that we're going to be able to have. So, first of all,
there's a new problem right there is that, you know, when you have a games thing and
you try to bring it into middle school classrooms, the female outfits are going to have to be
culled a little. It makes any sense? For adoption, one of things I like about having all these
things, we have these--there's all these males and females characters, there's a superhero
character. One of the things it's--that--this is actually kind of embarrassing, but when
we first made Alice--when we first made Alice, we had all these freely contributed models
from this class at Carnegie Mellon and it was great. But all the models and--all the
models and animations were sort of made by students at Carnegie Mellon and that's sort
of a narrow subset of the population. And so then it was used at inner city schools
in these after-school programs and they couldn't make anybody in their own image. That's really
bad and embarrassing for a lot of reasons, but it's nice to be able to have this--have
their all assets because you can make--kids can make these characters in their own image.
They could be male or female and I really like the ability to be able to say that everybody
can be the ambulance driver, right? That we're not steering anybody down any path. And just
to sort of overreact to the whole thing, we made it so you can make green people now and
everything just because, you know, it's really bad to not be able to do it. So, for the purpose
of this demo, we're going to have a daughter. We have a little story we want to tell. The
daughter is going to try to deride her dad to get in shape. So let's get the dad an outfit
here. Personally, they're just--my personal favorite is the--where is it? The red smoking
jacket. Very nice. But let's get him a sweat suit. We gave him the blue walking outfit.
I'll change his hair color here and give him the old--the old chrome dome so it's kind
of, you know, a dad sort of situation. And again, this is just a very--a prototype that's
going to be--hopefully, it'll be much smoother than this eventually. And when we accept this,
again, this is sort of behind the scenes but it's going to generate the code to insert
this into your world, if you will. And the students won't see any of that, but there's
actually Java instances that back each of these things to make this dad. And the next
piece of the puzzle--and this is a prototype that is running on top of Eclipse, so Eclipse
is now--for those of you who don't know about Eclipse, Eclipse is this fabulous integrated
development environment. But it's definitely--it's wonderful at helping you manage the complexity
of a million line program and it's not good at all for your first introduction to computing
when you're not--when you don't have to do a million line program. So, what we want to
do is we want to use their framework to build the ID that's designed specifically for learning
the program, and so you can see here we're sort of--we're parsing arbitrary Java 1.5
code and you can sort of pick up these blocks and move them around. And you can press play
and you can see this world play out. Actually haven't shown you this yet, so I'm going to
show it to you. So need to shake--get in shape, Dad. I'll move it over here so you can see
the world. Then he's going to loop three times, he's going to do a sit up while she counts
it out. And then, like me, he'll get a little tired. And, you know, she'll sort of ride
him and then he'll start doing--do another loop and he's going to put in a little conditional
thing where if the daughter is facing him, he's going to sort of show off and do these
one handed push-ups. And if she's not facing him, he'll kind of slack off. And it's whoops.
Okay? And so, there is some concern when take out all these lower-level methods that people
will still be able to program, still be able to do things. But in 20--you know, in basically
10 lines, you'll build a little story where people laugh at the appropriate moment. And
so, that's really encouraging. And you can change these. This is just a little demo but
you can change this thing to do ten times and it does all the incremental compiling
and everything and it will run at 10 times this time. But that's just a little technology
demo. I can speed it up. There you go. And for just the last little example of it--but
you can imagine, since that's in Eclipse, the eventual--for those of you who know Eclipse,
the eventual thinking--the eventual plan is to be able to just--okay, so the professor
decides we've done enough of the concepts; I want people to actually learn the syntax
of Java now. They'll just be able to turn essentially into Java perfective and just
start typing in Java. And then maybe at some point, they decide, we want to go back and
learn about the iterating for loop, they go back into Alice drag-and-drop. And the thing
about this is you just have to worry about one problem at a time, right? You don't switch
your--don't switch the classes that you're working with, the API like everything--all
the data doesn't become hidden. You just take on one problem at a time and you march towards
getting people fully prepared. And so, the final thing is, of course, that then here's
the Java code behind it and you can, you know, say something like, "Dad, you really need
to get in shape," and something. And eventually, you know, that could just go all the way out
and be in Eclipse or some other ID. Well, who knows why [INDISTINCT] but there you go.
And so just to some up, okay? What we're aiming to do--what we're aiming for is to be the
way everyone is introduced into programming, okay? We believe that if you're going to be--if
you're going to learn to program at any level anywhere, your first exposure to it should
not be with syntax and all these other--and hidden data and all these other things; that
everyone should be able to start out this way and then transition. Okay? And this is
rather ambitious, but with all the incredible positive feedback we received from the previous
versions, we have reason to believe this and I hope you do too. And with that, I would
like to thank you very much for your coming, your time, your attention, your support. Free
t-shirts and we'd be happy to take any questions you have.
>> [INDISTINCT] >> COSGROVE: Okay.
>> You know, you've done a lot of work on it. What do you see as part of the strengths
>> COSGROVE: I really like Carol. I learned--the first thing I ever used was Carol. It was
actually a Carol interface with the Alice. And so that's a little point to say is that
people want to teach different ways. But we're going down the story telling route. If somebody
wants to go down the Carol route or the Logo route, we're going to try to support those
as well. If somebody wants to go down the games route, if somebody wants to go down
to Google's API--Google Maps API route, right? Or the physics route, so were going to try
to support all those things. I love Carol but what Caitlin would say is that that doesn't
draw enough people in. I also love Logo, right? I also love Squeak. But that--in some ways,
those things don't draw people in enough as the story telling things. It worked for me;
I think it's fabulous but it isn't inclusive enough, I don't think.
>> DANN: So, if I can jump in on this, I would like to say that we feel like we are standing
on the shoulders of giants. >> COSGROVE: Yeah, definitely.
>> DANN: And we owe Rich Pattis a lot for Karel Robot. So, that said, I would also like
to say that I think what we're going to see in Alice 3.0 is a progression to a point where
we can move back and forth between the Alice interface and the professional language IDE.
And that was very difficult to do with the versions of Karel Robot. This is probably
a pedagogy point, but nonetheless, that's we're trying to do is to teach.
>> DANN: Okay. >> There seems to be a really big overlap
in Scratch. >> COSGROVE: Yes.
>> Scratch is 2D. >> COSGROVE: Right.
>> But are there any deeper certain sort of differences in your code [INDISTINCT] there,
at least until you get to the issue of this transition to, you know, CS1.
>> COSGROVE: Well, I think there's definitely a lot of overlap and that's because of Squeak,
which we both--I mean, everyone who's been a student in our research group has ended
up doing a internship with [INDISTINCT] almost. I think one of the things is the approach,
that we latched on, at least, at Carnegie Mellon in the--we're going to team with a
pedagogy expert whose going to write a textbook and make it so that we're going after this
formal education part. And they are more of the play thing. But I am a big fan of, you
know, of that whole thing too. >> [INDISTINCT] sort of a transition [INDISTINCT]
>> COSGROVE: Right. >> I could see a transition sort of from Scratch
to the Alice. >> COSGROVE: Yup.
>> And then to, you know, more formal [INDISTINCT] >> COSGROVE: I think one of the things is
that, you know, you have to--it seems that the status quo isn't working and something
has to be done differently, and I don't know if that's Alice or Scratch or whatever. But
we're certainly going down this road but, you know, obviously big fans of, certainly
Squeak and Scratch. >> DANN: I think there are many of us working
on this problem and we are fans of Scratch as well.
>> COSGROVE: Yeah. >> Some of these girls and boys can read this
message differently. >> COSGROVE: There's actually a--so go ahead.
Sorry. >> DANN: We have really highlighted today
for you our appeal to girls and young women. I, however, have been in the classroom teaching
with Alice for several years now and I have found that the guys are just as turned on
by Alice as the girls. The guys have very different context for the stories they tell
and they prefer to build with Alice interactive games. And as much as we have tried to tone
this down, there's only one gun in Alice in the gallery. Nonetheless, they find ways to
tell the stories they want to tell. It's rather interesting, however, that over the course
of the semester, they tend to be very, very creative and come up with things that are
not just shoot 'em ups. >> COSGROVE: The other thing is there is actually
a--it seems all the anecdotal stuff they comes in seems like it's bringing in the women but
it's not turning away the men because, you know, everyone wants to direct or whatever.
But there is a study in the plans to do the same study with the Boy Scouts, so that you
can formally show that these things are happening and that's in the--in the pipeline.
>> DANN: Do you have question? Go ahead. >> COSGROVE: Go ahead.
>> In the access tool in the exact sense with the [INDISTINCT] did--how did this affect
your system, the operational, you know, specification of the machine. And did it--did you have transition
issues? How does it work in the [INDISTINCT] >> COSGROVE: Well, it's surprisingly--well,
my first--I was really surprised at how well it ran. First of all, the whole thing is rendered
in Java and all these other things. But then I realized that Sims is a game that's designed--like
it runs really well on a five year-old laptop, because the Sims 2 came out more than five
years ago. So the assets of design to run--so it is a much more complicated--I mean, it's
doing real time skinning algorithms and all these other things. But it really--I thought
it was going to be more of a problem than it really was, because it's designed for older--it's
designed for an older machine. And it's also designed--it has levels of detail so you can
fall back to lower level models and textures and everything. So it hasn't been as big a
problem as I thought it was going to be. >> Well, I think you have done a great job
on it and it's a, I mean, excellent tool. A little theme going here is are we raising
the expectation, like, I mean, too much? Like, I mean, writing a program, I mean, like being
in the middle of school and then moving these objects, but then later on, I mean, asking
that the same person that can be spending, I don't know, like days, two hours, like the
>> COSGROVE: I think one of the things is that if you're shooting for the middle school
age, what I'd really like to--you know, you could almost take the exit condition from
that being they just know that they can do it, that they just have the confidence that
they know that they can do this and that you can do cool things in computing. It doesn't
all have to be whatever. If you just had that one thing, right, that would be almost be
good enough. But also, I mean, there are--there are hard problems in computer science. It's
not like somehow dragging and dropping is going to make synchronization of, you know,
multiple threads kind of all of a sudden, become easy. But the idea is to get more--what
we want to do is we want to stop having to filter beyond the long things. If you're filtering
people because they can't handle logic, well, then that might be okay. If you're filtering
people because they get frustrated because they used a colon instead of a semi-colon,
that seems really dumb that they're able to handle synchronization in, you know, multiple
nested, you know, conditional statements. Sorry.
>> DANN: I also would say that although we have talked today about computing majors,
it is also the case that that first course in computing is for non-majors. And that means
that you have people who want to learn how to use computing to do biochemical research,
neurology research so, you know, they want to be physicists. All of these other majors
are taking this course as well and we need to make it accessible. And so, I think looking
at this broader range of population is very important for us. One thing we didn't say
about Alice 3 is because it is implemented in Java and because the students will transition
into the Java environment totally, we anticipate that many researchers will build what we call
thin APIs to allow them to assign to their students problems in engineering and problems
in Physics and so forth and so on. And that, we think, is very interdisciplinary part of
this project. >> COSGROVE: It would also be nice if you,
you know--when you're talking about having these other people who are not intending to
be computer science majors, it'd be nice to show them that--to draw them into computer
science and be like, "Oh, maybe I don't want to do biology; maybe I want to do computing."
We can get better--more and better people into the field.
>> Do you feel that you address the missing piece that Peter [INDISTINCT] was talking
about? Could you respond to that? I think you've heard them earlier ask this question
and... >> COSGROVE: So what's the...
>> DANN: Basically, he was concerned about the fact that Alice 2 is not truly object-oriented.
>> COSGROVE: Oh, right. >> DANN: Meaning that it is not fully implemented
so you can't do Inheritance in Alice 2.0 for example. But because we're moving in to Alice
3.0 with the Java underneath and the line for line equivalency between the Alice code
and the Java code, we believe that as much as Java is object oriented, so will Alice
3.0 be object-oriented. >> COSGROVE: Thank you very much for coming.
>> DANN: Thank you so much.