Alice Community - Recent Updates Alice 3.0

Whew. An update on Alice3’s progress could take quite a while. That’s a good thing, I guess.

Somehow, some way, Randy convinced EA to donate the Sims2 assets to the Alice project. This is very exciting on multiple fronts. Sure, it will mean that the visual quality of our content will get a significant bump up, but more importantly (in my opinion) it will allow us to provide a bunch of high level commands. The Sims characters have a consistent skeleton. That alone is a beautiful thing. In addition, they come with a ton of key-framed animations. It will take me a while to support everything, but in the end, students will be able to direct characters to walk around and interact with things and each other. Things will look a lot more like:

ricardo.giveHighFiveTo( meg )

than

bunny.turn( LEFT, 1.0 )

Not everyone is as excited about this prospect as I am. Instructors seem to like the fact that they can motivate methods by having students build things like walk composed of joint turns. Personally, I abhor Alice2 for many reasons. The go-ahead-and-deal-with-the-accumulation-of-Euler-angles problem is particularly egregious to me. I think of it as “the new assembly language” that we have foisted upon poor students everywhere. I am sensitive to peoples concerns, however. Don’t worry. I am more than convinced that I can’t simply provide *all* high-level calls. My hope is though, that if I provide a way for students to move characters’ hands, feet, etc. instructors will still be able to motivate and teach the concepts they want. It’s just that in this new world order, I will be doing the kinematics, instead of students struggling with tweaking the joint angles. We’ll see how it goes. More than anything, I don’t want to destroy what is working in Alice2 (as shamefully crude as it may be :-) and I will be particularly vigilant on this front. Also, people should look forward to “touch” and “keep touching” as building blocks for authoring higher level methods. This and more of the Alice3 plan is inspired by Caitlin Kelleher’s excellent PhD dissertation work.

Aside from the higher level API, the fundamental structure of Alice3 will be different. First of all, there will be no more Alice virtual machine. Worlds will be Java programs executed like any other program on the Java virtual machine. So, when students are authoring methods in Alice, they will be authoring actual Java methods. When they invoke a method it will execute to completion like any other. Slicing and synchronizing with the renderer will happen within the Alice methods. In exchange for parsing arbitrary Java code and providing a drag and drop interface to the abstract syntax tree, a bunch of things should be easier. First of all, all of the capabilities of Java should be at our finger tips. So, we should be able to provide a truly object oriented system, as opposed to the object based kluge that is Alice2. Implement the kick method on the class Rockette (as opposed to copying kick and editing it from instance to instance in Alice2, only to then not be able to iterate over a list of them and invoke it (RRR!) ), override methods, whatever you want. It should all be possible. Now, how much of this “power” gets exposed to students will be a matter of preference. I can certainly see one flavor of the system exposing classes and instances and another flavor that hides the concept of class under the covers. Which brings me to…

We still have at least two very important audiences, in my opinion. A Pre-CS101 audience (whether that be in high school or college), and a younger (say middle school) audience. Pre-CS101 is obviously more concerned w/ transition to a real programming language like Java. Alice3 should be able to facilitate this transition. The plan is to build the new authoring tool on top of the Eclipse framework. An entirely new application is in the works (in fact a gold spike of this has been completed… just to show that I’m not completely insane and that we can reasonably expect it all to work) as opposed to simply plugging into Eclipse (although this should also be possible with the way it is being segmented). I’m opting for the extra work of the stand alone app because I believe the prospect of dumping the awesomeness of a full-fledged professional IDE onto novice programmers is a bit too overwhelming. Hmmm… how do I put this? Eclipse is wonderful at helping professional software engineers manage complexity. We want to hide some of the complexity. Does that make sense? Anyway, I see there being a need for at least two major flavors of the authoring tool. One flavor which is concerned with supporting an impending transition to a real language like Java. Another which simply wants to expose students to the concepts of computing, build confidence, teach logic, allow children to tell stories, etc. It is reasonable to expect that these two systems should look different in many ways. One such way may be how classes and instances are exposed, as I was discussing earlier when I got into all this mess. :-)

I’m sorry for the rambling nature that is this post, but I really should be getting back to work (rather than wordsmithing this post), so that we can kill the ugly beast that is Alice2 and replace it with the magic that will be Alice3… a system that will support, among other things…

the ability to go back and forth from drag-and-drop mode to straight up typing in Java mode. This shouldn’t matter at to the middle school students at all, but I can envision a Pre-CS101 course starting off dragging and dropping, then transitioning to typing and dealing syntax, then maybe sometime later, when the instructor wants to introduce a new concept… oh, I don’t know, maybe for loops or something… they go back into drag and drop mode for a little bit. I don’t think that’s the most important thing in the world to support, but it should be possible. More importantly (in my opinion) is the fact that when people do transition, they will be able to use the same API. I say having to deal with the syntax is enough of a problem. Why tax them with a whole new set of classes and methods, to boot? Which brings me to…

There is an Alice-2.1 under development. It is concerned with facilitating the transition to Java while the world waits for your humble narrator to build Alice3. There is an AliceObject class with move, turn, roll, resize, etc. methods. The gallery has been converted into hundreds of classes that each extends AliceObject. There is a Program class to extend with initialize and run methods to override. It has been very encouraging. The experience of extending a class and having it all work (because it and everything else one wants to do it just Java) seems to be quite liberating for people who are used to being shackled by the limitations of what Alice2 provided. Work on Alice3 has been slowed somewhat by this side project, but I am hopeful that this effort will pay great dividends. The pedagogy side of the Alice effort can start to get their heads wrapped around what the new world order will be like. Not to mention that the Alice-2.1 Java API is being built on top of my new Alice3 linear algebra and scenegraph code, so it is serving as a good forcing function for getting my infrastructure to work nicely. Besides, this will give me a functional API to test out the new authoring tool while I build the far more complicated Storytelling (Sims2) API, which brings me to…

Alice3 will support multiple dragging and dropping multiple APIs. Arbitrary Java code, really. I strongly assert that, no matter what, if you are learning to program you shouldn’t have to deal with syntax at the outset. You should divide and conquer, as it were. Learn the concepts, and then (if necessary) learn to deal with the syntax. (I could go into greater detail on this point, but I figure if you are reading this post, then you are already part of the choir, if you get my drift.) Anyway, while I *assert* the previous point, I *believe* that the storytelling API (animating Sims characters) will be the most motivating and successful API. It will be our crown jewel. However, I’m not opposed to other approaches and want to support them. If someone wants to introduce people to computing via physics simulation (as an introductory course in an engineering school might choose to do) then I’m all for it. I’m not really into jamming my storytelling API down everyone’s throat (and I certainly don’t want people trying to force physics simulations with ill-suited animations which aren’t set up with the critical deltaTime in mind). Anyway, I’ve whipped up a couple of other simple APIs so

1) I can make sure that Alice3 doesn’t become too Storytelling API centric, and
2) pedagogy folks will have simple examples to go from when building there own APIs.

Besides, I just want to be able to drag and drop Karel code (since it was how I was first exposed to programming way back in tenth grade (that is to say “forever ago” :-) ).

I’m sure there is more to say, but hopefully this is a good start. A great many things on a great many fronts have been making progress. DoTogether, as you might imagine, requires some magic to pull off in pure Java code. This has magic has been built. As referenced earlier, the Eclipse app gold spike has been built… Java code has been parsed and there is even a crude little editor for dragging and dropping the abstract syntax tree. Sims characters have been converted and soft skinned animations have been performed. *Much* is left to be done… no doubt about it. However, I am excited about the prospects of the end result, and I hope people will be pleased.

I hope this was better than listening to crickets chirp. :-)

Back to work.

dennis