Earlier research on spreadsheet authors' mental models has shown that people possess several types of information about spreadsheets. Especially, when explaining a spreadsheet, the real-world and domain mental models are prominent and the spreadsheet model is suppressed, but when locating and fixing an error, one must constantly switch back and forth between the domain model and the spreadsheet model, which requires frequent use of the mapping between problem domain concepts and their spreadsheet model counterparts. This paper introduces a new spreadsheet visualization tool and its empirical evaluation. The tool translates traditional spreadsheet formulas into problem domain narratives and highlights referenced cells. The tool was found to be easy to learn and helped the participants to locate more errors in spreadsheets. Furthermore, the tool increased the use of the domain mental model and appeared to improve the mapping between the spreadsheet model and the domain model.

Earlier research on spreadsheet authors' mental models has shown that people possess several types of information about spreadsheets. The research results also suggested that a tool intended to aid in comprehension and debugging of spreadsheets should make prominent real-world and problem domain concepts and map them easily to spreadsheet-specific details. This poster introduces a new spreadsheet visualization tool which was developed to demonstrate that it is possible to have an easy-to-use spreadsheet understanding and debugging tool that relieves users from spreadsheet details and lets them utilize more of their mental model of the application domain. The tool translates traditional spreadsheet formulas into problem domain narratives and highlights referenced cells.

In this paper, we report on an empirical study exploring the nature of mental models of spreadsheet authors when they are explaining and debugging their own spreadsheets. Study participants were first asked to explain one of their own spreadsheets, and then to find and fix seeded errors in the same spreadsheets. Talk-aloud protocols were collected and analyzed to reveal the nature of participants' mental models in these activities. The findings indicate that the authors explain their spreadsheets mainly in terms of real-world and problem domain concepts; in debugging, they constantly switch between problem domain concepts and spreadsheet-specific concepts, although they mainly use spreadsheet-specific concepts to fix an identified error. These study findings provide insights on the need for developing spreadsheet authoring and debugging tools that correspond to spreadsheet authors' mental models of spreadsheets.

Students' understanding of object-oriented (OO) program execution was studied by asking students to draw a picture of a program state at a specific moment. Students were given minimal instructions on what to include in their drawings in order to see what they considered to be central concepts and relationships in program execution. Three drawing tasks were given at different phases of an elementary OO programming course where two animation tools were used for program visualization. The drawings were analyzed for their overall approaches and their detailed contents. There was a large variability in the overall approaches and the popularity of various approaches changed during the course. The results indicate that students' mental representations of OO concepts and program execution not only grow as new material is covered in teaching, but they also change. The first drawings treat methods as having primarily a static existence; later methods are seen as dynamic invocations that call each other. The role of classes in program execution fluctuates during learning, indicating problems in locating the notion of class with respect to, for example, objects. Two major sources of problems that manifested in many different forms were the relationship between object and method, and the role of the main method with respect to program state. Other problems were caused by overly simplistic understanding of object identification and improper use of application domain knowledge.

Students' understanding of object-oriented program execution was studied by asking students to draw a picture of a program state at a specific moment. Students were given minimal instructions on what to include in their drawings in order to see what they considered to be central concepts and relationships in program execution. Three drawing tasks were given at different phases of an elementary OO programming course where two animation tools were used for program visualization. The drawings were analyzed for their overall approaches and their detailed contents.There was a large variability in the overall approaches and the popularity of various approaches changed during the course. The results indicate that students' mental representations of OO concepts and program execution do not only grow as new material is covered in teaching, but they do also change. The first drawings treat methods as having primarily a static existence; later methods are seen as dynamic invocations that call each other. The role of classes in program execution fluctuates during learning indicating problems in locating the notion of class with respect to, e.g., objects. Two major sources of problems that manifested in many different forms were the relationship between object and method, and the role of the main method with respect to program state. Other problems were caused by too simplistic understanding of object identification and improper use of application domain knowledge.

Novice programmers' program tracing skills have been found to be poor but the difficulties leading to inefficient tracing are not well known. To study this issue, we conducted exploratory interviews that included program comprehension tasks with novice students and analyzed comprehension protocols to identify specific difficulties affecting novices' ability to trace programs. Based on the qualitative analysis, we describe four specific difficulties students had with program tracing-single value tracing, confusing function and structure, inability to use external representations, and inability to raise abstraction level-and discuss ways to help students to overcome these difficulties.

Expert programmers possess programming knowledge, which is language independent and abstract. Still, programming is mostly taught only via constructs of a programming language and explicit teaching of programming knowledge is often disregarded. Experts' high level programming knowledge can, however, be explicitly taught in an introductory programming course. This paper reports the results of a study in which the effects of teaching roles of variables to novices in an elementary programming course were examined. In the course expert programming knowledge was taught explicitly with the concept of roles and by using PlanAni, a role-based animator, which elaborates role knowledge and the concept of a variable in general. The study replicates methodologically our earlier study conducted in the same course a year earlier when roles were not used in the teaching. In this paper we discuss also the differences between the two student groups taught differently. The overall results show that students who were taught with roles learned high level programming plans faster and were able to use some complex programming plans better than students who were taught only with traditional methods.

Journal Article Lightweight techniques for structural evaluation of animated metaphors Get access Jorma Sajaniemi, Jorma Sajaniemi * Department of Computer Science and Statistics, University of Joensuu, P.O. Box 111, FI-80101 Joensuu, Finland * Corresponding author. Tel.: +358 13 2517933; fax: +358 13 2517955. E-mail address:[email protected] (J. Sajaniemi). Search for other works by this author on: Oxford Academic Google Scholar Tuija Stützle Tuija Stützle Department of Computer Science and Statistics, University of Joensuu, P.O. Box 111, FI-80101 Joensuu, Finland Search for other works by this author on: Oxford Academic Google Scholar Interacting with Computers, Volume 19, Issue 4, July 2007, Pages 457–471, https://doi.org/10.1016/j.intcom.2007.04.003 Published: 18 May 2007 Article history Received: 30 June 2006 Revision received: 05 April 2007 Accepted: 25 April 2007 Published: 18 May 2007

The development of high level programming knowledge is not well known and there are no direct techniques to evaluate and measure it. Measurement of programming skills is mostly based on the evaluation of programs written by students but the final programs do not reveal the correctness of students' mental models of programming concepts. This paper presents a new analysis model that can be used to evaluate students' mental models based on their program writing protocols with three different measures. The analysis model is based on the concept of roles of variables and extends the methodology of Rist's theory of schema expansion in programming but has a better coverage and is more finely grained than Rist's model. This paper also reports a study in which the applicability and the general validity of the model was studied by following the emergence of novice students' programming knowledge during their first programming course. The results suggest that the model is generally applicable for analyzing programming knowledge in novice level and that the three measures can be applied when focusing on different aspects of this knowledge.

Empirical evaluation of visualizations has so far been typically carried out by measuring the performance of participants that have been shown the visualization in relation to control group by grading programming tasks. Such studies tell little about what effects take place during the visualizations and how these effects build up into the learning effects. To address these issues, we are carrying out a series of experiments using visualization tools whose long-term effects are known.This paper presents a model of the cognitive phenomena that take place during visualization viewing sessions and describes an experiment where two visualization tools that differed in the amount of animation were used. The results show that even when participants were provided with rich visual information in the form of animations, they resorted heavily to the textual cues present on the screen. As the animation proceeded, participants started to follow visual cues more closely. However, if the names of the variables involved in the current operation were not in the visually cued area, participants tended to search for them in the program code. In the absence of animation, participants were more eager to browse the code in general.

Learning elementary programming can be enhanced by introducing the notion of variable roles to students. This paper presents a web-based automatic role detection service that can be utilized in teaching when consolidating role knowledge. The service is based on data flow analysis techniques and uses machine learning to create flow characteristics for roles. The current version recognizes roles with 93% accuracy which is comparable to that of human role assigners.

Roles of variables capture tacit expert knowledge in a form that can be taught in introductory programming courses. A role describes some stereotypic use of variables, and only ten roles are needed to cover 99% of all variables in novice-level programs. This paper presents the results from a protocol analysis of a program creation task in an experiment where roles were introduced to novices learning Pascal programming. Students were divided into three groups that were instructed differently: in the traditional way with no treatment of roles in lectures or program animation; using roles in lectures but not in animation; and using a role-based program animator in addition to using roles in lectures. The results suggest that the introduction of roles provides novices a new conceptual framework for better mental processing of program information and that the use of role-based program animation increases novices' ability to apply data-related programming plans in program construction.

Roles can be assigned to occurrences of variables in programs according to a small number of patterns of use that are both language- and algorithm-independent. Preliminary studies on explicitly teaching roles of variables to novice students have shown that roles are an excellent pedagogical tool for clarifying the structure and meaning of programs. This paper describes the results of an investigation designed to test the understandability and acceptability of the role concept and of the individual roles as seen by computer science educators. The investigation consisted of a short tutorial on roles, a brief training session on assigning roles to variables, a test evaluating the subjects' ability to assign roles, and a set of open questions concerning their opinions of roles. Roles were identified with 85 accuracy, and in typical uses of variables with 93 accuracy.

Computer programming is a difficult skill for many students and new methods and techniques to help novices to learn programming are needed. This paper presents roles of variables as a new concept that can be used to assist in learning and gives detailed instructions on techniques to present roles to novices. These techniques are based on current learning theories and they have been used in a classroom experiment comparing traditional teaching with role-based teaching. The results suggest that the introduction of roles provides students a new conceptual framework that enables them to mentally process programs in a way similar to that of good code comprehenders; the use of role-based animation seems to assist in the adoption of role knowledge and expert-like programming skill.

Abstract Spreadsheet calculation is a powerful tool in simple administrative data processing. Formulae in spreadsheets have similar forms to expressions in traditional programming languages, but the implementation of control structures is totally different. This paper contains an analysis of 101 spreadsheets made and used in business and government. The analysis concerns general properties, such as cell contents and referencing, the role of input, output and computation, and the different ways iteration is implemented. Finally some effects of expertise are studied. The results show that less than half of the available functions are really used, only one cell in 25 contains computation, and iteration is implemented in at least four different ways. Formulae are found to differ in their contents from expressions of programming languages, as control structures are implemented differently in these systems. Summation with a constant skip is suggested to be included in the set of functions of spreadsheet calculation.