4,134 research outputs found
A study of novice programmer performance and programming pedagogy.
Identifying and mitigating the difficulties experienced by novice programmers is an active
area of research that has embraced a number of research areas. The aim of this research
was to perform a holistic study into the causes of poor performance in novice
programmers and to develop teaching approaches to mitigate them. A grounded action
methodology was adopted to enable the primary concepts of programming cognitive
psychology and their relationships to be established, in a systematic and formal manner.
To further investigate novice programmer behaviour, two sub-studies were conducted
into programming performance and ability.
The first sub-study was a novel application of the FP-Tree algorithm to determine if
novice programmers demonstrated predictable patterns of behaviour. This was the first
study to data mine programming behavioural characteristics rather than the learner’s
background information such as age and gender. Using the algorithm, patterns of
behaviour were generated and associated with the students’ ability. No patterns of
behaviour were identified and it was not possible to predict student results using this
method. This suggests that novice programmers demonstrate no set patterns of
programming behaviour that can be used determine their ability, although problem
solving was found to be an important characteristic. Therefore, there was no evidence
that performance could be improved by adopting pedagogies to promote simple changes
in programming behaviour beyond the provision of specific problem solving instruction.
A second sub-study was conducted using Raven’s Matrices which determined that
cognitive psychology, specifically working memory, played an important role in novice
programmer ability. The implication was that programming pedagogies must take into
consideration the cognitive psychology of programming and the cognitive load imposed
on learners.
Abstracted Construct Instruction was developed based on these findings and forms a new
pedagogy for teaching programming that promotes the recall of abstract patterns while
reducing the cognitive demands associated with developing code. Cognitive load is
determined by the student’s ability to ignore irrelevant surface features of the written
problem and to cross-reference between the problem domain and their mental program
model. The former is dealt with by producing tersely written exercises to eliminate
distractors, while for the latter the teaching of problem solving should be delayed until
the student’s program model is formed. While this does delay the development of
problem solving skills, the problem solving abilities of students taught using this pedagogy
were found to be comparable with students taught using a more traditional approach.
Furthermore, monitoring students’ understanding of these patterns enabled micromanagement of the learning process, and hence explanations were provided for novice
behaviour such as difficulties using arrays, inert knowledge and “code thrashing”.
For teaching more complex problem solving, scaffolding of practice was investigated
through a program framework that could be developed in stages by the students.
However, personalising the level of scaffolding required was complicated and found to be
difficult to achieve in practice.
In both cases, these new teaching approaches evolved as part of a grounded theory study
and a clear progression of teaching practice was demonstrated with appropriate
evaluation at each stage in accordance with action researc
The Example Guru: Suggesting Examples to Novice Programmers in an Artifact-Based Context
Programmers in artifact-based contexts could likely benefit from skills that they do not realize exist. We define artifact-based contexts as contexts where programmers have a goal project, like an application or game, which they must figure out how to accomplish and can change along the way. Artifact-based contexts do not have quantifiable goal states, like the solution to a puzzle or the resolution of a bug in task-based contexts. Currently, programmers in artifact-based contexts have to seek out information, but may be unaware of useful information or choose not to seek out new skills. This is especially problematic for young novice programmers in blocks programming environments. Blocks programming environments often lack even minimal in-context support, such as auto-complete or in-context documentation. Novices programming independently in these blocks-based programming environments often plateau in the programming skills and API methods they use. This work aims to encourage novices in artifact-based programming contexts to explore new API methods and skills. One way to support novices may be with examples, as examples are effective for learning and highly available. In order to better understand how to use examples for supporting novice programmers, I first ran two studies exploring novices\u27 use and focus on example code. I used those results to design a system called the Example Guru. The Example Guru suggests example snippets to novice programmers that contain previously unused API methods or code concepts. Finally, I present an approach for semi-automatically generating content for this type of suggestion system. This approach reduces the amount of expert effort required to create suggestions. This work contains three contributions: 1) a better understanding of difficulties novices have using example code, 2) a system that encourages exploration and use of new programming skills, and 3) an approach for generating content for a suggestion system with less expert effort
Agents for educational games and simulations
This book consists mainly of revised papers that were presented at the Agents for Educational Games and Simulation (AEGS) workshop held on May 2, 2011, as part of the Autonomous Agents and MultiAgent Systems (AAMAS) conference in Taipei, Taiwan. The 12 full papers presented were carefully reviewed and selected from various submissions. The papers are organized topical sections on middleware applications, dialogues and learning, adaption and convergence, and agent applications
Designing as Construction of Representations: A Dynamic Viewpoint in Cognitive Design Research
This article presents a cognitively oriented viewpoint on design. It focuses
on cognitive, dynamic aspects of real design, i.e., the actual cognitive
activity implemented by designers during their work on professional design
projects. Rather than conceiving de-signing as problem solving - Simon's
symbolic information processing (SIP) approach - or as a reflective practice or
some other form of situated activity - the situativity (SIT) approach - we
consider that, from a cognitive viewpoint, designing is most appropriately
characterised as a construction of representations. After a critical discussion
of the SIP and SIT approaches to design, we present our view-point. This
presentation concerns the evolving nature of representations regarding levels
of abstraction and degrees of precision, the function of external
representations, and specific qualities of representation in collective design.
Designing is described at three levels: the organisation of the activity, its
strategies, and its design-representation construction activities (different
ways to generate, trans-form, and evaluate representations). Even if we adopt a
"generic design" stance, we claim that design can take different forms
depending on the nature of the artefact, and we propose some candidates for
dimensions that allow a distinction to be made between these forms of design.
We discuss the potential specificity of HCI design, and the lack of cognitive
design research occupied with the quality of design. We close our discussion of
representational structures and activities by an outline of some directions
regarding their functional linkages
Proceedings of the Second Program Visualization Workshop, 2002
The Program Visualization Workshops aim to bring together researchers who design and construct program visualizations and, above all, educators who use and evaluate visualizations in their teaching. The first workshop took place in July 2000 at Porvoo, Finland. The second workshop was held in cooperation with ACM SIGCSE and took place at HornstrupCentret, Denmark in June 2002, immediately following the ITiCSE 2002 Conference in Aarhus, Denmark
Exploiting persistence in CASE technology
Bibliography: pages 102-107.A Design Workbench has been built for Napier88 [MBC+94] as part of the natural progression towards developing better product systems and improving software construction tools. The system includes a Metamodeller (enabling users to specify the data and process models they prefer), a Model Builder which supports multiple coexisting models and a Target System Generator. Experience using the Workbench has shown that it is easy to use, increases productivity, improves programming standards and facilitates code sharing. This thesis demonstrates the benefits of orthogonal persistence for Computer-Aided Software Engineering by describing an initial design environment and its subsequent extension to include support for multiple co-existing models
- …