Down the OOP Rabbit Hole with Alice

Computational Thinking, Education, MSU MAET

Much like other popular programming options for younger students such as Scratch and SNAP, Alice offers users the ability to create interactive scenes by combining blocks of code. While many of these graphical programming environments include elements of object oriented programming, Alice brings it to the forefront and is integral for effective programing of complex interactions. Unlike other popular options, Alice’s scenes are rendered in three dimensions and offers control over many details of the character models. This is both liberating and limiting, as it provides a wealth of options that younger students would likely find overwhelming.

Alice, like most tools, aids in solving a particular type of problem, namely creating animated scenes. It also helps develop problem solving in other contexts by developing skills in abstraction and algorithmic design, two core skills of computational thinking. Developing the ability to abstract data and instructions is perhaps its greatest strength. Students can start creating intricate animations by making use of built in functions that would otherwise be difficult to implement, such as moving towards a target or defining camera angles. They can then extend that abstraction by creating their own functions, which can be defined in a parent class and inherited in all children classes, without having to worry about how it is implemented once it’s created.

Being able to work with an abstraction of data is equally important in Alice. As I worked with my initial task of simply having my astronaut walk, I had to consider the details important to the motion, so needed only concern myself with the relevant details, such as the rotation of arms and legs. As Cooper, Dann and Pausch (2000) point out, although the capability is there, I did not find it necessary create any variables beyond arguments for my defined functions. Alice’s use of classes allows the students to focus on manipulating class data, rather than creating what would most likely be a messy collection of variables.

Another important CT skill being developed is creating algorithms. Cooper, Dann and Pausch (2000) refer to “algorithm vs. program” (p. 2) as part of algorithmic thinking, which I took to refer to developing a general solution as an algorithm, such as thinking about what needs to be done for the alien to wave its hand, then implementing it in the program, using the specific function calls found in the software. The algorithm could be used anywhere, while the program is the particular implementation defined by the language/software being used. Being able to create general solutions that can be applied no matter what the implementation may be is a useful tool.

Problem solving benefits greatly by being good at problem decomposition, and Alice allows that skill to be developed either alone or by working in groups. A simple animation requires breaking it down into many smaller parts, and creating a detailed final product requires that process to be repeated many times over. It also helps with troubleshooting and working iteratively, as creating the animation required many tries with debugging and refinement being done at each run through, rather than waiting until after an entire program is created.

At first, I found little to love when using Alice. The interface was cluttered and confusing, the manipulation of characters’ limbs seemed overly complicated, and there appeared to be better tools for creating scenes through code, as I found earlier. As I became more familiar with the program by struggling through tutorials intended for a previous version, some reservations fell away, others intensified, but I did begin to see value in using Alice in an educational setting. Becoming familiar with already implemented functions made it much easier to animate characters, but it was often guess work to see what rotate forward means when talking about a wrist vs. a door. I could see students having much more patience than I to become involved in world building. Running against the limitations of the program also allowed for creative solutions. As Knuth (1974) states, “It makes a person feel like a real virtuoso to achieve something under such severe restrictions” ( p.671).

The world I created reflected how I decomposed the problem of creating something. At first it was just an alien waving, then having the alien arrive in a UFO. From there, I tackled the problem of getting the astronaut to walk at least somewhat normally and to make a look of surprise. Throughout the process I struggled with the camera positions, and finally settled on a few basic zooms and sweeps. The background detail was the last to be added. The problem solving process showed how I would focus on the one aspect that was most important to the program at that time, and then slowly filled in the details. This is something all students should learn since it shows how any program or solution to a problem is built.

References

Cooper, S., Dann, W., & Pausch, R. (2000, November). Developing algorithmic thinking with Alice. In The Proceedings of ISECON 2000 (Vol. 17, pp. 506-539).

Knuth, D. E. (1974). Computer Programming as an Art. Communications of the ACM, 17 (12), 667-673.

Leave a Reply

Your email address will not be published. Required fields are marked *