MET:Alice: Computer Programming in a Constructionist Environment
In my vision, the child programs the computer and, in doing so, both acquires a sense of mastery over a piece of the most modern and powerful technology and establishes an intimate contact with some of the deepest ideas from science, from mathematics, and from the art of intellectual model building. 
Alice is a 3D programming environment that allows the novice programmer to dive into the complex world of computer programming and begin authoring narratives and simple interactive games without any previous specialized training. This freeware was designed to help democratize the cloistered programming community and entice a more diverse range of students into exploring object-oriented programming.  The design of Alice's environment is deeply informed by Seymour Papert's LOGO work and his extension of constructivist pedagogy into constructionism, which puts an emphasis on the importance of building objects to think with. While Alice was originally conceived as a means for keeping at risk students from dropping out of entry level computer programming courses, many educators agree that programming is a valuable part of education for all students. In Alice's constructionist learning environment, students are introduced to structured problem solving, complex systems and computational thinking skills - all of which have a broad range of applicability both in and outside of the computer sciences.  Alice embodies Papert's belief that, "children can learn to use computers in a masterful way, and that learning to use computers can change the way they learn everything else."  The central figure in this environment (as represented in the logo image to the right) is Alice from Lewis Carroll's widely beloved Alice's Adventures in Wonderland. Her presence is meant to reassure and inspire the user, as she represents a world where anything is possible and imagination is the only limit.
The Alice Project has evolved over time and is the collaborative work of a large assortment of professors, computer scientists and students from a number of different universities. The Alice initiative was spearheaded by the late Randy Pausch (October 23, 1960 – July 25, 2008) who led the initial Human-Computer Interaction and Design research group at the University of Virginia. In 1997 he took the project with him to Carnegie Mellon University where it continues to evolve under the direction of Dr. Wanda Dann. Randy Pausch died on July 25, 2008 of pancreatic cancer and is still remembered both for his major contributions to computer science and educational technology and for his inspirational lecture and book, Last lecture: Really achieving your childhood dreams, which he delivered at Carnegie Mellon on September 18, 2007 one month after receiving his terminal diagnosis. 
On his memorial page at the Carnegie Mellon website, Randy Pausch is remembered as being "widely respected in academic circles for a unique interdisciplinary approach, bringing together artists, dramatists and designers to break new ground by working in collaboration with computer scientists."  This interdisciplinary and collaborative approach reflects a pedagogical spirit that has evolved out of the work of people like Seymour Papert and others who are concerned with improving human-computer interactions for the purpose of augmenting human creativity, problem solving and thinking in general. In this view, technology is a tool for increasing human potential and computers "can help people form new relationships with knowledge that cut across the traditional lines separating humanities from sciences and knowledge of the self from both of these." 
The evolution of human-computer interaction
While computers and technology continue to become increasingly pervasive and ubiquitous in our lives, there is still a widely held fear of 'looking under the hood' and seeing how the technology works. This job is left to the professionals who are often depicted as 'computer geek' stereotypes and somehow different from the rest of us. We imagine engineers building impossible machines dreamed up by science fiction writers or code monkeys hunched over keyboards in cramped cubicles, churning out incomprehensible strings of numbers. These stereotypes are invariably of men outfitted with years of boring and highly specialized training and fluent in an exclusive digital tongue.
Refuting this vision, is a more democratic belief that computers need not and should not be difficult to use or understand. Since the late 50s and early 60s, a community of computer scientists, inventors, designers and educators has been working towards making computers increasingly more portable, intuitive, reasonably priced and universally accessible.
It is about using computers to question standard assumptions in developmental psychology and in the psychology of aptitudes and attitudes. It is about whether personal computers and the cultures in which they are used will continue to be the creatures of ‘engineers’ alone or whether we can construct intellectual environments in which people who today think of themselves as ‘humanists’ will feel part of not alienated from, the process of constructing computational cultures. 
Gary Stager, a proponent of progressive education, educational technology and Constructionist pedagogy, reminds us that the personal computer itself can be traced back to Seymour Papert. The story goes that in 1968 the computer scientist and digital pioneer Alan Kay was in Boston to see Seymour Papert at work. Kay was so excited by what he saw of children programming computers and working and thinking creatively with the LOGO programming language, that on the flight back he sketched out plans for the Dynabook, which is the predecessor of the laptop. He also coined the term 'personal computer.' Stager does not want us to forget that, "The notion of the personal computer was as this imagination machine for kids." 
The development of Alice grows out of this greater discourse around human-computer interactions and the imaginative resources and capabilities of children. "The central thesis," writes Matthew Conway, one of the Alice developers, "is that 3D interactive graphics programming does not need to be as hard to learn as it is today."  In order to prove the truth in this statement, Alice developers had to break down what students find difficult about programming to begin with and how to ameliorate these difficulties. As with any constructionist project (and the design of Alice itself is the definition of a collaborative, constructionist project) the process of creating and refining Alice as an artifact or 'object to think with' is in a co-evolutionary relationship with the construction of an understanding about how we think. The following design principles of the Alice environment further explore this question of how people learn in general and with computers specifically.
Design principles through a constructionist lens
The following list of design principles is not exhaustive; rather, it has been compiled through a lens of constructionism. Only those key principles that are directly informed by or implicitly reflect constructionist pedagogy have been listed here.
The 3D environment of Alice programming is stocked full of a huge bank of whimsical characters, objects and landscape features to choose from. Users drag and drop these objects in order to visually and spatially create a unique world in which to explore. The choice of this 3D object-oriented paradigm is rooted in the much researched theory that people learn best through tangible experiences that are directly related to the senses. Alice is concerned with the time-based, interactive behaviour of 3D objects. In the tradition of Papert's turtle, "students [of Alice] see their programs execute in an animated format, directly observing the impact of each programming statement." 
Two fundamental road blocks in learning computer programming are the problems of syntax errors and invisible state. Alice's drag and drop paradigm removes the possibility of syntax error. The problem of invisible state is removed via visualizations and animations. Let's say you want to move your bunny character to the left 10 steps but you accidentally enter 50 steps which effectively moves the bunny off screen. In an unanimated programming environment, this error would be difficult to spot. In the Alice environment, the programmer watches her command unfold over a specified duration of time during which she can easily spot the source of her error.
Alice is very much like a 3D version of Papert's LOGO because it encourages students to analyze and breakdown actions "that they themselves know very well how to do." For example, if a student wants to program a character to walk across the screen in a realistic fashion, he needs to break down what is involved in the act of walking: moving one leg in front of the other, bending the knees, perhaps swinging the arms and how all these movements relate to each other. The visualization of the program allows students to continue refining and altering their commands which not only increases the students' literacy of programming, but also their very understanding of the physical act itself.
Discovery and exploration
Perhaps the most significant feature of any effective learning environment is that of motivation. Alice developers had to create a motivating environment for students so that they would stay in the environment, explore, and invest the energy and time necessary for real learning to occur. Providing students with an opportunity to express their creativity is central to Alice's motivating success. Part of encouraging real creativity is providing students with open ended projects in which the end goal is not yet determined. "Papert draws our attention to the fact that 'diving into' situations rather than separation, are powerful means of gaining understanding." 
Another factor in encouraging students to engage deeply enough to take the time necessary for authentic exploration, is to engage them in "projects that grow out of their own interests and passions."  The Alice environment is outfitted with a couple of tutorials to give users the hang of what can they can do. Once they have stepped over that 'low threshold', users are encouraged to develop their own ideas. The possibilities are endless. Problems and difficulties will naturally arise in the design/creation process - this is where the real learning occurs; the student will be much more motivated to put in the effort to work out these problems when the ultimate goal is the realization of their own vision.
Alice was designed to have a "low threshold, high ceiling [and] wide walls.  Upon first opening up the Alice software program, the user is prompted to begin making choices that refine their unique 3D world. The user easily steps over that "low threshold" and into their first interactive experience with the Alice program. But as explained above, for optimal creativity to be unleashed, there needs to be a high ceiling of possibility. The more engaged a user becomes, the more functionalities and affordances the software opens up for her. As one user explained: "You can get as complicated as you want, but not more than you need to." 
What remains invisible
...Imagine going to a poet and saying, "What are you doing?" You'd be very surprised if the poet said, "I'm using a pencil". The poet would have said, "I'm writing a poem," or, maybe, "Just leave me alone, I'm busy." Of course the poet was using a pencil, but that's not worth mentioning, and the same should be true of computers.
In a promotional video for Alice, Wandy Dann explains that today's average student is no longer excited about the computer itself. There was a time, in the not so distant past, when the computer was new and alien to us. Learning how to type in code to make the the words: 'Hello, world' appear on the screen was an exciting project, in and of itself. This is no longer the case. We have ipods, cellphones, laptops and all kinds of multimedia at our finger tips that will do extraordinary things for us. Entry level computational activities simply can't compete. Alice designers turned the focus away from the tool itself - the pencil - to focus on the poem. Then the problem for designers became how to make the tool as non-obtrusive, or 'invisible', as possible. 
Randy Pausch explains that, "the best way to teach somebody something is to have them think they're learning something else."  This is fundamental to the Alice experience. Students are invited to engage in problem-based, open-ended and constructionist projects. In the journey towards realizing their own ideas, students are learning programming skills and how to think with a computer, but that implicit learning is hidden within the engaging experience of creative expression.
If Alice was going to succeed at truly being a tool with "a low threshold, high ceiling and wide walls," than designers had to negotiate a balance between visibility and invisibility of affordances. An essential factor in encouraging exploration and innovation within any program or tool is that the affordances be visible or apparent to the user. Because Alice was designed to not require extensive training, these affordances have to be intuitive and readily accessible and yet not overwhelming to the novice user. Let's extend the metaphor of the poet above, to that of a painter. In deciding upon how to execute the next stroke in a painting, the painter might refer to her pallet of colours and her jar of brushes. These options should be immediately available to her in order to help in her problem-solving and artistic decision-making. However, if all the possible hues and tints were to cover her pallet, all the possible instruments were to fill her jars and all the possible styles of painting were to crowd her imagination, she would likely be overwhelmed by her options and finally quit the project. Alice developers met this design challenge in the form of 'controlled exposure to power'. "This characteristic of the API [Application programming interface] allows novice users to become expert users by incrementally adding to what they know."  Each option has a level of complexity that need only be tapped into when the designer is ready for that particular challenge, or if its addition is necessary to the particular problem the user is facing in their project.
Objects to think with
Artifacts and understanding in [the constructionist] model are at once the product, as well as the producer, of the other. Artifacts produce understanding through interpretation. Understanding produces artifacts through representing.....
A central differentiation between Constructionism and Piaget's Constructivism, is Papert's focus on the importance of constructing artifacts or objects-to-think. As you can see from the model pictured above, there is a co-evolutionary relationship between the artifact and the understanding. Each produces the other. In this view, the Alice program itself is an artifact, the construction of which has added to a greater understanding of the way people learn in a programming environment.
Within the Alice environment, learning with objects is central to the experience. Alice is an object-oriented programming environment, the language of which, it is interesting to note, directly reflects Papert's vocabulary. It is not the intention here to explain object-orientated programming in detail. However, some key features are relevant to the constructionist view of the Alice environment. The 'objects' of object-oriented programming represent a complex set of attributes and characteristics. Objects themselves must be 'constructed'. In the Alice environment, the user is not able to design an object from scratch, but they can construct aesthetic parameters for each instance of the object (such as size & colour). In addition, users can construct and save complex methods for their chosen object, such as a waving motion of the Alice object's arm. Once that method (itself constructed together from a series of simple actions) has been saved, it becomes a part of that object's repertoire.
The 'objects' of object oriented programming, are visualizations of complex mathematical and programming code. The visualizations are in the form of familiar objects, features and characters. This familiarity is meant to draw upon languages and knowledge the user already has. Another distinguishing characteristic of the Alice programming environment, which may seem on the surface to be merely cosmetic, but which is in fact quite profound was the design choice of getting rid of the XYZ coordinate system. Alice researchers found that this XYZ coordinate system was adding an extra level of complexity to the design experience that was totally unnecessary. Users already know how to move objects in space. Instead of learning a new language of cognitive mapping, users can simply engage with the vocabulary they already have for this task: Forward/Back, Left/Right, and Up/Down. '
Benefits for the learner
- Helps with learning persistence and creative problem solving skills
- Students can visualize progress towards a goal, solution, story, or game.
- Th*is visualization is a reward that has a snowballing effect in that it creates a sense that further effort will 'pay off'.
- Students have the intrinsic motivation of telling their own story, or building a game of their own design.
- Students end up with a product they can share with others who can enjoy it for what it is and need not have any knowledge of Alice.
- Students can see visualize their mistakes and easily see where they have gone wrong. (The fact that these mistakes are often visually amusing can have the effect of reducing frustration)
- Self confidence is fostered as students become aware of their own capabilities at authoring narratives and programs in an object-oriented programming environment.
- The fear of code is minimized and interest in exploring computing is developed. Students realize that developing programming literacy gives them the tools to make and build 'cool things' that are interesting to others. 
- Kelleher, C. (2006). Kelleher, C. (2006). Motivating programming: Using storytelling to make computer programming attractive to middle school girls. ProQuest Dissertations and Theses. Retrieved from www.cs.cmu.edu/~caitlin/papers/kelleherProposal.pdf
- Kelleher, C., Pausch, R., & Kiesler, S. (2007). Storytelling Alice motivates middle school girls to learn computer programming. Proceedings from SIGCHI Conference on Human Factors in Computing Systems. San Jose: California. 1455-1464. doi: 10.1145/1240624.1240844
- Microworld applications for computer programming
- Constructivist Learning Environments
- Problem-Based Learning
- Information hiding
- Papert, S. (1980). Mindstorms: Children, computers, and powerful ideas. New York, NY, USA: Basic Books, Inc.
- Rodger, S. H., Hayes, J., Lezin, G., Qin, H., Nelson, D., Tucker, R., & Slater, D. (2009). Engaging middle school teachers and students with Alice in a diverse set of subjects. SIGCSE Bull., 41(1), 271-275. doi: 10.1145/1539024.1508967
- Kelleher, C. (2006). Motivating programming: Using storytelling to make computer programming attractive to middle school girls." Retrieved from csta.acm.org/Research/sub/Projects/.../kelleherThesis_CSD.pdf
- Pausch, R. (2007, December 20). Randy Pausch Last Lecture: Achieving Your Childhood Dreams. [Video file]. Retrieved from http://www.youtube.com/watch?v=ji5_MqicxSo [
- An enduring legacy: Randy Pausch inspired millions. (n.d.) Carnegie Mellon University. Retrieved from http://www.cmu.edu/homepage/beyond/2008/summer/an-enduring-legacy.shtml
- Warlick, D. (2007, February 8). Podcast 125: The Value of Student Programming and Constructionism (Gary Stager)[Audio recording]. Retrieved from http://www.speedofcreativity.org/2007/02/08/podcast125-the-value-of-student-programming-and-constructionism-gary-stager/
- Conway, M. J. (1998). Alice: Easy-to-learn three-dimensional scripting for novices. Retrieved from www.cs.princeton.edu/courses/archive/spr01/.../conway97.pdf
- Cooper, S. (2010). The design of Alice. Journal ACM Transactions on Computing Education, 10(4), 15:1-15:16. doi: 10.1145/1868358.1868362
- Ackermann, E. (2001). Piaget’s constructivism, Papert’s constructionism: What’s the difference? Retrieved from http://www.google.ca/url?sa=t&rct=j&q=&esrc=s&source=web&cd=1&ved=0CDMQFjAA&url=http%3A%2F%2Flearning.media.mit.edu%2Fcontent%2Fpublications%2FEA.Piaget%2520_%2520Papert.pdf&ei=le00UaP1LZLkqAHpjIHwBg&usg=AFQjCNEy7ujMTYVEnLWu8BLgo4VZuHOFHw&sig2=ERAWG6R0i1HLu_6AV9cwOQ&bvm=bv.43148975,d.aWM
- Resnick, M., Myers, B., Nakakoji, K., Shneiderman, B., Pausch, R., Selker, T., & Eisenberg, M. (2005). Design principles for tools to support creative thinking. Proceedings from: NSF Workshop on Creativity Support Tools, 25-36. Retrieved from http://www.google.ca/url?sa=t&rct=j&q=&esrc=s&source=web&cd=1&ved=0CD4QFjAA&url=http%3A%2F%2Fwww.cs.umd.edu%2Fhcil%2FCST%2FPapers%2Fdesignprinciples.pdf&ei=SG4qUfLJCaiUigKi0IDQDg&usg=AFQjCNEyYDbcmJlJq_Ku9mtPNaCtIGr3cw&sig2=nfVWhGppVY6om9J_3Y6YaA&bvm=bv.42768644,d.cGE
- Conway, M., Audia, S., Burnette, T., Cosgrove, D., & Christiansen, K. (2000). Alice: Lessons learned from building a 3D system for novices. Proceedings from: SIGCHI Conference on Human Factors in Computing Systems. The Hague: The Netherlands. 486-493. doi: 10.1145/332040.332481
- Papert, S. (n.d.) Constructionism vs. Instructionism. Part 2: LEGO/LOGO projects. Retrieved from http://www.papert.org/articles/const_inst/const_inst2.html
- Cosgrave, D. & Dann, W. (2007, December 13). A Preview of Alice 3.0, Introductory Programming in 3D. [Video file]. Retrieved http://www.youtube.com/watch?v=lXOyd68saIM
- Pausch, R. (n.d.) Retrieved February 25, 2013 from http://en.wikiquote.org/wiki/Randy_Pausch
- Ostwald, J. (1996). Knowledge construction in software development: The evolving artifact approach. Retrieved Feb. 23, 2013, from http://l3d.cs.colorado.edu/~ostwald/thesis/home.html
- Goulet, D. (n.d.) Alice and the introductory programming course: An invitation to dialogue. Retrieved from http://isedj.org/7/50/Goulet.j.txt