Ville Karavirta

Merging interactive visualizations with hypertextbooks and course management

As a report of a working group at ITiCSE 2006, this paper provides a vision of how visualizations and the software that generates them may be integrated into hypertextbooks and course management systems. This integration generates a unique synergy that we call a Visualization-based Computer Science Hypertextbook (VizCoSH). By borrowing features of both traditional hypertextbooks and course management systems, VizCoSHs become delivery platforms that address some of the reasons why visualizations have failed to find widespread use in education.The heart of the paper describes these features and explains, from both a student and teacher perspective, how each feature adds educational value to a visualization. In some cases, this value focuses on pedagogical issues, taking advantage of known strategies for making visualizations more engaging and effective. In other cases, the emphasis is on making it easier for teachers to use visualizations. A set of possible use scenarios and approaches for increasing interest in adopting a VizCoSH are also presented.

Taxonomy of effortless creation of algorithm visualizations

The idea of using visualization technology to enhance the understanding of abstract concepts, like data structures and algorithms, has become widely accepted. Several attempts have been made to introduce a system that levels out the burden of creating new visualizations. However, one of the main obstacles to fully taking advantage of algorithm visualization seems to be the time and effort required to design, integrate and maintain the visualizations.Effortlessness in the context of algorithm visualization is a highly subjective matter including many factors. Thus, we first introduce a taxonomy to characterize effortlessness in algorithm visualization systems. We have identified three main categories based on a survey conducted among CS educators: i) scope, i.e. how wide is the context one can apply the system to ii) integrability, i.e., how easy it is to take in use by a third party, and iii) interaction techniques, i.e., how well does the system support different use cases regularly applied by educators. We will conclude that generic and effortless visualization systems are needed. Such a system, however, needs to combine a range of characteristics implemented in many current AV systems.

Experiences on automatically assessed algorithm simulation exercises with different resubmission policies

In this paper, we present our experiences in using two automatic assessment tools, TRAKLA and TRAKLA2, in a second course of programming. In this course, 500--700 students have been enrolled annually during the period 1993--2004. The tools are specifically designed for assessing algorithm simulation exercises in which students simulate the working of algorithms at a conceptual level. Both of these tools allow students to resubmit their solutions after getting feedback. However, the resubmission policy has changed considerably during the period. Those changes reflect the students performance in the exercises. We conclude that an encouraging grading policy, i.e., the more exercises they solve the better grades they achive, combined with an option to resubmit the solution is a very important factor promoting students learning. However, in order to prevent aimless trial-and-error problem solving method, the number of resubmissions allowed per assignment should be carefully controlled.

Development of XML-based tools to support user interaction with algorithm visualization

As a report of a working group at ITiCSE 2005, this paper represents a vision of the use of XML specifications and tools in algorithm visualization, particularly with regard to supporting user interaction. A detailed description is given of how an interesting event to be visualized is decomposed, combined with interactive questions, narratives, control flow code and metadata, and finally rendered into graphical primitive and transformation specifications. The heart of the paper is our discussion of XML specifications for content generation (the object being visualized), interactive questions, and graphical primitives and transformations, with briefer discussions of narratives and metadata. Examples are provided for each in an appendix, with fuller details to be published on an associated website that we hope will become a source of future standards in this area. In conclusion, the approach of the working group is discussed, and important remaining challenges are identified.

On the use of resubmissions in automatic assessment systems

Automatic assessment systems generally support immediate grading and response on learners submissions. They also allow learners to consider the feedback, revise, and resubmit their solutions. Several strategies exist to implement the resubmission policy. The ultimate goal, however, is to improve the learning outcomes, and thus the strategies should aim at preventing learners from using the resubmission feature irresponsibly. One of the key questions here is how to develop the system and its use in order to cut down such reiteration that does not seem to be worthwhile? In this paper, we study data gathered from an automatic assessment system that supports resubmissions. We use a clustering technique to draw a distinction among learner groups that seem to differ in their use of the resubmission feature and the points achieved from the exercises. By comparing these groups with each other, we conclude that for a small minority of learners there is a risk that they use the resubmission inefficiently. Some learners seem to resubmit the solution without thinking much between two consecutive submissions. In order to prevent such an aimless trial-and-error problem solving method, one option is to limit the number of allowed resubmissions. However, not all resubmissions are bad. In addition, there exist several ways to realize the limitations to achieve the best possible resubmission policy fit for all the students. These are discussed based on the evidence gathered during the research.

Two-Dimensional Parson's Puzzles: The Concept, Tools, and First Observations

Parson’s programming puzzles are a family of code construction assignments where lines of code are given, and the task is to form the solution by sorting and possibly selecting the correct code lines. We introduce a novel family of Parson’s puzzles where the lines of code need to be sorted in two dimensions. The vertical dimension is used to order the lines, whereas the horizontal dimension is used to change control flow and code blocks based on indentation as in Python. Python blocks have no explicit begin/end statements or curly braces to mark where the block starts or stops. Instead, indentation is used to define starts and stops of blocks and functions.

MatrixPro - a tool for demonstrating data structures and algorithms ex tempore

Algorithm animation has been researched since early 1980s and many different visualization systems have been developed. However, most of them have remained as research prototypes and almost none have gained wide acceptance by teachers as classroom demonstration tools. One of the key reasons for this has been that preparing animations has been too laborious. In this paper, we demonstrate a new tool, MatrixPro, in which animations are generated in terms of visual algorithm simulation. The user can graphically invoke ready-made operations available in the library to simulate the working of real algorithms. Since the system understands the semantics of the operations, the teacher can ex tempore demonstrate the execution of algorithms with different input sets, or work with what-if questions students ask in lectures. Such an approach lowers considerably the step for adopting algorithm visualization as a regular lecture tool.

A comprehensive taxonomy of algorithm animation languages

In this paper, we present a taxonomy of algorithm animation languages that augments Prices well-known taxonomy of software visualization. Whereas Prices taxonomy is directed to classifying features and characteristics of visualization systems, the new taxonomy focuses on evaluating current animation languages. The taxonomy can be used by algorithm visualization system designers as a tool to compare visualization system languages with each other as well as for designing and implementing new systems and language features. In addition, the taxonomy provides guidelines to the features that are needed for transferring animations between systems. This is an ongoing project that elaborates upon the work reported on in a briefer version of the taxonomy.

Analyzing the use of a rubric-based grading tool

Over the years, a lot of research has focused on how to assess programming courses. For programming courses, semiautomatic assessment combining automatic and manual feedback has been shown to be a good solution. In this paper, we will focus on the manual assessment part and analyze the use of a rubrics-based grading tool on larger courses with multiple graders. Our results show that the use of such tools can support objective grading with high-quality feedback with reasonable time usage. Finally, we will give some pointers for teachers intending to adopt such tools on their courses.

Roles of Variables in Teaching

Introduction Learning to program is not easy. Recent experimental studies into students programming ability have shown that university students in many countries have similar difficulties in writing (McCracken et al., 2001), tracing (Lister et al., 2004), and designing (Eckerdal, McCartney, Mostrom, Ratcliffe, & Zander, 2006) programs. The emergence of the expert programmer from the novice is a process that involves the formation of multiple mental models, deep and interlinked knowledge hierarchies, and abstract, generalized problem-solving patterns (Winslow, 1996). As programming instructors, our job is to initiate and facilitate this process. In this paper, we look at one tool--roles of variables--which may help us with this task. Schemas An expert solves problems fluently and fast and possesses domain-specific problem-solving strategies. A novice is uncoordinated and slow and commonly resorts to generic problem-solving strategies, such as trial-and-error and means-ends analysis. What is a complex problem for the novice may be for the expert merely a task with a familiar solution pattern. One explanation for this difference is suggested by schema theory. Schema theory argues that people bundle similar experiences into cognitive constructs called schemas. Schemas are abstractions of concrete cases of experience and have a crucial role in the way people store, organize, and understand information. A schema can be triggered and brought to bear--consciously or unconsciously--in new problem-solving situations similar to previously encountered ones. The importance of schemas, sometimes called plans, has been explored in many fields, including computer programming. (See e.g. Adelson, 1981; Chi, Glaser, & Rees, 1982; Detienne, 1990; Fix, Wiedenbeck, & Scholtz, 1993; Rist, 1989; Soloway & Ehrlich, 1984; Sweller & Levine, 1982.) For instance, say a student has encountered examples of (a) sequentially searching an array for the smallest integer, and (b) searching a linked list of Movie objects for the movie with the highest gross income. With enough practice and reflection, encountering such concrete cases contributes towards the eventual formation of a schema for sequential searching, which can be applied to similar problems. An expert has many schemas that accommodate various kinds of scenarios he or she is likely to encounter. A novice, lacking these schemas, flounders. Cognitive Load Human working memory is very limited in capacity (Baddeley, 1994), and a novices working memory resources are greatly taxed by problem-solving situations such as programming. Novice students of programming are commonly asked to complete assignments that require understanding of multiple interacting program components, algorithmic design, the sometimes less-than-obvious program syntax, language semantics, and the notional machine (Du Boulay, 1986). In addition, they may need to use an integrated development environment or similar tools, or to apply third-party libraries in their programs. As the novice juggles all these new concepts in their working memory, it is burdened with a high cognitive load. Excessive cognitive load hinders meaningful learning and schema formation (see e.g. Paas, Renkl, & Sweller, 2003; Tuovinen, 2000). Schemas combine related bits of knowledge into larger chunks, which can be brought to working memory and processed as a single entity. Sequential searching through a collection of elements, for instance, eventually becomes a single chunk of knowledge whose details do not need to be kept in working memory. With experience, a learner becomes increasingly familiar with common schemas. As this happens, triggering such schemas becomes increasingly unconscious and automatic, further lessening the strain on working memory. Pedagogical Implications If schemas play a crucial part in turning a novice into an expert, then it is crucial that we help our students construct them. …