Language-Independent Conceptual “Bugs” in Novice Programming

@article{Pea1986LanguageIndependentC,
  title={Language-Independent Conceptual “Bugs” in Novice Programming},
  author={Roy D. Pea},
  journal={Journal of Educational Computing Research},
  year={1986},
  volume={2},
  pages={25 - 36}
}
  • R. Pea
  • Published 1 February 1986
  • Education
  • Journal of Educational Computing Research
This article argues for the existence of persistent conceptual “bugs” in how novices program and understand programs. These bugs are not specific to a given programming language, but appear to be language-independent. Furthermore, such bugs occur for novices from primary school to college age. Three different classes of bugs—parallelism, intentionality, and egocentrism—are identified, and exemplified through student errors. It is suggested that these classes of conceptual bugs are rooted in a… 
View on SAGE
telearn.archives-ouvertes.fr
274 Citations
Highly Influential Citations
26
Background Citations
131
Methods Citations
14
Results Citations
4

274 Citations

Alternatives to construct-based programming misconceptions

  • J. SpohrerElliot Soloway
  • Computer Science
    CHI '86
  • 1986
It is argued that most bugs are not due to misconceptions about the semantics of language constructs, based on the empirical study of 101 bug types from three programming problems.

Programming in Java: student-constructed rules

This study examined beginning students' understanding of the construction and use of objects in Java, including the most common false assumptions or “student-constructed rules” invoked by the students and the implications of the interviews for instruction.

Studying the language and structure in non-programmers' solutions to programming problems

The ways that non-programmers express solutions to problems that were chosen to be representative of common programming tasks are examined, to identify the features and paradigms that seem to match these natural tendencies as well as those that do not.

Using Systematic Errors to Investigate the Developing Knowledge of Programming Language Learners

It is suggested that students had major difficulties with using the semicolon, the sequencing operator of the programming language ALGOL 68, due to the fact that students did not immediately understand a specific simply stated rule of syntax, introduced in a decontextualised way, but rather that their understanding of the rule developed with their increasing experience of using it in different contexts.

Tracing quiz set to identify novices' programming misconceptions

A tracing quiz set was developed to locate the exact points at which students will fail and an interactive test system was developed which showed the correct answers to the students and requested them to describe their explanations.

How Users Interpret Bugs in Trigger-Action Programming

This work systematizes the temporal paradigms through which TAP systems could express rules and identifies ten classes of TAP programming bugs related to control flow, timing, and inaccurate user expectations, and suggests directions for better supporting end-user programmers.

Debugging: The key to unlocking the mind of a novice programmer?

  • Tony Lowe
  • Computer Science
    2019 IEEE Frontiers in Education Conference (FIE)
  • 2019
This paper will provide an example of this by reinterpreting debugging literature using TAMP as a theoretical guide, which suggests a “debugging-first” pedagogy can supplement existing methods of teaching programming and perhaps fill some of the mental gaps TAMP suggests hamper novice programmers.

The Role of Systematic Errors in Developmental Studies of Programming Language Learners

The results of the investigation demonstrate that students had major difficulties using the semicolon, the sequencing operator of the programming language ALGOL 68, and suggest that such systematic low-level syntactic errors may be indicative of higher-level misconceptions regarding the structure of the language.

A Study of Code Design Skills in Novice Programmers using the SOLO taxonomy

This work presents an evaluation framework that uses the SOLO taxonomy to assess programming questions' complexity and extends SOLO by using the term "building block" as an adaptable parameter that explicitly defines the student's ability to increasingly write more complex pieces of code.

Toward a Framework of Programming Pedagogy

The term “programming pedagogy” here refers to any instructional methods and strategies which are used to teach students introductory programming, and is focused on approaches of teaching computer programing.
...

References

SHOWING 1-10 OF 32 REFERENCES

PROUST: Knowledge-Based Program Understanding

Bugs are discovered in the process of relating plans to the code; PROUST can give deep explanations of program bugs by relating the buggy code to its underlying intentions.

Uncovering principles of novice programming

The use of video-taped interview studies for understanding how novices use a programming system is described and an example natural language specification is shown and strategies used in that specification are discussed.

Empirical Studies of Programming Knowledge

Two empirical studies attempt to evaluate the hypothesis that expert programmers have and use two types of programming knowledge: programming plans, which are generic program fragments that represent stereotypic action sequences in programming, and rules of programming discourse, which capture the conventions in programming and govern the composition of the plans into programs.

A Knowledge-Based Program Editor

This paper describes an initial implementation of an in terac t ive programming assistant system called the Programmer's Apprent ice (PA). The PA. is designed to be midway be tween an improved…

Children's Mental Models of Recursive Logo Programs

A prevalent but misguided “looping” interpretation of Logo recursion was identified, and this robust mental model persisted even in the face of contradiction between what the program did when executed and the child's predictions for what it would do.

On the Cognitive Effects of Learning Computer Programming: A Critical Look. Technical Report No. 9.

Learning to Program in LISP

The processes by which subjects write LISP functions to meet problem specifications has been modeled in a simulation program called GRAPES (Goal Restricted Production System), which simulates the top-down, depth-first flow of control exhibited by subjects and produces code very similar to subject code.

Analogical Processes in Learning

The role of analogy and procedural representation in learning is examined from several domains, including turtle geometry, kinship terms, and the learning of a computer text editor.

From Utterance to Text: The Bias of Language in Speech and Writing

In this far-ranging essay David Olson attempts to reframe current controversies over several aspects of language, including meaning, comprehension, acquisition, reading, and reasoning. Olson argues…

Cognitive strategies and looping constructs: an empirical study

This work was supported by the Army Research Institute for the Behavioral and Social Sciences and the National Science Foundation under NSF Grant SED-81-12403.