Conference Paper

Some Trouble with Transparency: An Analysis of Student Errors with Object-oriented Python

Authors:
To read the full-text of this research, you can request a copy directly from the authors.

Abstract

We investigated implications of transparent mechanisms in the context of an introductory object-oriented programming course using Python. Here transparent mechanisms are those that reveal how the instance object in Python relates to its instance data. We asked students to write a new method for a provided Python class in an attempt to answer two research questions: 1) to what extent do Python's transparent OO mechanisms lead to student difficulties? and 2) what are common pitfalls in OO programming using Python that instructors should address? Our methodology also presented the correct answer to the students and solicited their comments on their submission. We conducted a content analysis to classify errors in the student submissions. We find that most students had difficulty with the instance (self) object, either by omitting the parameter in the method definition, by failing to use the instance object when referencing attributes of the object, or both. Reference errors in general were more common than other errors, including misplaced returns and indentation errors. These issues may be connected to problems with parameter passing and using dot-notation, which we argue are prerequisites for OO development in Python.

No full-text available

Request Full-text Paper PDF

To read the full-text of this research,
you can request a copy directly from the authors.

... We have already presented a study on reference construction difficulties in a broader programming context [20]. The purpose of that study was to understand the implications of the transparency of the Python programming language when defining objects. ...
... Here, we add to our previous work [20] by drawing upon a larger sample, which allows us to focus on factors that underlie the reference-point errors that we previously observed. As we will see, our analysis provides stronger evidence that students are more likely to omit identifying attributes than descriptive attributes. ...
... As we have already noted, we originally conducted our study to explore the transparent elements of Python's object-oriented mechanisms on student learning [20]. This article describes the same study and method, but its findings draw upon a larger sample of participants. ...
Article
We investigate conditions in which novices make some reference errors when programming. We asked students from introductory programming courses to perform a simple code-writing task that required constructing references to objects and their attributes. By experimentally manipulating the nature of the attributes in the tasks, from identifying attributes (e.g., title or label) to descriptive attributes (e.g., calories or texture), the study revealed the relative frequencies with which students mistakenly omit the name of an identifying attribute while attempting to reference its value. We explain how these reference-point shifts are consistent with the use of metonymy, a form of figurative expression in human communication. Our analysis also reveals how the presentation of examples can affect the construction of the reference in the student’s solution. We discuss plausible accounts of the reference-point errors and how they may inform a model of reference construction. We suggest that reference-point errors may be the result of well-practiced habits of communication rather than misconceptions of the task or what the computer can do.
... We have already presented a study on reference construction di culties in a broader programming context [20]. e purpose of that study was to understand the implications of the transparency of the Python programming language when de ning objects. ...
... Here we add to our previous work [20] by drawing upon a larger sample, which allows us to focus on factors that underlie the reference-point errors that we previously observed. As we will see, our analysis provides stronger evidence that students are more likely to omit identifying a ributes than descriptive a ributes. ...
... As we have already noted, we originally conducted our study to explore the transparent elements of Python's objectoriented mechanisms on student learning [20]. is paper describes the same study and method but its ndings draw upon a larger sample of participants. ...
Preprint
We investigate conditions in which novices make some reference errors when programming. We asked students from introductory programming courses to perform a simple code-writing task that required constructing references to objects and their attributes. By experimentally manipulating the nature of the attributes in the tasks, from identifying attributes (e.g. name or label) to descriptive attributes (e.g. calories, texture), the study revealed the relative frequencies with which students mistakenly omit an identifying attribute name while attempting to reference the attribute value. We explain how these reference-point shifts are consistent with the use of metonymy, a form of figurative expression in human communication. Our analysis also reveals how the presentation of examples can affect the construction of the reference in the student's solution. We discuss plausible accounts of the reference-point errors and how they may inform a model of reference construction. We suggest that reference-point errors may be the result of well practiced habits of communication rather than misconceptions of the task or what the computer can do.
... Esto complicaría la utilización de algunos comandos y estructuras de programación e induciría a cometer errores tanto de sintaxis como de semántica "La implementación de los elementos transparentes de Python's OO provocan dificultades en los estudiantes". [6] "Los errores cometidos por los estudiantes están relacionados con el lenguaje con el que se los introduce al la programación y con la falta de conocimiento de su sintaxis y su semántica". [6] El desconocimiento de semántica y sintaxis tiene consecuencias sobre la capacidad de codificación y de corrección de errores. ...
... [6] "Los errores cometidos por los estudiantes están relacionados con el lenguaje con el que se los introduce al la programación y con la falta de conocimiento de su sintaxis y su semántica". [6] El desconocimiento de semántica y sintaxis tiene consecuencias sobre la capacidad de codificación y de corrección de errores. ...
... [7] "(…) tienen inconvenientes para detectar y/o corregir los errores de sintaxis". [6] La dificultad para detectar y corregir errores está asociada con un conocimiento insuficiente, especialmente de la semántica". [6] Esto se hace evidente en particular en el uso de estructuras de control: "(…) en el uso de los condicionales y en el manejo de los límites de las iteraciones". ...
Conference Paper
Full-text available
Specialized literature shows evidence that students in introductory courses fail to develop basic programming skills, a circumstance that may contribute, to some extent, to the high early dropout rates in computing degree programs. Efforts to improve the introductory teaching of programming appear unsuccessful. It has been suggested that, in practice, teachers are guided by their opinions and personal theories, leaving aside proven teaching strategies. This paper presents a phenomenographic study, which offers a description of what computer science teachers believe they should teach in introductory programming courses. The study was carried out through a survey and interviews with teachers belonging to universities in a populous metropolitan city. Teachers' beliefs about their students, the discipline of programming, and the knowledge to be taught, were identified and organized. The object to be taught was constructed as a collective conception providing the essence of what teachers think they should teach. The components of the object to be taught, as expressed by the interviewed teachers, were contrasted against the curricula of computing degree programs. This triggered the outline of recommendations for educational management in terms of curricula design, content management, teacher training, and teaching practice. Due to the rigorous method followed in this study, its replication in different regions and with larger samples is easily feasible and highly recommended.
... Introducing all these constructs "from the first day" [16], as the library's authors suggest, may be feasible in some contexts and under some definition of what it means to introduce a construct. We argue, however, that this approach is incompatible with the goal of learners understanding the concepts in the code they write [37]. In most circumstances, students will need to accept parts of code as 'something you need to write' with the promise that 'one day you will understand. ...
... PyTamaro has been originally implemented in Python to serve the needs of our specific contexts. Despite its complexity (see[26,37,41]), Python is currently a popular introductory language. ...
... In order to make programming more accessible to these students, some educators have turned to visual programming languages like visual logic or to more beginner-friendly languages like Python to simplify programming and make it easier for students to understand [21]. However, while Python may be suitable for introducing students to the basics of computer science, it may not be the best choice for learning higher-level concepts like object-oriented programming [22]- [24]. In order to effectively teach these more advanced concepts, educators may need to use different approaches. ...
Article
Full-text available
span lang="EN-US">Students often feel overwhelmed by object-oriented programming courses. They find it difficult and complex to learn, requiring a high cognitive load to use the concepts in coding. These issues lead to demotivation in learning programming. This research aims to identify and verify factors that contribute to learning object-oriented programming from two perspectives: interviews and surveys. A literature review was conducted to identify these factors, followed by interviews with five experts who have been teaching object-oriented programming for over ten years to confirm them. Based on the interview results, a questionnaire was developed and administered to 31 bachelor students and 19 lecturers with master’s or doctorate degrees in computer science. The responses indicated that the identified factors were acceptable, with scores ranging from 3.74 to 4.65. The outcomes of this study are a set of factors that should be considered in a programming environment to improve the teaching and learning of object-oriented programming and make it more accessible and engaging for students.</span
... The this notation can be seen as a pointer, which is recognized as being among the most difficult concepts that have to do with the execution-time use of memory (Milne and Rowe 2002). Research on student errors with Python has pointed out that reference errors were more common than other types of error (Miller and Settle 2016). In that study, most students had difficulty with the instance (self) object and omitted the parameter in the method definition or failed to use the instance object when referencing attributes of the object. ...
Article
Full-text available
The paper presents research that aims to expose students’ understanding of the this reference in object-oriented programming. The study was conducted with high school students (N = 86) and college engineering students (N = 77). Conceptualization of this reflects an understanding of objects in general and involves aspects of programming variants and programmers’ preferences as well. To examine students’ conceptions, perceptions, and misconceptions we developed a diagnostic tool that uses this in various contexts, such as in constructors, as a visible parameter, for calling an overloaded constructor in class, or while transiting a non-static method using this to a static one. The detailed analysis revealed difficulties, in both groups of participants, in conceptualizing the meaning of this as the current object and in its various uses in the code. The discussion presents students’ conceptions of “what is this”, nine misconceptions that we characterized, and answers to our research questions. The conclusion offers recommendations for teaching and learning processes in light of the results obtained.
... Some researchers have followed up with think-aloud interviews to capture student misconceptions [2,14,16,25,34]. We follow up with a related technique, task-based interviews (TBIs), to clarify and correct the understanding of student conceptions formed through analysis of the surveys. ...
Conference Paper
Understanding student conceptions and identifying student misconceptions is an important precursor to developing high quality pedagogical materials and approaches. We conducted a pencil-and-paper survey consisting of a demographic questionnaire and 21 content-based questions with 106 students at the start of a second semester course for CS majors (i.e., CS2) at a large public U.S. university with a focus on engineering and science. We then selected the questions that appeared to be most problematic for students and several closely related questions and analyzed the student reasoning for each question and across questions with similar concepts. We found that students exhibited misconceptions related to pass by value versus pass by reference semantics, "false sharing" of variables of the same name in different scopes, and believing that global variables may not be accessed from the main function and/or that a global variable may be modified via a local variable of the same name (i.e., in the presence of variable shadowing). Potential explanations for these misconceptions include fragile knowledge, lack of attention to detail, over-attention to newly acquired knowledge, information foraging (abductive reasoning) in the presence of misleading contextual clues, and lack of exposure to the use of global variables beyond the specification of constants.
... We hypothesize that one of the reasons for the bump in the predictive power in weeks three and four is the relative bump in the effort that students need to invest in order to understand the course contents: objects have previously been noted as a challenging topic [4,20,33], and it is meaningful to assume that the predictive models can -to some degree -separate those who struggle with object oriented programming constructs from those who do not. ...
Conference Paper
In this work, we explore students' usage of online learning material as a predictor of academic success. In the context of an introductory programming course, we recorded the amount of time that each element such as a text paragraph or an image was visible on the students' screen. Then, we applied machine learning methods to study to what extent material usage predicts course outcomes. Our results show that the time spent with each paragraph of the online learning material is a moderate predictor of student success even when corrected for student time-on-task, and that the information can be used to identify at-risk students. The predictive performance of the models is dependent on the quantity of data, and the predictions become more accurate as the course progresses. In a broader context, our results indicate that course material usage can be used to predict academic success, and that such data can be collected in-situ with minimal interference to the students' learning process.
... This is true especially in introductory programming courses, where instructors' beliefs about student errors have only a weak correlation with the errors students actually make [3]. Others have therefore attempted to extract information about CS students' misunderstandings from various types of CRQs, such as code explanations [10,15] or code submissions [7,9,12,14], programming process byproducts such as error logs [4,6], and univalent CRQs as in our work. Univalent CRQs are particularly appealing: like other CRQs, they can reveal useful information about student difficulties without requiring creation of distractors in advance, but unlike other CRQs, they can be easily machine-graded. ...
Conference Paper
Constructed-response, code-tracing questions ("What would Python print?") are good formative assessments. Unlike selected-response questions simply marked correct or incorrect, a constructed wrong answer can provide information on a student's particular difficulty. However, constructed-response questions are resource-intensive to grade manually, and machine grading yields only correct/incorrect information. We analyzed incorrect constructed responses from code-tracing questions in an introductory computer science course to investigate whether a small subsample of such responses could provide enough information to make inspecting the subsample worth the effort, and if so, how best to choose this subsample. In addition, we sought to understand what insights into student difficulties could be gained from such an analysis. We found that ~5% of the most frequently given wrong answers cover ~60% of the wrong constructed responses. Inspecting these wrong answers, we found similar misconceptions as those in prior work, additional difficulties not identified in prior work regarding language-specific constructs and data structures, and non-misconception "slips" that cause students to get questions wrong, such as syntax errors, sloppy reading/writing. Our methodology is much less time-consuming than full manual inspection, yet yields new and durable insight into student difficulties that can be used for several purposes, including expanding a concept inventory, creating summative assessments, and creating effective distractors for selected-response assessments.
... In this example, the intended referent is the name attribute for the obj object, but the code refers to the whole object in its place. While reference-point errors have yet to be studied extensively in this non-API context, a forthcoming paper (C. S. Miller & Settle, 2016) reveals similar reference-point errors including those consistent with previous findings. ...
Conference Paper
Full-text available
A reference-point error occurs when a programmer writes code that mistakenly refers to one element when the intention is to refer to an element structurally related to it. I review these errors and their relation to the use of metonymy in human communication. Using a working example, I draw upon cog-nitive theories of human communication and problem-solving to explore three accounts of why these reference errors occur in novice programming. The first account involves a deficient mental model, the second assumes a misconception of the notional machine, and the third considers implicit, procedural-ized habits of communication. I conclude with learning objectives for students that address these sources of difficulty.
Conference Paper
Learning programming is a road that is paved with mistakes. Initially, novices are bound to write code with syntactic mistakes, but after a while semantic mistakes take a larger role in the novice programmers' lives. Researchers who wish to understand that road are increasingly using data recorded from students' programming processes. Such data can be used to draw inferences on the typical errors, and on how students approach fixing them. At the same time, if the lens that is used to analyze such data is used only from one angle, the view is likely to be narrow. In this work, we replicate a previous multi-institutional study by Brown et al. [5]. That study used a large scale programming process data repository to analyze mistakes that novices make while learning programming. In our single institution replication of that study, we use data collected from approximately 800 students. We investigate the frequency, time required to fix, and the development of mistakes through the semester. We contrast our findings from our single institution with the multi-institutional study, and show that whilst the data collection tools and the research methodology are the same, the results can differ solely due to how the course is conducted.
Conference Paper
Full-text available
The programming task known as the Rainfall Problem has developed a reputation for being surprisingly difficult for introductory-level (CS1) students. We contribute a survey of studies of the problem as well as a new study of students' solutions collected at three institutions. In all three CS1s, at least about half of the students were able to fully solve the problem and the large majority were at least close. Failure to handle invalid or missing input accounted for most bugs. Our survey and study together suggest that the Rainfall Problem is not necessarily overwhelmingly difficult: Success rates vary and some reasonably good results have been achieved under multiple programming paradigms. We provide a breakdown of confounding factors and suggest improvements and hypotheses for future studies of the Rainfall Problem.
Article
Full-text available
Article
Full-text available
Various aspects of computational thinking, which builds on the power and limits of computing processes, whether they are executed by a human or by a machine, are discussed. Computational methods and models are helping to solve problems, design systems, and understand human behavior, by drawing on concepts fundamental to computer science (CS). Computational thinking (CT) is using abstraction and decomposition when attacking a large complex task or designing a large complex systems. CT is the way of thinking in terms of prevention, protection, and recovery from worst-case scenarios through redundancy, damage containment, and error correction. CT is using heuristic reasoning to discover a solution and using massive amount of data to speed up computation. CT is a futuristic vision to guide computer science educators, researchers, and practitioners to change society's image of the computer science field.
Technical Report
Full-text available
We report a small yet detailed study where we recorded students completing an object-oriented programming exercise in the context of a CS2 course using Python. All students struggled while completing the assignment, most notably experiencing difficulties with parameters and referencing elements with object-dot notation. While previous research has identified these areas as troublesome for novice programmers, our analysis suggests that parameters and reference specifications are particularly critical prerequisites for learning advanced object-oriented concepts with the Python programming language. Given our findings, we recommend extensive practice with parameter passing and object-dot notation before addressing advanced object-oriented concepts in a Python course.
Article
Full-text available
A student's capacity to learn a concept is directly related to how much cognitive load is used to comprehend the material. The central problem identified by Cognitive Load Theory is that learning is impaired when the total amount of processing requirements exceeds the limited capacity of working memory. Instruction can impose three different types of cognitive load on a student's working memory: intrinsic load, extraneous load, and germane load. Since working memory is a fixed size, instructional material should be designed to minimize the extraneous and intrinsic loads in order to increase the amount of memory available for the germane load. This will improve learning. To effectively design instruction to minimize cognitive load we must be able to measure the specific load components for any pedagogical intervention. This paper reports on a study that adapts a previously developed instrument to measure cognitive load. We report on the adaptation of the instrument to a new discipline, introductory computer science, and the results of measuring the cognitive load factors of specific lectures. We discuss the implications for the ability to measure specific cognitive load components and use of the tool in future studies.
Conference Paper
Full-text available
We examine how students work in scenario-based and object-oriented programming (OOP) languages, and qualitatively analyze the use of abstraction through the prism of the differences between the paradigms. The findings indicate that when working in a scenario-based language, programmers think on a higher level of abstraction than when working with OOP languages. This is explained by other findings, which suggest how the declarative, incremental nature of scenario-based programming facilitates separation of con-cerns, and how it supports a kind of programming that al-lows programmers to work with a less detailed mental model of the system they develop. The findings shed light on how declarative approaches can reduce the cognitive load involved in programming, and how scenario-based program-ming might solve some of the difficulties involved in the use of declarative languages. This is applicable to the design of learning materials, and to the design of programming lan-guages and tools.
Article
Full-text available
When learning to program, students often mistakenly refer to an element that is structurally related to the element that they intend to reference. For example, they may indicate the attribute of an object when their intention is to reference the whole object. This paper examines these reference-point errors through the context of metonymy. Metonymy is a rhetorical device where the speaker states a referent that is structurally related to the intended referent. For example, the following sentence states an office bureau but actually refers to a person working at the bureau: The tourist asked the travel bureau for directions to the museum. Drawing upon previous studies, I discuss how student reference errors may be consistent with the use of metonymy. In particular, I hypothesize that students are more likely to reference an identifying element even when a structurally related element is intended. I then present two experiments, which produce results consistent with this analysis. In both experiments, students are more likely to produce reference-point errors that involve identifying attributes than descriptive attributes. Given these results, I explore the possibility that students are relying on habits of communication rather than the mechanistic principles needed for successful programming. Finally I discuss teaching interventions using live examples and how metonymy may be presented to non-computing students as pedagogy for computational thinking.
Conference Paper
Full-text available
In line with institutions across the United States, the Computer Science Department at Swarthmore College has faced the challenge of maintaining a demographic composition of students that matches the student body as a whole. To combat this trend, our department has made a concerted effort to revamp our introductory course sequence to both attract and retain more women and minority students. The focus of this paper is the changes instituted in our Introduction to Computer Science course (i.e., CS1) intended for both majors and non-majors. In addition to changing the content of the course, we introduced a new student mentoring program that is managed by a full-time coordinator and consists of undergraduate students who have recently completed the course. This paper describes these efforts in detail, including the extension of these changes to our CS2 course and the associated costs required to maintain these efforts. We measure the impact of these changes by tracking student enrollment and performance over 13 academic years. We show that, unlike national trends, enrollment from underrepresented groups has increased dramatically over this time period. Additionally, we show that the student mentoring program has increased both performance and retention of students, particularly from underrepresented groups, at statistically significant levels.
Article
Full-text available
This article brings together, summarizes, and comments on several threads of research that have contributed to our understanding of the challenges that novice programmers face when learning about the runtime dynamics of programs and the role of the computer in program execution. More specifically, the review covers the literature on programming misconceptions, the cognitive theory of mental models, constructivist theory of knowledge and learning, phenomenographic research on experiencing programming, and the theory of threshold concepts. These bodies of work are examined in relation to the concept of a “notional machine”—an abstract computer for executing programs of a particular kind. As a whole, the literature points to notional machines as a major challenge in introductory programming education. It is argued that instructors should acknowledge the notional machine as an explicit learning objective and address it in teaching. Teaching within some programming paradigms, such as object-oriented programming, may benefit from using multiple notional machines at different levels of abstraction. Pointers to some promising pedagogical techniques are provided.
Article
Full-text available
This article is a survey of program visualization systems intended for teaching beginners about the runtime behavior of computer programs. Our focus is on generic systems that are capable of illustrating many kinds of programs and behaviors. We inclusively describe such systems from the last three decades and review findings from their empirical evaluations. A comparable review on the topic does not previously exist; ours is intended to serve as a reference for the creators, evaluators, and users of educational program visualization systems. Moreover, we revisit the issue of learner engagement which has been identified as a potentially key factor in the success of educational software visualization and summarize what little is known about engagement in the context of the generic program visualization systems for beginners that we have reviewed; a proposed refinement of the frameworks previously used by computing education researchers to rank types of learner engagement is a side product of this effort. Overall, our review illustrates that program visualization systems for beginners are often short-lived research prototypes that support the user-controlled viewing of program animations; a recent trend is to support more engaging modes of user interaction. The results of evaluations largely support the use of program visualization in introductory programming education, but research to date is insufficient for drawing more nuanced conclusions with respect to learner engagement. On the basis of our review, we identify interesting questions to answer for future research in relation to themes such as engagement, the authenticity of learning tasks, cognitive load, and the integration of program visualization into introductory programming pedagogy.
Article
Full-text available
Yes, and Yes.We are currently undertaking an pirical investigation of "Threshold Concepts" in Computer Science, with input from both instructors and students. We have found good pirical evidence that at least two concepts---Object-oriented programming and pointers--are Threshold Concepts, and that there are potentially many more others.In this paper, we present results gathered using various experimental techniques, and discuss how Threshold Concepts can affect the learning process.
Conference Paper
Full-text available
This paper identifies and describes a number of misconceptions observed in students learning about object technology. It identifies simple, concrete, measures course designers and teachers can take to avoid these misconceptions arising. The context for this work centres on an introductory undergraduate course and a postgraduate course. Both these courses are taught by distance education. These courses both use Smalltalk as an introduction to object technology. More particularly, the undergraduate course uses Smalltalk as a first programming language.Distance education can limit the amount and speed of individual feedback that can be given in the early stages of learning. For this reason, particular attention has been paid to characterizing measures for avoiding elementary misconceptions seen in beginning learners. At the same time we also address some misconceptions observed in postgraduate students. The pedagogical issues discussed are of particular importance when devising an extended series of examples for teaching or assessment, or when designing a visual microworld to be used for teaching purposes.
Conference Paper
Full-text available
There is an ongoing debate regarding the role of object orientation in the introductory programming sequence. While the pendulum swings to and fro between the "objects first" and "back to basics" extremes, there is general agreement that object-oriented programming is central to modern software development and therefore integral to a computer science curriculum. Developing effective approaches to teach these principles raises challenges that have been exacerbated by the use of Java or C++ as the first instructional language. In this paper, we recommend Python as an excellent choice for teaching an object-oriented CS1. Although often viewed as a "scripting" language, Python is a fully object-oriented language with a consistent object model and a rich set of built-in classes. Based upon our experiences, we describe aspects of the language that help support a balanced introduction to object orientation in CS1. We also discuss the downstream effects on our students' transition to Java and C++ in subsequent courses.
Conference Paper
Full-text available
In this paper, we begin by considering object-oriented programming concepts and typical novice misconceptions as identified in the literature. We then present the results of a close examination of student programs, in an objects-first CS1 course, in which we find concrete evidence of students learning these concepts while also displaying some of these misconceptions. This leads to the development of two checklists that educators can use when designing or grading student programs.
Conference Paper
Full-text available
If you change the CS1 language to Python, what is the impact on the rest of the curriculum? In earlier work we examined the impact of changing CS1 from C++ to Python while leaving CS2 in C++. We found that Python-prepared CS1 students fared no differently in CS2 than students whose CS1 course was in C++, even though CS2 was taught in C++ and covered the same topics as in previous years. Was that an anomaly? What happens in the next tier of courses? When our CS1 was first changed to Python there were many students who had taken CS1 in C++ still in the system. The result is that there is a cadre of students with either CS1 in Python or CS1 in C++ moving together through our curriculum. This one-time occurrence is an opportunity to study the students with many variables fixed. Our next tier of courses is a C-based computer organization course, a C++ based object-oriented software design course, and a data structures course. We found that the students who started with Python fared as well as the CS1 C++ students. As before, the best predictor of performance was their college GPA. Python versus C++ CS1 preparation was not a predictor of performance in any course. We conclude again that in our C++ based curriculum changing CS1 to Python had no negative impact on student performance and did not require any significant change in those subsequent courses.
Article
Full-text available
This paper discusses Python and its suitability to CS1, CS2 and other advanced computer science courses. As compared to other computing languages, Python has a simpler and more elegant syntax. It is available at no cost for several platforms and is suitable for both small-scale and large-scale programming. Python also provides support for Graphical User Interfaces and object-oriented programming.
Article
Full-text available
Students' understanding of object-oriented (OO) program execution was studied by asking students to draw a picture of a program state at a specific moment. Students were given minimal instructions on what to include in their drawings in order to see what they considered to be central concepts and relationships in program execution. Three drawing tasks were given at different phases of an elementary OO programming course where two animation tools were used for program visualization. The drawings were analyzed for their overall approaches and their detailed contents. There was a large variability in the overall approaches and the popularity of various approaches changed during the course. The results indicate that students' mental representations of OO concepts and program execution not only grow as new material is covered in teaching, but they also change. The first drawings treat methods as having primarily a static existence; later methods are seen as dynamic invocations that call each other. The role of classes in program execution fluctuates during learning, indicating problems in locating the notion of class with respect to, for example, objects. Two major sources of problems that manifested in many different forms were the relationship between object and method, and the role of the main method with respect to program state. Other problems were caused by overly simplistic understanding of object identification and improper use of application domain knowledge.
Article
Full-text available
this paper, the terms client and application are used to refer to a piece of software that makes use of some lower-level software; i.e. the spreadsheet is a client of the window system.
Conference Paper
The Rainfall problem comprises small tasks that have been used to investigate student performance in introductory programming. We conducted several kinds of analyses to inform our understandings of student performance in CS1 relating to this problem. We analyzed implementation approaches and program errors, as in related studies, and also explored the role of test writing vis-à-vis the most common student error. Finally, using correlation analyses and manual inspection of the exam answers, we studied how well the Rainfall problem served as an exam question. The students' implementation choices reflected their familiarity with particular loop constructs, while the single most common error concerned division by zero (DivZ), as in many previous studies. Although many students wrote unit tests to guard against DivZ, they often failed to implement according to the tests, which could be partly attributed to the pen-and-paper exam format. From the correlation analyses, we concluded that some students had difficulties with knowledge transfer and that their conceptual understandings of program constructs were insufficient, regardless of them being able to produce working code. The results inform CS1 teachers in preparing materials and exams.
Conference Paper
We report a small yet detailed study where we recorded students completing an object-oriented programming exercise in the context of a CS2 course using Python. All students struggled while completing the assignment, most notably experiencing difficulties with parameters and referencing elements with object-dot notation. While previous research has identified these areas as troublesome for novice programmers, our analysis suggests that parameters and reference specifications are particularly critical prerequisites for learning advanced object-oriented concepts with the Python programming language. Given our findings, we recommend extensive practice with parameter passing and object-dot notation before addressing advanced object-oriented concepts in a Python course.
Conference Paper
Yes, and Yes.We are currently undertaking an pirical investigation of "Threshold Concepts" in Computer Science, with input from both instructors and students. We have found good pirical evidence that at least two concepts---Object-oriented programming and pointers--are Threshold Concepts, and that there are potentially many more others.In this paper, we present results gathered using various experimental techniques, and discuss how Threshold Concepts can affect the learning process.
Conference Paper
Article
The Python programming language has been around since its development by Guido van Rossum around 1991. One of the main features of the language is code readability (sometimes described as "executable pseudocode"). Python is an interactive programming language, using dynamic typing. It is also a hybrid language, supporting the imperative, object-oriented and functional programming paradigms. Although used as a scripting language, it is also used for the development of full-scale programs.
Article
The Python programming language has been quickly gaining popularity over the past few years as a language of choice for CS1 courses. Some estimates put the rise in use at forty-percent a year. As far back as 2006 there have been reports of significant improvement in both student and instructor satisfaction by redesigning introductory courses to use the simplicity of Python rather than the complexity of a language like Java.
Article
Constructivist approaches to education advocate situating learning in real-world problems-- but these problems are complex. Providing scaffolding allows learners to deal with a problem's complexity and successfully solve and learn from these kinds of problems. In this paper, we describe a theory of learning-by-doing and suggest several ways that the "doing" can be supported without forgetting the learning. We use the metaphors of black-box and glass-box scaffolding to suggest how scaffolding might be used to support learning and performance. Black-box scaffolding is scaffolding that facilitates student performance. Black-box scaffolding performs a task in place of the student performing that performance goal, usually because learning to perform that goal is determined to be unimportant for the learning goals of the activity. Glass-box scaffolding is scaffolding that facilitates performance and learning. It is important for the student to understand what glass-box scaffolding is providing because we want the student to be able to take on the functions that the glass-box scaffolding is providing. Finally, we illustrate how glass-box and black-box scaffolding have been used in two educational software programs.
Chapter
This article is a brief introduction to some of the issues that teachers of programming may find helpful. It starts by presenting a fairly idiosyncratic view of teaching programming which makes use of mechanistic analogies and points out some of the pitfalls. The article goes on to examine certain errors based on the misapplication of analogies as well as certain interaction errors. The main emphasis is on the notional machine both at the general level of understanding (and misunderstanding) the relationship of the terminal to the computer as such, as well as at the more specific level of understanding assignment. Notation and mistakes that poorly-designed languages can induce novices to commit are discussed.
Article
Considerable evidence indicates that domain specific knowledge in the form of schemas is the primary factor distinguishing experts from novices in problem-solving skill. Evidence that conventional problem-solving activity is not effective in schema acquisition is also accumulating. It is suggested that a major reason for the ineffectiveness of problem solving as a learning device, is that the cognitive processes required by the two activities overlap insufficiently, and that conventional problem solving in the form of means-ends analysis requires a relatively large amount of cognitive processing capacity which is consequently unavailable for schema acquisition. A computational model and experimental evidence provide support for this contention. Theoretical and practical implications are discussed.
Conference Paper
Examples form an integral part of learning to program. In this paper we argue that the role of examples should go beyond merely illustrating concepts or principles and should "sell" concepts to new programmers. We identify four common pitfalls to avoid when designing examples for teaching programming. We show how examples that are too abstract or too complex can be harmful in explaining new concepts to students. We also show how some examples used to illustrate new concepts can undermine previously taught concepts by not applying these concepts consistently. Finally, we show how some examples can do harm by undermining the very concept they are introducing. The aim of this paper is to encourage educators to think critically about examples before using them.
Conference Paper
Abstraction is viewed as a key concept in computer science. It is not only an important concept but also one that is difficult to master. This paper focuses on the problems that novices experience when they first encounter this concept. Three assignments from introductory courses are analyzed, to understand why abstraction is difficult for novices. This analysis leads to a number of guidelines that can be used by instructors to support novices learning abstraction.
Article
There’s a key piece of magic in the engineering of the Internet that you rely on every single day. It happens in the TCP protocol, one of the fundamental building blocks of the Internet.
Article
Alongside the widespread support for adopting object orientation there are reports on difficulties in learning object oriented programming and design. This indicates the need for refining the research on cognitive difficulties in a way that will offer guidelines for better designing respective education. The presented findings of our study relate to general issues of object-oriented design and in particular to the abstraction issue with its various manifestations. Based on students' solutions we extracted a cognitive task analysis taxonomy regarding abstraction and inheritance. We discuss possible implications of our results for the teaching of object orientation and for further needed research.
Conference Paper
'Cognitive dimensions' are features of computer languages considered purely as information structures or notations. They therefore apply to many types of language—interactive or programming, high or low level, procedural or declarative, special purpose or general purpose. They are 'cognitive' dimensions because they control how (or whether) the preferred cognitive strategy for design-like tasks can be adopted: it has repeatedly been shown that users prefer opportunistic planning rather than any fixed strategy such as top-down development. The dimension analysis makes it easier to compare dissimilar interfaces or languages, and also helps to identify the relationship between support tools and programming languages: the support tools make it possible to use opportunistic planning with notations that would otherwise inhibit it.
Article
This paper examines transformational learning experiences of computing students as a way to better understand threshold concepts in computing. From empirical evidence we found that students often describe transformative experiences as learning situations in which they were led to use various kinds of abstraction, for example modularity, data abstraction, inheritance, polymorphism, reuse, design patterns, and complexity. Some students describe an abstract concept as coming first, and then needing to be made concrete though application; others describe transformations in which they learn the advantages of these abstract concepts from their experience of not using them. Abstraction is certainly of central importance in computer science. It appears, however, from our students' descriptions of transformative experiences, that abstraction per se is not a threshold, but that particular concepts in which abstraction is paramount exhibit the characteristics of threshold concepts.
Towards a new model of abstraction in the engineering of software. International Workshop on Reflection and Meta-Level Architecture
  • G Kiczales
G. Kiczales. Towards a new model of abstraction in the engineering of software. International Workshop on Reflection and Meta-Level Architecture, pages 67–76, 1992.
Cognitive dimensions of notations Human-Computer Interaction Specialist Group on People and computers V
  • T R G Green
Avoiding object misconceptions
  • S Holland
  • R Griffiths
  • M Woodman
S. Holland, R. Griffiths, and M. Woodman. Avoiding object misconceptions. SIGCSE Bull., 29(1):131-134, 1997.
Measuring cognitive load in introductory cs: Adaptation of an instrument
  • B B Morrison
  • B Dorn
  • M Guzdial
B. B. Morrison, B. Dorn, and M. Guzdial. Measuring cognitive load in introductory cs: Adaptation of an instrument. In Proceedings of the Tenth Annual Conference on International Computing Education Research, ICER '14, pages 131-138, New York, NY, USA, 2014. ACM.
Concrete examples of abstraction as manifested in students' transformative experiences
  • J E Moström
  • J Boustedt
  • A Eckerdal
  • R Mccartney
  • K Sanders
  • L Thomas
  • C Zander
J. E. Moström, J. Boustedt, A. Eckerdal, R. McCartney, K. Sanders, L. Thomas, and C. Zander. Concrete examples of abstraction as manifested in students' transformative experiences. In Proceedings of the Fourth International Workshop on Computing Education Research, ICER '08, pages 125-136, New York, NY, USA, 2008. ACM.