GENERIC CODE-MEMORY DIAGRAM ANIMATION CREATOR:
AN AID FOR EFFECTIVE COMPUTER-PROGRAMMING TEACHING
Mark Dixon
University of Plymouth, School of Computing Communications and Electronics, Drake Circus, Plymouth, UK
Abstract
Previous work has described difficulties of using static media (books and lecture slides) with narratives to explain dynamic computer programming concepts. The potential for code-memory diagram (CMD) animation software to overcome these limitations and enhance student learning has been demonstrated. This language independent software tool is particularly relevant to higher education with recent increases in class sizes.
For these animations to realise this potential, there must be a mechanism for lecturers to quickly and easily create and adapt animations to meet their specific needs.
This paper focuses on the interaction between the CMD animation software and the lecturer during preparation-time. It describes a year-long evaluation of the software, and the development and evaluation of animation editing software.
Participant observation was employed to determine how the software performed over an academic year. Semi-structured interviews were conducted with 3 lecturers to determine current use of animations, and the perceived usefulness of the enhanced version of the software. Current use of animation was perceived to be very useful, but restricted by the level of preparation time required. The lecturers perceived the CMD animation creation software as ‘fast’, ‘easy’, ‘brilliant’, and a potential solution to this, and were very keen to start using it.
Key Words
Teaching computer programming, computer assisted learning
1. Introduction
Previous work has described problems with teaching computer programming, and the potential of code-memory diagram (CMD) animation software to improve student understanding, as an aid to student-lecturer interaction during contact time (lectures and tutorials).
This paper focuses on lecturer-computer interaction while creating CMD animations during preparation time (a critical factor in realising the potential of such animations).
1.1 Teaching computer programming: Problems
Computer programming is widely regarded as difficult to learn and teach, with some concepts (such as passing parameters by reference) being identified as particularly problematic [1]. This is compounded by two factors in higher education (HE). Firstly, students are admitted to undergraduate computing degrees with no prior experience of computer programming, which creates a diverse range of subject specific prior knowledge in stage 1 groups. Secondly, over the past 10 years, there has been a trend toward the ‘massification’ of HE in the UK and internationally, which has resulted in larger class sizes and an increased proportion of less able/motivated students [2].
A key practical problem in teaching computer programming is the conflict between the fundamental concepts and the ‘standard’ explanation media (such as books and lecture slides). The concepts are dynamic (relating to changes occurring in memory over time), whereas the media are static requiring lengthy narratives that are notoriously difficult to follow and therefore largely ineffective.
1.2 Code-memory diagram animation software: student-lecturer-computer interaction
Previous work [3] has demonstrated the ability of code-memory diagram (CMD) animation software tools to enhance student understanding of computer-programming concepts (such as variables, arrays, functions, and procedures).
Figure 1 shows the CMD animation viewer software. This automated the manual process of drawing CMDs (on paper or the white-board), which involved showing the effect that individual lines of code have on variables in memory. It also went beyond the manual process, providing facilities that were too time consuming to
perform by hand, such as constantly displaying an arrow indicating the current line, and ticking each line that had been executed.
Figure 1: Code-memory diagram animation viewer software.
This provided an explicit detailed visual model of the dynamic interactions between individual lines of code and variables in memory, which overcame the limitations of static media (such as books and slides). The software also provided a common point of reference that supported the student-lecturer scaffolding [4] process.
1.3 CMD animation creation: lecturer-computer interaction
In order to realise the potential of CMD animations for widespread routine use, there must be a quick and easy way for lecturers to create animations that meet their specific needs.
Anecdotal evidence and informal discussions with other lectures indicated a common perception that animations can help explain programming concepts to students – why then are animations not in more widespread use? Is it possible that the single factor preventing more widespread use of animation in teaching programming is the time required to produce and modify individual animations. This paper describes the:
• further development of the animation viewer software tool, that allowed it to be used in conjunction with Microsoft PowerPoint,
• evaluation of CMD animation software over a year long module,
• further development of the animation creation software to provide a quick and easy ‘direct manipulation’ [5] interface for creating CMD animations, and
• pilot evaluation of this improved animation creation software.
A large proportion of educational research focuses on student-lecturer or student-computer interaction during contact time. This paper focuses on lecturer-computer interaction during preparation time. As such it emphasises the relationship between preparation time, quality of teaching, and effectiveness of teaching in terms of increases in student understanding.
2. Method
This paper presents the current state (phase 2 and the pilot stage of phase 3) of an on-going programme of work, which has 4 phases:
• Phase 1 (use in controlled environment by lecturer-developer) – This represented a proof of principle for the CMD animation viewer software in revision sessions at the end of a module. This used a student perception questionnaire, video observation, and participant observation to determine whether the software enhanced or inhibited student learning. It was completed during the 2002/2003 academic year, and has been reported in [3].
• Phase 2 (routine use by lecturer-developer) – This used the CMD animation viewer software across a complete year long module. It involved the modification of the CMD animation viewer software for smoother integration with PowerPoint slides, and the development of the CMD animation editor software (to make creating and editing animations easier and quicker – phase 1 animations were created by typing data directly into Microsoft Access database tables). This sought to determine whether the use of the software in routine teaching sessions was practical. It has been undertaken during the current (2003/2004) academic year, and although not complete the remaining week of teaching is unlikely to significantly alter the findings. This phase is described in more detail in section 2.1.
• Phase 3(trial use by other lecturers) – This represents the use of the CMD animation viewer and enhanced creator software by a small number of ‘trial’ lectures within the developer’s own institution across the 2004/2005 academic year. The preliminary pilot stage of this phase has been completed. This phase is described in more detail in section 2.2.
• Phase 4(routine use by wider lecturing community) – This represents the ultimate goal of widespread general release of the software within the general teaching population.
It is tempting to argue that the benefits and impact of using the tool are obvious. However, the introduction of technology without empirical evidence of its safety and usefulness is potentially very dangerous. History presents several examples of new technology being introduced
without thorough evaluation, sometimes with disastrous consequences.
For example, in the late 1960s a new technology was introduced into obstetric medicine, called the cardiotocogram (CTG), it recorded (onto a paper trace) a baby’s heart rate and the contractions of the mother’s uterus during birth. This was done without large scale trials on the basis that it’s usefulness was obvious. However, recent studies have found no difference in outcome between CTG based and traditional methods of monitoring, and continuous CTG monitoring has been associated with an increase in unnecessary intervention (such as caesarean section). Every recent annual report of the confidential enquiry into stillbirths and death in infancy (CESDI) has identified misinterpretation of the CTG as a significant cause of unnecessary fetal death [6].
2.1 Phase 2 – Use by author in routine sessions.
The CMD animation viewer software was modified for easier integration with Microsoft PowerPoint slides (described in section 3.1), and a CMD animation editor was developed (described in section 3.2).
This software was then used in a year-long stage 1 computer-programming module of an undergraduate computing degree, delivered by the author. Data collection was therefore longitudinal, and based upon participant observation. This was selected to minimise interference with student learning, and because prolonged employment of other methods (such as questionnaire, or video observation) would have been impractical.
This degree was not typical of computing degrees in that it combined technical computing with art and design. As a result students tended to have less technical experience than those on straight computing degrees. About 50% of the students had prior experience with computer-programming (typically 2 years A level at school of college of further education). The remaining 50% had no prior experience with computer-programming.
The module spanned the 2003-2004 academic year (split into 3 terms). All teaching material was delivered in the first two terms, with the final term being used for formal examinations. Term 1 focused on fundamental computer-programming concepts (such as variables, loops, and procedures). Term 2 extended this into database front-end development, object-oriented programming, and web development (client-side and server-side scripting).
2.2 Phase 3 – Trial use by other lecturers in routine sessions.
Initial Development
The CMD animation editor software was modified to make creating and changing animations easier and quicker (described in section 3.3).
Pilot Review
Review sessions were then conducted independently with 3 other computer programming lecturers in the author’s host institution. These sessions were 1:1 and off-line (no students were present). This involved a questionnaire-guided semi-structured interview [7], and accompanying software demonstration. The first 6 questions in the questionnaire aimed to identify what modules the lectures currently taught, to what degree animations were used, how effective this was (in terms of both student learning and usefulness to the lecturer), and whether there were any difficulties. The CMD animation viewer and editor software were demonstrated after these questions were answered. The seventh (final) question sought to elicit the lecturers’ impression of how useful the software would be to them, and where it would be applied in their teaching. Longitudinal Evaluation
The main stage of phase 3 will commence in September 2004 and run over the duration of the 2004/2005 academic year. The three lecturers who participated in stage 1 will use the CMD animation creation and viewer software in their modules. Longitudinal participant observation will be used to evaluate the software’s effectiveness (both in terms of student learning and impact on lectures).
3. Code-Memory Diagram Animation
Software
The aim of the work was to develop a common framework and an automated software tool for presenting animations of code-memory interactions to students. The software would need to be language independent, and provide facilities to quickly and easily generate new animations and adapt existing animations for specific use.
3.1 Phase 2 Animation Viewer
The CMD animation viewer software used in phase 1 was modified to allow the animations to be linked to slides in PowerPoint presentations. The link started a specific animation immediately (the drop-down list of animations, and buttons were not shown). Clicking anywhere on the CMD moved on to the next frame in the animation, and when the last frame was shown, a further click closed the viewer and returned to PowerPoint.
3.2 Phase 2 Animation Creator
Figure 2 shows the initial (phase 2) user interface design for the code-memory diagram animation editor software.
Figure 2: Initial user interface design for the code-memory diagram animation editor software.
This was strongly tied to the internal representation of the CMD animation data. It had three main display areas:
• Code (C): This was used to edit the code text.
• Instructions (I): This was used to add, edit, and remove instructions that made up the animation. As an instruction was selected, its data items were displayed (and could be edited) in the text boxes above the list. The user (lecturer) had to type all data associated with an instruction. This included entering a whole number representing the position that a newly created variable appeared in the memory diagram. It also required the entry of the line number of the next line of code.
• Viewer (V): This allowed the user to simulate the animation as it would appear to students in the viewer software. This operated separately from the instruction editing facilities.
3.3 Phase 3 Animation Creator: Direct Manipulation
Terminology
An animation consists of a sequence of frames. Each frame consists of one or more instructions, and is associated with a particular line of code. Each instruction changes the code-memory diagram in some way. There are four types of instruction:
• Do – This is used to record the execution of a particular line of code, with no change to the memory diagram. Complete execution is shown on the diagram by displaying a tick to the left of the line. Partial execution (as in the case of a function or procedure call) is shown by a filled circle in the same place.
• Create variable – This is used to represent the creation of a variable in memory. It causes a rectangle to be drawn on the memory diagram, with the variable name to the left and its value inside.
• Set variable– This is used to represent the changing of a variable’s value. It causes the value of a variable shown in the memory diagram to change.
• Remove variable – This is used to represent the memory used by a variable being released when the variable goes out of scope. It causes a variable in the memory diagram to disappear.
User Interface Design
Figure 3 shows the ‘direct manipulation’ user interface design for the (phase 3) CMD animation editor software.
Figure 3: ‘direct manipulation’ user interface design for the code-memory diagram animation editor software.
There are three main panes:
• Animation pane(A) – shows a list of all animations in the current database, and provides facilities to add new animations; and edit, remove, save, and select existing animations. Once an animation is selected its associated data is displayed in the frame (F) and viewer panes (V).
• Frame pane (F) – shows a graph/chart representing the sequence of frames that will be displayed when the animation is viewed. Each node on the graph represents a single instruction, and is colour coded on the basis of instruction type (do – green, create variable – yellow, set variable – cyan, and remove variable – red) to make recognition easier. Clicking any instruction will select that instruction and run the animation in the viewer pane to that point. Clicking the right mouse button brings up a popup menu, which provides facilities to manipulate the selected
F A V
instruction and insert an new instruction at the current point in the animation.
• Viewer pane(V) – simulates what will be displayed when the animation is shown to students by the viewer software. It also provides facilities to add and modify instructions, via rapid and easy direct manipulation [5] of the CMD:
Insert Do frame: This is done by selecting and double-clicking a portion of text in a line of code.
Insert Create Variable frame: This is done by selecting a portion of text in a line of code and dragging it into an unoccupied part of the memory diagram.
Insert Set Variable frame: This is done by selecting a portion of text in a line of code and dragging it into an existing variable.
Insert Remove Variable frame: This is done by dragging a variable from the CMD onto the line of code which deletes it (causes it to go out of scope).
Change Frame’s code line: The line of code that the currently selected frame is associated with can be changed by dragging the program counter arrow up or down.
Change Variable’s position on CMD: The
position that a variable appears at on the CMD can be adjusted by selecting the frame that created the variable and dragging the variable on the CMD up or down.
The edit code button allows the lines of code to be changed, by typing directly into the code on the CMD.
4. Results
4.1 Phase 2
Nine animations were developed over the duration of the first term specifically for delivery in lectures (to accompany PowerPoint slides) and subsequent re-use in tutorials. These animations covered variables, conditional execution, loops, arrays, structures/records, variable scope, functions, and passing procedure arguments by reference.
The animations worked well in both lectures and tutorials (confirming the phase 1 findings): they were well received by students, made delivery easier (by reducing the amount of mundane drawing work), provided a common point of reference, and enhanced student understanding.
No new animations were developed during the second term, although animations from the first term were used to revise material. There were two reasons for this. Firstly, although the animations were quicker to produce than equivalent PowerPoint presentations, they still required a considerable amount of time, which limited the frequency of use. As the module progressed the material became
more complex and examples became longer, which increased the time required to produce animations to the point where it just was not viable in the time available. Secondly, the software had no explicit support for second term concepts such as object oriented programming; and client-side and server-side web code.
This phase was not fully completed at the time of publication (1 teaching week left in term 2). However, a pattern had emerged in the data, which seemed unlikely to change in the last teaching week.
4.2 Phase 3: Pilot Review
Current teaching: All three lecturers confirmed that they were currently teaching computer programming modules (6 in total), ranging across all stages 0 (foundation year – access to HE), 1, 2, and 3. Four modules used Java, one used C++, and one used Visual BASIC. All modules either introduced or depended upon fundamental programming concepts (such as variables, loops, procedures, and functions). Five modules focused on object-oriented programming.
Current use of animation: All three lecturers used Microsoft PowerPoint to prepare lecture slides. One lecturer indicated that they had not used animation before, the other two indicated that they used animation to ‘annotate’ and ‘build up’ code ‘bit by bit’, and to show the interactions between code and memory for concepts such as parameter passing, pointers, and object creation. Effectiveness of animation: The two lecturers who used animation indicated that it was ‘very useful’ and ‘useful’ to them during sessions, and ‘very effective’ and ‘effective’ in improving student understanding.
Animation preparation time: The amount of preparation time required was described as ‘high’ dropping to ‘medium’ once ‘I’ve done it a lot of times’, and ‘high’ to ‘very high’. An estimate of the actual time difference was given as about ‘2 minutes’ for one text-only slide, and about ’10 to 15 minutes’ for one slide of animation, with the comment that once this was scaled up to a nominal 20 slides per 1 hour lecture ‘it takes forever’. The two lecturers who used animation said that they would like to use it more, but that ‘the amount of time it takes’ to prepare caused by the limitations of the presentation tools available makes this impractical.
Usefulness of Software: After the demonstration of the CMD animation software viewer and editor the lecturers indicated that its usefulness in their modules would be very high, very high/high, and very high/high. They described it as ‘brilliant’, ‘very quick’, ‘very clear’, and ‘easy to use’. They indicated that it was most obviously powerful for teaching stage 0 and 1 students, although it seemed to have potential for object-oriented programming concepts taught mainly during stages 2 and 3.
5. Conclusion
5.1 CMD Animation Viewer software
The use of the CMD animation software over a year long module (phase 2), confirmed that the benefits observed during the revision sessions (phase 1) also apply during routine use in normal teaching sessions. The software continually enhanced student understanding, by providing an explicit model of code-variable interaction, alleviating the lecturer of a significant portion of mechanistic drawing tasks, and supporting student-lecturer interaction.
5.2 CMD Animation Creator software
The routine use of the CMD animation software over the duration of an entire module, demonstrated that the ability to create animations quickly and easily is critical. Without this the full benefit of CMD animations cannot be realised, as the preparation-time required can make creation and modification of animations impractical within the timeframes available.
This highlights the need for thorough evaluation of new teaching methods and technologies. If the initial (phase 2) version of the CMD animation creation software were released it could have significantly added to the lecturer’s already high workload. This could have made teaching computer programming more difficult, and given a falsely negative indication of the potential benefits of the approach.
5.3 Current use of animation in teaching computer-programming
The interviews with lecturers (phase 3) gave a strong indication that within a small sample of lecturers animation was perceived to be very useful (both for the lecturer and the students), but very time consuming and therefore not used as often as lectures would like. The enhanced CMD animation creation software was seen as a potential solution to this, making the creation and modification of animations extremely quick and easy. The lecturers perceived the software as been very useful in their teaching, and were very keen to start using it.
5.4 Further work
These results justify commencement of trial use by a limited number of other lecturers (phase 3), during the next academic year.
This will include the application of CMD animation software beyond fundamental programming concepts, into object oriented programming, and web programming. This may lead to enhancements that provide specific functionality for these topics.
Other areas of investigation include more-complex animations, larger-scale studies of impact on student understanding, the adaptation of the creator software for use in formative and summative student assessment, and the development and evaluation of a web-based version.
References:
[1] I. Milne, & G. Rowe, Difficulties in Learning and Teaching Programming – views of students and tutors, Education and Information Technologies,7(1), 2002, 55-66.
[2] J. Biggs,Teaching for Quality Learning in University (Open University Press, 1999).
[3] M. Dixon, Code-memory diagram animation software tool: towards on-line use. Proc. IASTED Conf. on Web Based Education, Innsbruck, Austria, 2004, 601-603. [4] B. Somekh, Designing software to maximise learning, Association for Learning Technology Journal,4(3), 1996, 4-16.
[5] B. Shneiderman, Designing the user interface: Strategies for Effective Human-Computer Interaction (Addison-Wesley Publishing Company Inc., 1998) [6] Confidential Enquiry into Stillbirths and Deaths in Infancy, 8th annual report(London: Maternal and Child Health Research Consortium, 2001).
[7] A.N. Oppenheim,Questionnaire design, interviewing and attitude measurement(Pinter, 1992).
