Pablo Romero

Whole body interaction

In this workshop we explore the notation of whole body interaction. We bring together different disciplines to create a new research direction for study of this emerging form of interaction

Debugging strategies and tactics in a multi-representation software environment

This paper investigates the interplay between high level debugging strategies and low level tactics in the context of a multi-representation software development environment (SDE). It investigates three questions. 1. How do programmers integrate debugging strategies and tactics when working with SDEs? 2. What is the relationship between verbal ability, level of graphical literacy and debugging (task) performance. 3. How do modality and perspective influence debugging strategy and deployment of tactics? The paper extends the work of Katz and Anderson [1988. Debugging: an analysis of bug location strategies. Human-Computer Interaction 3, 359-399] and others in terms of identifying high level debugging strategies, in this case when working with SDEs. It also describes how programmers of different backgrounds and degrees of experience make differential use of the multiple sources of information typically available in a software debugging environment. Individual difference measures considered among the participants were their programming experience and their knowledge of external representation formalisms. The debugging environment enabled the participants, computer science students, to view the execution of a program in steps and provided them with concurrently displayed, adjacent, multiple and linked programming representations. These representations comprised the program code, two visualisations of the program and its output. The two visualisations of the program were available, in either a largely textual format or a largely graphical format so as to track interactions between experience and low level mode-specific tactics, for example. The results suggest that (i) additionally to deploying debugging strategies similar to those reported in the literature, participants also employed a strategy specific to SDEs, following execution, (ii) verbal ability was not correlated with debugging performance, (iii) knowledge of external representation formalisms was as important as programming experience to succeed in the debugging task, and (iv) participants with greater experience of both programming and external representation formalisms, unlike the less experienced, were able to modify their debugging strategies and tactics effectively when working under different format conditions (i.e. when working with either largely graphical or largely textual visualisations) in order to maintain their high debugging accuracy level.

A survey of external representations employed in object-oriented programming environments

Abstract This document presents an overview of the program visualisations additional to the program code provided by some of the most popular object-oriented programming environments to support tasks involving program comprehension. These representations were compared in terms of the programming aspects they highlight and of their information modality. Those with common characteristics according to these criteria were identified. Finally, a brief analysis of these common representations in terms of Greens Cognitive Dimensions is presented. Two questions arising from this survey are (a) whether representations additional to the code should be redundant and highlight similar information to the main notation or be complementary and highlight different programming aspects and (b) which factors might increase the cognitive difficulty of co-ordinating these additional representations and the program code. More theoretical knowledge about the way these additional representations influence the comprehension of computer programs seems to be needed.

A Cognitive Processing Perspective on Student Programmers' 'Graphicacy'

The ‘graphicacy’ of student programmers was investigated using several cognitive tasks designed to assess ER knowledge representation at the perceptual, semantic and output levels of the cognitive system. A large corpus of external representations (ERs) was used as stimuli. The question ‘How domain-specific is the ER knowledge of programmers?’ was addressed. Results showed that performance for programming-specific ER forms was equal to or slightly better than performance for non-specific ERs on the decision, naming and functional knowledge tasks, but not the categorisation task. Surprisingly, tree and network diagrams were particularly poorly named and categorised. Across the ER tasks, performance was found to be highest for textual ERs, lists, maps and notations (more ubiquitous, ‘everyday’ ER forms). Decision task performance was generally good across ER types indicating that participants were able to recognise the visual form of a wide range of ERs at a perceptual level. In general, the patterns of performance seem to be consistent with those described for the cognitive processing of visual objects.

The effects of graphical and textual visualisations in multi-representational debugging environments

The effects of graphical and textual visualisations in a multi-representational debugging environment were investigated in computing students who used a software debugging environment (SDE) that allowed them to view the execution of programs in steps and that provided them with concurrently displayed, adjacent, multiple and linked representations. The experimental results are in agreement with research in the area that suggests that good debugging performance is associated with a balanced use of the available representations. Additionally, these results raise the issue of whether graphical visualisations promote a more judicious representation use than textual ones for program debugging in multi-representational environments.

Pair programming and the re-appropriation of individual tools for collaborative programming

Although pair programming is becoming more prevalent in software development, and a number of reports have been written about it [4] [6], few have addressed the manner in which pairing actually takes place [5]. Even fewer consider the methods employed to manage issues such as role change or the communication of complex issues. Here we contribute by highlighting the way resources designed for individuals are re-appropriated and augmented to facilitate pair collaboration.

Focal structures and information types in Prolog

Several studies have suggested that the mental structures of programmers of procedural languages have a close relationship with a model of structural knowledge related to functional information known as programming Plans. It also has been claimed that experienced programmers organize this representation in a hierarchical structure where some elements of Plans are focal or central to them. However, it is not clear that this is the case for other types of programming languages, especially for those which are significantly different from the procedural paradigm.The study reported in this paper investigates whether these claims are true for Prolog, a language which has important differences to procedural languages. Prolog does not have obvious syntactic cues to mark blocks of code (begin/end, repeat/until, etc). Also, its powerful primitives (unification and backtracking) and the extensive use of recursion might influence how programmers comprehend Prolog code in a significant way.The findings of the study suggest that Plans and functional information are important for Prolog programmers, but that there is also at least another model of structural knowledge valid for this language. This model of structural knowledge, Prolog schemas, is related to data structure information and it seems that a hierarchical organisation that highlights the relevance of some of its elements as focal is valid for Prolog. These results support the view that comprehension involves the detection of varying aspects of the code and that each of the structures related to these aspects might have their own organization and hierarchical relations.

A methodology for the capture and analysis of hybrid data: A case study of program debugging

This article describes a methodology for the capture and analysis of hybrid data. A case study in the field of reasoning with multiple representations—specifically, in computer programming—is presented to exemplify the use of the methodology. The hybrid data considered comprise computer interaction logs, audio recordings, and data about visual attention focus. The capture of the focus of visual attention data is performed with software. The software employed tracks the user’s visual attention by blurring parts of the stimuli presented on the screen and allowing the participant to see only a small region of it at any one time. These hybrid data are analyzed via a methodology that combines qualitative and quantitative approaches. The article describes the software tool employed and the analytic methodology, and also discusses data capture issues and limitations of the approach.

Is Embodied Interaction Beneficial When Learning Programming

Embodied interaction has been claimed to offer important advantages for learning programming. However frequently claims have been based on intuitions and work in the area has focused largely around system-building rather than on evaluation and reflection around those claims. Taking into account research in the area as well as in areas such as tangibles, psychology of programming and the learning and teaching of programming, this paper identifies a set of important factors to take into account when analysing the potential of learning environments for programming employing embodied interaction. These factors are formulated as a set of questions that could be asked either when designing or analysing this type of learning environments.

Structural Knowledge and Language Notational Properties in Program Comprehension

Several accounts of program comprehension have taken the theory of text comprehension by Kinstch as a starting point to model the mental representations built when programmers understand a computer program. A crucial point that these accounts try to explain is how these mental representations are organised. According to Kintschs theory, the mental representations built as a product of the text comprehension process are interrelated propositional networks whose organisation is determined by the main idea of the text. In program comprehension, this main idea has been understood in terms of functionality. This paper contends this notion, proposing that in program understanding programmers mental representations are multifaceted and organised through several criteria. Which of these is the most important one depends on the programming language employed among other factors. The fact that functional information appeared as crucial might have been because most of the empirical research that has been undertaken has employed procedural languages. This claim is tested empirically by analysing the mental representations of programmers in Prolog, a declarative programming language. The results support our claim by showing that in this case data structure information is more important than function