Reflections on My Experiences with Using Alice to Teaching Introductory Programming

I redeveloped and took ownership of BIS 112, Programming Concepts, over the summer of 2007, somewhat reluctantly given that the vision for the course and the work to redesign it had been started by a colleague who fell seriously ill and went out on leave. I thought that the idea to use Alice was sound and I endorsed it as the department chair, but at the outset I was not a true believer, so to speak. I came to love Alice, though, as well as the challenge of teaching introductory programming in an open enrollment context.

I taught my first section of the redeveloped, Alice-based class in September. I was struck at the outset by the potential of the Alice approach. A blank page and a blinking cursor can be intimidating, and it precludes the sort of exploratory messing around and “intelligent muddling” that can be so powerful, as a learning technique generally, but especially for learning software. (In fact, in a course on interface design and usability I hold out to the students that the extent to which a design supports intelligent muddling often works well as a sort of usability gauge for sufficiently complex software systems.)

From something as simple as one of the students, working on our first in-class lab asking “Ummm..what’s recursion?” because he’d inadvertently created a recursive function, it was evident that a direct manipulation interface affords serendipity in a way that an IDE just can’t, and having that conversation about recursion, even though it came too early in the course to be easy to address, and even though the class doesn’t really cover recursion in much depth at all, this sort of authentic inquiry can make a huge impact I think.

Better still was the student who, in the midst of an open-ended in-class assignment, called me over because he had a Halloween scene with a half dozen or so zombies and he was looking for a way to make them move one after the next; he was tiring of instructing them individually one after the next and suspected there was an easier way. Of course it was a wonderful opportunity to talk about lists and arrays. I’ve no confidence that he left that day with a particularly robust understanding of arrays, but eventually he did, and it’s great thing to see that genuine interest in accomplishing a task coupled with an earnest interest in doing it more efficiently. Having an authentic interest in accomplishing some particular task is a fantastic learning opportunity. They claim that a lazy programmer is a good programmer. The claim that a lazy programming student is a good programming student is pretty preposterous, I know, yet with authentic problems that students actually desire to work on, one can leverage that whole lazy = good business because students will seek easier ways to accomplish things and will learn them in the process. Yeah team! Without Alice that sort of “hey, here’s what I’d like to do and it’s taking a while is there an easier way to do it?” is much, much less likely on the first day of class, that’s for sure.

Just as in real software engineering, however, there are accidental and essential complexities in teaching programming too, and Alice was no panacea (no silver bullet, if you will) of course. I had heartache soon enough that no programming environment could redress when, on our second meeting, it came time to perform some resoundingly basic arithmetic manipulations. My request of the students in class was to make a world that asked the user how old he or she was in years and to tell them how old they will be in days at their next birthday. Having temporary trouble is reasonable enough but the stark difficulty several of the students had with flat out basic arithmetic took me aback. I asked one student - OK, do we need to make the number the user gives us bigger or smaller? He was uncertain. Abstraction of any sort can be tough: I asked him how old in days someone who was 10 years would be and he answered immediately and correctly. I’ve still not quite come to terms with the consequences of open enrollment, nor have my teaching approaches evolved as much as they need to. Such a wide preparedness disparity is an inordinate teaching challenge, and one with which I continue to struggle.

Essential complexity is irreducible. That which is genuinely challenging will remain genuinely challenging. Nevertheless my initial experiences are that Alice is a real time on task enhancer, and that is no small thing. The final projects in the class *way* outstripped the minimum requirements I had assigned for them. Students made way bigger, more involved and more creative projects than they needed to. This doesn’t mean that they learned programming any better necessarily, but it surely doesn’t hurt. I’m greatly encouraged.