29,807 research outputs found
Pair programming and the re-appropriation of individual tools for collaborative software development
Although pair programming is becoming more prevalent in software development, and a number of reports have been written about it [10] [13], few have addressed the manner in which pairing actually takes place [12]. Even fewer consider the methods used to manage issues such as role change or the communication of complex issues. This paper highlights the way resources designed for individuals are re-appropriated and augmented by pair programmers to facilitate collaboration. It also illustrates that pair verbalisations can augment the benefits of the collocated team, providing examples from ethnographic studies of pair programmers 'in the wild'
Links between the personalities, styles and performance in computer programming
There are repetitive patterns in strategies of manipulating source code. For
example, modifying source code before acquiring knowledge of how a code works
is a depth-first style and reading and understanding before modifying source
code is a breadth-first style. To the extent we know there is no study on the
influence of personality on them. The objective of this study is to understand
the influence of personality on programming styles. We did a correlational
study with 65 programmers at the University of Stuttgart. Academic achievement,
programming experience, attitude towards programming and five personality
factors were measured via self-assessed survey. The programming styles were
asked in the survey or mined from the software repositories. Performance in
programming was composed of bug-proneness of programmers which was mined from
software repositories, the grades they got in a software project course and
their estimate of their own programming ability. We did statistical analysis
and found that Openness to Experience has a positive association with
breadth-first style and Conscientiousness has a positive association with
depth-first style. We also found that in addition to having more programming
experience and better academic achievement, the styles of working depth-first
and saving coarse-grained revisions improve performance in programming.Comment: 27 pages, 6 figure
Understanding Programmers' Working Context by Mining Interaction Histories
Understanding how software developers do their work is an important first step to improving their productivity. Previous research has generally focused either on laboratory experiments or coarsely-grained industrial case studies; however, studies that seek a finegrained understanding of industrial programmers working within a realistic context remain limited. In this work, we propose to use interaction histories â that is, finely detailed
records of developersâ interactions with their IDE â as our main source of information for understanding programmerâs work habits. We develop techniques to capture, mine, and analyze interaction histories, and we present two industrial case studies to show how this approach can help to better understand industrial programmersâ work at a detailed level: we explore how the basic characteristics of software maintenance task structures can be better understood, how latent dependence between program artifacts can be detected at interaction time, and show how patterns of interaction coupling can be identified. We also examine the link between programmer interactions and some of the contextual factors of software development, such as the nature of the task being performed, the design of the software system, and the expertise of the developers. In particular, we explore how task boundaries can be automatically detected from interaction histories, how system design
and developer expertise may affect interaction coupling, and whether newcomer and expert developers differ in their interaction history patterns. These findings can help us to better reason about the multidimensional nature of software development, to detect potential problems concerning task, design, expertise, and other contextual factors, and to build smarter tools that exploit the inherent patterns within programmer interactions and provide improved support for task-aware and expertise-aware software development
Recommended from our members
Team-oriented process programming
Team-oriented process programming promises to provide significant support for the planning, directing, and controlling of software engineering projects. In this paper we apply process programming to software engineering teams and show how this can provide powerful new capabilities for the management of software projects. We identify key issues which must be addressed to apply process programming to teams, and present our vision for team-oriented process programming
The abstraction transition taxonomy: developing desired learning outcomes through the lens of situated cognition
We report on a post-hoc analysis of introductory programming lecture materials. The purpose of this analysis is to identify what knowledge and skills we are asking students to acquire, as situated in the activity, tools, and culture of what programmers do and how they think. The specific materials analyzed are the 133 Peer Instruction questions used in lecture to support cognitive apprenticeship -- honoring the situated nature of knowledge. We propose an Abstraction Transition Taxonomy for classifying the kinds of knowing and practices we engage students in as we seek to apprentice them into the programming world. We find students are asked to answer questions expressed using three levels of abstraction: English, CS Speak, and Code. Moreover, many questions involve asking students to transition between levels of abstraction within the context of a computational problem. Finally, by applying our taxonomy in classifying a range of introductory programming exams, we find that summative assessments (including our own) tend to emphasize a small range of the skills fostered in students during the formative/apprenticeship phase
A review of Australasian investigations into problem solving and the novice programmer
This Australasian focused review compares a number of recent studies that have identified difficulties encountered by novices while learning programming and problem solving. These studies have shown that novices are not performing at expected levels and many novices have only a fragile knowledge of programming, which may prevent them from learning and applying problem solving strategies. The review goes on to explore proposals for explicitly incorporating problem solving strategy instruction into introductory programming curricula and assessment, in an attempt to produce improved learning outcomes for novices. Finally, directions suggested by the reviewed studies are gathered and some unanswered questions are raised
A methodology for the capture and analysis of hybrid data: a case study of program debugging
No description supplie
- âŠ