The traditional use of algorithm animation involves an instructor (or domain expert) developing animations which students view to help them learn about an algorithm. Recent empirical tests to validate the pedagogical value of this approach have had mixed results. In this talk we review another approach to algorithm animation--having the students themselves build the animations. This approach requires that flexible, easy to learn, language independent animation tools be available. In this talk, we describe the Samba animation system that fills this role, and we describe how Samba has been used in an undergraduate algorithms class as an educational aid.
Here at Clark Atlanta University, we have started a project to develop interactive multimedia modules which provide supplementary tutorials on basic topics covered in the early CS courses. This presentation will describe the development of two of these modules: a number conversion tutorial which covers converting numbers to different bases (especially binary, octal and hex), and an operating systems tutorial which introduces files and directories, the program cycle, and unix commands.
The modules feature a graphical user interface with buttons, file browsers, and images. The first version also included animations of the conversions between number bases. The prototype tutorials were evaluated in a study using protocol collection and a post-test with nine student participants, primarily drawn from the CIS 105 class (Structured Programming in C). The students ranged in experience from high-ability to low-ability (according to their course grades).
General feedback from the students indicated that they liked the courseware and could imagine using it again in the future. The students found the operating system module easy to use and interesting. They also particularly liked the animations of the conversions between number bases. Several students remarked that they recognized the process from the book. However, these same students didn't even know where to begin to convert a decimal number to hexadecimal when asked to do so in the post-test. There seemed to be no retention of the conversion process.
Many students were fearful of answering the post-test questions unless they were sure of the answers. They preferred to use the module to find the correct answer. When students thought that they were sure of the answer and found by negative feedback that they had the wrong answer they wanted to know why. Many students navigated the modules by answering the test questions and only looked at the available information if they got a question wrong. Some students said that they wanted more tests.
Based on these observations the courseware was modified to require more user interaction. Instead of watching an animation of base number conversion the user is now led through the process with levels of support to assist the student. For students with no idea how to begin the process, a help window with an example and the process steps is displayed. A step button allows the user to let the computer automatically do the next step. If the user enters inncorrect input a window appears with an explanation that the input is wrong and how to calculate the right answer. The modules were also changed to be more test driven. A "do it" or "explain" button was added on the on-line tests that leads the user through the process of finding the correct answer or helps explain why their answer was wrong, and a "next test" button was added to let the user take another test.
We will present a three level simulator for a model computing system that can be used to teach the principles of compiling, the assembly language level architecture, and the switching circuits that implement the architecture. At the compiler level, the system shows how compilation rules are used to parse the input program and generate assembly language. At the architecture level, the system shows the fetch- execute cycle as it executes the object code from the previous stage. At the switching circuit level, the system allows the user to observe the detailed actions of the adder switching circuit as it computes the sum of two numbers.
The system has been used over the past two years in a first course in computer science at Duke. It can be used in the lecture to demonstrate ideas as they are presented. It can be used in laboratories for weekly assignments. Also, it has a tutor capability that can be used for home study; a cartoon professor appears on the screen and describes the sequential actions of each simulation step as it occurs. It has a tester capability that allows the student to be tested on his or her understanding of the simulation; if the student chooses, the resulting grade will be transmitted over the network to the instructor's grades database.
In this talk, I will discuss the use of visual and interactive learning tools to teach topics in Artificial Intelligence. Artificial Intelligence is a notably difficult course to teach, in part because of the breadth of information generally expected to be conveyed in a single course. The use of visual and interactive tools allows complex techniques to be introduced in an intuitive manner, allowing the students to grasp the key points more efficiently. Out-of-class use of the same tools (required as homework exercises) reinforces this introduction, and enables students to deepen their understanding of the covered topics.
Two tools will be described, both of which cover topics in reasoning under uncertainty. Statrad teaches the Dempster-Shafer theory of evidence accumulation in the context of expert system development. Baynex teaches the theory of Bayesian networks, including network development and propagation of uncertainty information. Both tools make use of graphical animation to highlight important aspects of the theory. In addition to the "standard" level of animations, both tools have more detailed expositions of the underlying theory available on an as-needed basis. In addition to giving students more control over their learning experience, this feature allows the use of the tool to be tailored to a particular course or student audience.
Certain topics are difficult for some students. In particular, students often have trouble with two concepts in programming courses: (1) distinguishing between different modes of parameter passing, e.g., by value, by reference, and by constant reference; (2) understanding pointers, dynamic memory allocation, and linked structures. Although animations are helpful in understanding these concepts, physical artifacts offer another dimension of understanding; one students grasp both physically and mentally. In this demonstration and lecture we will illustrate some of the physical artificacts that we have used in our courses to explain parameter passing, pointers, and dynamic data structures. These artifacts are intrinsically pedagogical aids, but their use in a classroom setting also offers instructors another dimension for teaching and learning.
In this presentation we would like to describe the concepts of cognitive apprenticeship and case libraries and demo a prototype where we have tried to implement these concepts in a courseware system aimed at computer graphics students. The system is being developed within the "Multimedia Courseware for Computer Sciences" Project at the Graphics, Visualization and Usability Center, College of Computing of Georgia Tech.
The Apprenticeship concept: One of the old and effective ways of training is the apprenticeship way. The effectiveness of training people in the workplace comes probably from different reasons. One reason may be the engagement of the apprentice in real-world problems (learning-by-doing.) Another reason may be the close presence of the supervisor who provides the apprentice with scaffolding along the training process. Typically, at the beginning of the process the apprentice can't perform a lot without the scaffolding support, and towards the end of the process, scaffolding fades and the apprentice is capable of performing tasks independently.
The Case Library concept: A case library is typically aimed at storing previous cases in a given domain for the sake of finding solutions to problems encountered in new cases. This is done through a process known as case-based reasoning (as opposed to rule-base reasoning.) The case library provides its users with a search mechanism that uses partial matching to find similar cases according to criteria defined by the user. An important notion within the 'educational case library' is to enable a broad use of the library: experts might use it to find similar cases to the one they are currently engaged with, and novices could use the library to learn about major problems in computer graphics.
The Learning Interaction: In the computers world, 'doing' is usually problem-solving. For example, in most cases an algorithm learned in school won't fit exactly to a new application being developed and the necessary modifications are the problem to be solved. Therefore, we have included in our system problem-solving activities. These activities are based on simplified stories, aspects of general problems and variety of introductory course assignments. Learners are challenged to look for different solutions by retrieving relevant stories and problems stored in the library. While trying to solve a learning problem, learners could also be facilitated by various support and scaffolding features provided by the system, such as library hints; suggested learning issues; links to relevant tutorials; visualization tools; experts analysis and students' trials to solve this problem including unsuccessful trials.
The apprenticeship environment is achieved by integrating several modules: tutorials, case libraries, problem-soling activities and collaborative tools. Thus, the system enables symbiosis of both learners (apprentices) and teachers (experts/supervisors.)
Visual and interactive tools allow one to associate a picture with a concept, to experiment with the concept, and receive immediate feedback. We will demo several such tools for teaching formal languages and automata. The first tool, FLAP, provides an environment for designing and simulating programs for three types of nondeterminisitic automata: finite automata, pushdown automata, and Turing machines. The interaction in this case involves designing the programs using an editor, and controlling the simulation, especially the nondeterminism. Additional tools, LLparse and LRparse, provide an instructional environment for constructing LL(1) and LR(1) parse tables through a series of steps, and parsing strings using the resulting table. We will explain how we use these tools in and out of the classroom.
Computers are being used increasingly to improve the quality of classroom instruction. An area that little seems to have been done in is in the automation of one of the more tedious and error-prone activities - taking notes while the instructor is presenting and explaining material.
The low-tech approach to solving this problem is for the instructor to pass out copies of his/her notes and/or overheads, onto which the student may make whatever annotations will help later in recall and understanding. There are several problems with this approach. The notes/slides must be prepared in advance, thereby reducing the possibility of spontaneity in response to student questions and/or feedback. If the instructor does deviate from the notes/slides, note taking reverts to the ancient manual system. Much can be gained from using color on overheads, but the cost of color copies usually results in b&w versions being distributed - regardless the student usually reverts to one pen color when making annotations even though the instructor may use several colors for clarity. Animations are almost impossible to make decent notes about.
Some solutions to these problems have been developed. One is reported by John Rabung, where students are required to use the computer to take notes by simply typing into a word processor. Another is the UNIX Classroom described by Joel Adams, in which he found that students discovered on their own that taking notes on the computer was preferable to the pencil and paper approach.
These improvements are obviously moving in the right direction, but its time to take the next (big) step. Consider the following scenario. The instructor and every student has a computer, with a pen input device, at their disposal. The instructor presents material via a combination of prepared "slides" and animations, but also impromptu writing and drawing via the computer (using the keyboard and/or pen). The student watches the presentation on his/her individual machine. If the student wants to save what is currently displayed (either the prepared or impromptu), simply hitting a key (or pointing and clicking) is all that is necessary. The student can add personal annotations to what is displayed, including animations, right on his/her own screen (either as an "overlay" to the presented material or as a graphical hyperlink to another window), using keyboard and/or pen input (for the typing impaired). The student can pose a question both verbally and by drawing on the screen and having what is drawn appear on everybody else's screens (again via overlay or hyperlink). The entire classroom experience, including animations and impromptu presentation, plus the student's own annotations, can be saved. The instructors voice can even be recorded and pinned to the presentation.
After class the student can review the lecture the his/her convenience. If questions arise, the student can pose them to the instructor by "emailing" a replay of an appropriate part of the "lecture" and adding his/her questions as annotations, to which the instructor can respond likewise.
The hardware to do this exists. Many pieces of the software exist, but there is a need to integrate them into a flexible and easy to use system. The question is, should it be done? What are the problems? Can we make it so simple that an instructor can use it with no more practice and preparation than they currently invest in a "low tech" lecture? Will it be so neat that students will "discover" it and forever abandon pencil and paper? Will it in fact enhance the learning process, or is it just a waste of money in the quest of applying technology to education?
Object-oriented design and programming is a challenging subject for students (Guzdial, 1995a). An approach which has proven successful in teaching complex subjects is creating a "cognitive apprenticeship" -- where correct procedures are modeled and demonstrated, students are coached through a process, and students have the opportunity and are encouraged to articulate what they're doing (Collins, Brown, & Newman, 1989; Guzdial, 1995b). Encouraging a culture of apprenticeship is hard, especially in large classes. Creating software to support a "cognitive apprenticeship" can help, but the software can be complex (Guzdial, 1995b). We are exploring techniques for supporting an apprenticeship experience while minimizing the overhead.
We are focusing on a sophmore level course (typical enrollment is 50-75 per quarter) in object-oriented design and programming at Georgia Tech: CS 2390, Modeling and Design. Our learning environment has two software components:
I. CaMILE (Collaborative and Multimedia Interactive Learning Environment), a threaded, WWW-based collaboration tool (Guzdial, Kolodner, et al. 1996). CaMILE is unlike newsgroup-based collaboration tools in two main ways: (a) Individual notes can be easily linked with other WWW resources, without using unintelligible note references. For example, we can link individual problems from an exam review page to notes that begin a thread with answers, questions, and suggestions about that problem. When students are using the review page, a single click brings them to a threaded discussion which is related to the context of the problem. (b) Students writing notes in CaMILE are prompted to think about the role that their note is playing: Are you raising an issue about Analysis? Design? Programming? Such prompts can help students to think about and learn from their collaboration (Scardamalia, Bereiter, et al., 1989).
II. STABLE (SmallTalk Apprenticeship Based Learning Environment). STABLE presents students with worked-out problems and support for trying the problem themselves. It weaves together procedures, general problem steps (which can be used in the students' own problems), graphical representations of the procedures and steps, and repair support for when the student fails at using the procedure or step. STABLE is also WWW-based and links into CaMILE.
CaMILE has been in use for two quarters in CS 2390, and STABLE is being tested for the first time in the Spring 1996 quarter. Our talk will describe the approach and our preliminary results.
REFERENCES Collins, A., Brown, J. S., & Newman, S. E. (1989). Cognitive apprenticeship: Teaching the craft of reading, writing, and mathematics. In L. B. Resnick (Ed.), Knowing, Learning, and Instruction: Essays in Honor of Robert Glaser (pp. 453-494). Hillsdale, NJ: Lawrence Erlbaum and Associates.
Guzdial, M. (1995a). Centralized mindset: A student problem with object-oriented programming. In ACM SIGCSE Technical Symposium 1995 (pp. 182-185). New York: ACM Press.
Guzdial, M. (1995b). Software-realized scaffolding to facilitate programming for science learning. Interactive Learning Environments, 4(1), 1-44.
Guzdial, M., Kolodner, J. L., Hmelo, C., Narayanan, H., Carlson, D., Rappin, N., H=FCbscher, R., Turns, J., & Newstetter, W. (1996). Computer support for learning through complex problem-solving. Communications of the ACM, In press.
Scardamalia, M., Bereiter, C., McLean, R., Swallow, J., & Woodruff, E. (1989). Computer-supported intentional learning environments. Journal of Educational Computing Research, 5(1), 51-68.