No full-text available
To read the full-text of this research,
you can request a copy directly from the authors.
A Framework to Assist Instructors Help Novice Programmers to Better Comprehend Source Code ─ A Decoding Perspective
Abstract
The Decoding the Disciplines paradigm posits that each discipline has unique mental operations – often invisible to instructors due to their own expert blind spots. If the nature of these operations is not made explicit to students, they are likely to develop learning bottlenecks that could prevent them from mastering key disciplinary practices – such as the ability to reliably work through the chain of reasoning necessary for efficient source code comprehension (SCC). This study seeks to assist instructors to help novice programmers reliably think and work their way through a long chain of reasoning to efficiently comprehend a piece of source code. We followed a narrative approach where data was collected through decoding interviews with five expert programming instructors. Several SCC strategies were identified, but only the seven key ones were used to devise a step-by-step framework for efficient SCC. Our findings aim to create awareness among instructors regarding the explicit mental operations required for efficient SCC.KeywordsSource code comprehensionexpert programming instructorsdecoding the disciplinesdecoding interviewcomputer science educationbottleneckCS1
ResearchGate has not been able to resolve any citations for this publication.
We present in this paper a summary analysis of log files collected during an experiment designed to test the hypothesis that prompting for free self-explanations leads to better comprehension of computer code examples. Indeed, the results indicate that students who were prompted to self-explain while trying to understand code examples performed significantly better at predicting the correct output of the examples than students who were just prompted to read the code examples and predict their output.
Source code comprehension (SCC) continues to be a challenge to undergraduate CS students. Understanding the mental processes that students follow while comprehending source code can be crucial in helping students to overcome related challenges. The ‘Decoding the Disciplines’ (DtDs) paradigm that is gaining popularity world-wide provides a process to help students to master the mental actions they need to be successful in a specific discipline. In focusing on the first DtDs step of identifying mental obstacles (“bottlenecks”), this paper describes a study aimed at uncovering the major SCC bottlenecks that senior CS students experienced. We followed an integrated methodological approach where data were collected by asking questions, observations, and artefact analysis. Thematic analysis of the collected data revealed a series of SCC difficulties specifically related to arrays, programming logic, and control structures. The identified difficulties, including findings from the literature as well as our own teaching experiences, were used to compile a usable list of SCC bottlenecks. By focusing on senior students (instead of first-year students), the identified SCC bottlenecks point to learning difficulties that need to be addressed in introductory CS courses.
We propose and evaluate a lightweight strategy for tracing code that can be efficiently taught to novice programmers, building off of recent findings on "sketching" when tracing. This strategy helps novices apply the syntactic and semantic knowledge they are learning by encouraging line-by-line tracing and providing an external representation of memory for them to update. To evaluate the effect of teaching this strategy, we conducted a block-randomized experiment with 24 novices enrolled in a university-level CS1 course. We spent only 5-10 minutes introducing the strategy to the experimental condition. We then asked both conditions to think-aloud as they predicted the output of short programs. Students using this strategy scored on average 15% higher than students in the control group for the tracing problems used the study (p
We present an empirical study investigating the effect of syntax highlighting on program comprehension and its interaction with programming experience. Quantitative data was captured from 10 human subjects using an eye tracker during a controlled, randomised, within-subjects study. We observe that syntax highlighting significantly improves task completion time, and that this effect becomes weaker with an increase in programming experience.
This study (N = 48) examined the relationship between preservice secondary teachers’ subject-matter expertise in mathematics and their judgments of students’ algebra problem-solving difficulty. As predicted by the “expert blind spot” hypothesis, participants with more advanced mathematics education, regardless of their program affiliation or teaching plans, were more likely to view symbolic reasoning and mastery of equations as a necessary prerequisite for word equations and story problem solving. This view is in contrast with students’ actual performance patterns. An examination across several subject areas, including mathematics, science, and language arts, suggests a common pattern. This article considers how teachers’ developmental views may influence classroom practice and professional development, and calls into question policies that seek to streamline the licensure process of new teachers on the basis of their subject-matter expertise.
Thematic analysis is a poorly demarcated, rarely acknowledged, yet widely used qualitative analytic method within psychology. In this paper, we argue that it offers an accessible and theoretically flexible approach to analysing qualitative data. We outline what thematic analysis is, locating it in relation to other qualitative analytic methods that search for themes or patterns, and in relation to different epistemological and ontological positions. We then provide clear guidelines to those wanting to start thematic analysis, or conduct it in a more deliberate and rigorous way, and consider potential pitfalls in conducting thematic analysis. Finally, we outline the disadvantages and advantages of thematic analysis. We conclude by advocating thematic analysis as a useful and flexible method for qualitative research in and beyond psychology.
This poster explores some of the issues associated with teaching computer science to students with dyslexia. Issues associated with both student learning generally and computer science specifically are considered. The accessibility of teaching materials made available through virtual learning environments (VLEs) is addressed. Twelve resulting guidelines particularly relevant to students with dyslexia are outlined. More specifically to computer science, the issues associated with programming are explored through the development of a mapping of the features of dyslexia to the tasks involved in writing a computer program. Preliminary evidence, from both the wider dyslexia community with computer programming experience and some early interview results, are presented to both support the mapping and draw out other important issues.This poster describes results generated from a LTSN-ICS Development Fund project, entitled 'Impact of Learning Disability on the Study of Computing'. This project seeks to investigate the impact of learning disabilities on students who are following a course of study in the computing curriculum. It looked at how best to deliver materials through the University's Virtual Learning Environment (VLE) and then focused on issues surrounding students with dyslexia and computer programming.The introduction of the Special Educational Needs and Disability Act [1] and the Disability Discrimination Act part IV [2] provides an opportunity and incentive to review teaching and learning methods and see how the needs of the students with special needs are addressed. In the case of a computing department, this should include general aspects, for example accessible provision of e-resources, and also domain specific aspects, for example programming. This poster looks at both of these aspects.Leeds Metropolitan University (Leeds Met.) is a large (37,000 students) university of applied learning, with a policy of widening access to higher education. The School of Computing has approximately 1,500 students enrolled on a variety of HND and degree programmes, of these on average 20 are registered as dyslexic at any given time. This is in line with the occurrence of dyslexia across the University as a whole and the general higher education student population, 1.2 per cent to 1.5 per cent [3]. There is, then, a substantial and persistent number of individuals that require support within the school.The poster begins by outlining the sources of standards and guidelines relating to the provision of accessible Web based and e-learning materials and then highlights those considered particularly pertinent to students with dyslexia. It then focuses in on specific issues associated with computer programming and dyslexia. In order to do this, first the features of dyslexia, both negative and positive, are outlined. A model of the processes involved in computer programming is then proposed. This allows an interaction matrix of the features of dyslexia and the process stages of computer programming to be developed. Preliminary evidence is then presented from correspondents of a Dyslexia e-mail forum, which supports the interaction matrix and raises additional issues. The results of an interview with a Computer Science student with dyslexia are also presented.This poster is based on earlier work [4,5].
Teaching effective problem-solving skills in the context of teaching programming necessitates a revised curriculum for introductory computer programming courses.
It is widely accepted that software maintenance absorbs a significant amount of the effort expended in software development. Proper training of both university students and professional developers is required in order to improve software maintenance. Understanding cognitive difficulties the students have while maintaining object-oriented systems is a prerequisite for improving their university education and preparing them for jobs in industry. The goal of the experiment reported in this paper is to explore the difficulties of students who maintain an unfamiliar object-oriented system. The subjects were 34 students in their third year of study in computer science. They used a professional Java tool to perform several maintenance tasks on a medium-size Java application system in a seven-hour long experiment. The major difficulties were related to understanding program logic, algorithms, finding change impacts, and inheritance of the functionality. Based on these results we suggest teaching the basics of impact analysis and introducing examples of modifying larger object-oriented programs in courses on object-oriented programming.
Using the Decoding the Disciplines model, faculty who are deeply ingrained in their disciplinary research answer a series of questions to understand how students think and learn in their field. The cross-disciplinary nature of the process clarifies the thinking for each discipline.
We suggest that expert programmers have and use two types of programming knowledge: 1) programming plans, which are generic program fragments that represent stereotypic action sequences in programming, and 2) rules of programming discourse, which capture the conventions in programming and govern the composition of the plans into programs. We report here on two empirical studies that attempt to evaluate the above hypothesis. Results from these studies do in fact support our claim.
As mentioned before, pattern recognition does not appear as a new problem. A lot of studies have been performed on this scientific field and a lot of works are currently developed. Pattern recognition is a wide topic in machine learning. It aims to classify a pattern into one of a number of classes. It appears in various fields like psychology, agriculture, computer vision, robotics , biometrics... With technological improvements and growing performances of computer science, its application field has no real limitation. In this context, a challenge consists of finding some suitable description features since commonly, the pattern to be classified must be represented by a set of features characterising it. These features must have discriminative properties: efficient features must be affined transformations insensitive. They must be robust against noise and against elastic deformations due, e.g., to movement in pictures. Through the application example based on our MSGPR method, we have illustrated various aspects of a PRS. With this example, we have illustrated the description task that enabled us to extract multi-scale features from the generated IPM function. By using theses features in the classification task, we identified the letters from a car number plate so that we automatically retrieved the license number of a vehicle.
This paper formally distinguishes between two variants of top-down
comprehension (as originally described by Brooks (1983) and Soloway
(1984)). The first is inference-based comprehension, where the
programmer derives meaning from cliched implementations in the code. The
second is expectation-based comprehension, where the programmer has
pre-generated expectations of the code's meaning. The paper describes
the distinguishing features of the two variants, and uses these
characteristics as the basis for an empirical study. This study
establishes their existence, and identifies their relationship with
programmers' domain and coding standards familiarity
This descriptive study discusses two conceptual difficulties encountered by students in introductory programming courses regardless of the chosen language or pedagogical approach (e.g. objects, classes or fundamentals first). Firstly, students tend to learn programming by memorizing correct code examples instead of acquiring the programming thought process. Secondly, they tend to read code by "flying" over it at a comfortable altitude while thinking to its assumed intent. While relaxing, this practice fails to train students to develop the rigor to catch bugs in others' or their own code. Both trends result in an almost complete loss of intentionality in the programming activity; un-innovative code is generated by analogy with (or cut and paste from) existing solutions and is then almost randomly modified until "it fits" the minimal tests requirements without real analysis of its flaws. We review and evaluate pedagogical strategies which can be leveraged by instructors to address the above mentioned issues. Namely, we discuss the benefits of various forms of "Live coding" and test-driven pair programming active learning practices.
In this paper, we explore the question of whether program understanding tools enhance or change the way that programmers understand programs. The strategies that programmers use to comprehend programs vary widely. Program understanding tools should enhance or ease the programmer 's preferred strategies, rather than impose a fixed strategy that may not always be suitable. We present observations from a user study that compares three tools for browsing program source code and exploring software structures. In this study, 30 participants used these tools to solve several high-level program understanding tasks. These tasks required a broad range of comprehension strategies. We describe how these tools supported or hindered the diverse comprehension strategies used. Keywords: Fisheye views, program comprehension, program understanding tools, reverse engineering, software maintenance, software visualization, user study. 1 Introduction Program understanding tools should help programmers to...
It has been argued elsewhere that in order to make gains in software productivity and quality, it is necessary to somehow make explicit the conceptual representations that link the formal documents, such as the code, the design, the requirements. These intermediate representations contain information that is typically not included in those formal documents. The authors address the questions of what these important, and currently implicit, conceptual representations are, and once made explicit, how they can be used. They argue that the ecological design approach can lead directly to insights concerning the identification and use of these representations. As evidence for this position, they highlight two major studies of software professionals that they feel have led to a better understanding of the role of such conceptual representations.
How do beginning students approach problems which require them to read and understand code? We report on a Grounded Theory-based analysis of student transcripts from 12 institutions where students were asked to "think aloud" when solving such problems. We identify 19 strategies used by students. Primary results are that all students employ a range of strategies, there were (in total) many different strategies that were applied, students use multiple strategies on each individual problem, students applied different strategies to different types of questions, and students often applied strategies poorly. We show that strategies conform with existing education theories including Bloom's Taxonomy and the Approaches to Study Inventory. Additionally, we discuss emergent theories developed through a card sort process.
Through “decoding”, implicit expert knowledge can be turned into explicit mental tasks, and made available to students. This book presents a seven-step process for uncovering bottlenecks and determining the most effective strategies to enable students to surmount them.
Teaching and learning in a college setting has never been more challenging. How can instructors reach out to their students and fully engage them in the conversation? Applicable to multiple disciplines, the Decoding the Disciplines Paradigm offers a radically new model for helping students respond to the challenges of college and provides a framework for understanding why students find academic life so arduous. Teachers can help their pupils overcome obstacles by identifying bottlenecks to learning and systematically exploring the steps needed to overcome these obstacles. Often, experts find it difficult to define the mental operations necessary to master their discipline because they have become so automatic that they are invisible. However, once these mental operations have been made explicit, the teacher can model them for students, create opportunities for practice and feedback, manage additional emotional obstacles, assess results, and share what has been learned with others.
There is a common intuition among those in computer science education that programming encourages the development of good problem-solving skills. The term “problem solving” has a broader and deeper meaning than what is implied by its educational association with mathematics. This is an exciting idea, especially when one considers how the concept of problem solving has been synonymous with human endeavors of the best possible kind, with the mastery of the physical, social, and intellectual worlds we live in. Computer environments make it possible for students to experience some of the deeper ideas that underlie a correct understanding of what human problem solving entails. Students learn best in settings where they can move from the empirical to the theoretical and back again freely. This coincides with the way real problem-solvers function. Low-cost microcomputers make it possible to incorporate these ideas into mathematics curricula and also into new courses in computer science and computer literacy.
In illustrating examples of software use in different contexts through three distinct case-study
examples we hope to paint a picture of some common aspects of analysis in the context of
software tools so that you can draw out ideas about what might be useful in your own particular
research. We understand that your choice of software may be limited within the constraints of
local provision, but our purpose is to enable ambitious yet secure use of any CAQDAS package and
the moulding of its functions to your needs, while also adding to your awareness of what other
tools work well for particular contexts. We believe that a broad understanding of software packages
other than the one you happen to be using will open up your thinking about your own work.
Above all, we see ourselves as ‘facilitators’ rather than ‘instructors’. The way we teach is
informed by the belief that you are the expert about your project and your needs. We can show
you tools, illustrate their benefits and caution against their potential limitations. We can make
suggestions about their suitability (or not) for different approaches to data analysis. But you need
to decide whether to use software at all – and if so, then which package. If you decide not to use
software then you need to be able to justify this. If you decide to use software, you need to design
a strategy for doing so within the parameters of your broader methodological context, specific
analytic needs and any practical constraints within which you are working.
We hope this book will provide you with the context you need to frame your thinking about
software, to give you insights into the way particular tools might be useful at various moments,
and to heighten your reflection about the relationship between technology and methodology.
More than anything else, we hope this book will inspire you to explore your data to greater
depths, to experiment with software tools and to develop systematic and creative ways of conducting
robust and well-evidenced analysis.
The automatic evaluation of computer programs is a nascent area of research with a potential for large-scale impact. Extant program assessment systems score mostly based on the number of test-cases passed, providing no insight into the competency of the programmer. In this paper, we present a system to grade computer programs automatically. In addition to grading a program on its programming practices and complexity, the key kernel of the system is a machine-learning based algorithm which determines closeness of the logic of the given program to a correct program. This algorithm uses a set of highly-informative features, derived from the abstract representations of a given program, that capture the program's functionality. These features are then used to learn a model to grade the programs, which are built against evaluations done by experts. We show that the regression models provide much better grading than the ubiquitous test-case-pass based grading and rivals the grading accuracy of other open-response problems such as essay grading . We also show that our novel features add significant value over and above basic keyword/expression count features. In addition to this, we propose a novel way of posing computer-program grading as a one-class modeling problem and report encouraging preliminary results. We show the value of the system through a case study in a real-world industrial deployment. To the best of the authors' knowledge, this is the first time a system using machine learning has been developed and used for grading programs. The work is timely with regard to the recent boom in Massively Online Open Courseware (MOOCs), which promises to produce a significant amount of hand-graded digitized data.
Program tracing is an important skill for programming learning, but novice programmers' tracing abilities are poor. This study designs a system to enable students to exercise program tracing and make students' program tracing processes visible to help teachers indicate students' errors in tracing execution flow, variable values, or I/O display. © 2010 Wiley Periodicals, Inc. Comput Appl Eng Educ 21: 432–438, 2013
Students in introductory programming courses struggle with building the mental models that correctly describe concepts such as variables, subroutine calls, and dynamic memory usage. This struggle leads to lowered student learning outcomes and, it has been argued, the high failure and dropout rates commonly seen in these courses. We will show that accurately modeling what is occurring in memory and requiring students to trace code using this model improves student performance and increases retention. This paper presents the results of an experiment in which introductory programming courses were organized around code tracing. We present program memory traces, a new approach for tracing code that models what occurs in memory as a program executes. We use these traces to drive our lectures and to act as key pieces of our active learning activities. We report the results of student surveys showing that instructor tracing was rated as the most valuable piece of the course and students' overwhelming agreement on the importance of the tracing activities for their learning. Finally, we demonstrate that trace-based teaching led to statistically significant improvements student grades, decreased drop and failure rates, and an improvement in students' programming abilities.
While analysing students' marks in some comparable code-reading and code-writing questions on a beginners' programming exam, we observed that the weaker students appeared to be able to write code with markedly more success than they could read it. Examination of a second data set from a different institution failed to confirm the observation, and appropriate statistical analysis failed to find any evidence for the conclusion. We speculate on the reasons for the lack of a firm finding, and consider what we might need to do next in order to more thoroughly explore the possibility of a relationship between the code-reading and code-writing abilities of novice programming students.
On the basis of metamemory assessment research and theories of discourse comprehension, the Metacomprehension Scale (MCS) was designed to assess multiple dimensions of metacomprehension. In a sample of younger (n = 30) and older (n = 30) adults, we examined age differences in self‐assessed components of metacomprehension and the relation of the MCS to comprehension performance and general verbal ability. Younger adults reported greater use of strategies to resolve comprehension failures (i.e., regulation) and placed higher value on good comprehension skills than older adults. The MCS revealed a substantial amount of variance in comprehension performance and verbal ability, with the regulation dimension of metacomprehension being a reliable and consistent predictor of performance. The results provided support for domain‐specific assessment of metacognition and for the critical role of regulation in comprehension performance.
Program comprehension plays a crucial role during the software-development life cycle: Maintenance programmers spend most of their time with comprehending source code, and maintenance is the main cost factor in software development.
Thus, if we can improve program comprehension, we can save considerable amount of
time and cost. To improve program comprehension, we have to measure it first. However, program comprehension is a complex, internal cognitive process that we cannot
observe directly. Typically, we need to conduct controlled experiments to soundly
measure program comprehension. However, empirical research is applied only reluctantly in software engineering. To close this gap, we set out to support researchers in
planning and conducting experiments regarding program comprehension. We report
our experience with experiments that we conducted and present the resulting framework to support researchers in planning and conducting experiments. Additionally, we
discuss the role of teaching for the empirical researchers of tomorrow
in this chapter we present our current view on the knowledge and processing strategies programmers employ in attempting to comprehend computer programs
we first present an experiment that supports our claims as to the composition of an expert programmer's knowledge base
next, we propose processing strategies that may be at work in comprehending programs
as support for these latter mechanisms, we draw on our experience in building a computer program that attempts to understand computer programs written by novices (PsycINFO Database Record (c) 2012 APA, all rights reserved)
This chapter situates Guba and Lincoln's chapter within the broad philosophical debate about the justifiability of interpretations.
The emergence of a new paradigm of inquiry (naturalistic) has, unsurprisingly enough, led to a demand for rigorous criteria that meet traditional standards of inquiry. Two sets are suggested, one of which, the “trustworthiness” criteria, parallels conventional criteria, while the second, “ authenticity” criteria, is implied directly by new paradigm assumptions.
This paper describes an investigation into the nature of the academic problems that face novice programming students. These learners are required to demonstrate competencies in high-level abstract principles of programming and logic, such as program design and OOP principles, which are conceptually difficult. During the programming task learners receive relatively high levels of feedback on low level issues, such as syntax rules, but tend to receive low levels of feedback on conceptually more difficult issues. This problem tends to be exacerbated by the trend of learners to study independently, outside the classroom or in online modes, which further reduces the options available for quality feedback on high-level issues. This paper analyses the results of a survey given to students enrolled in an introductory programming unit across three campuses at Monash University in 2007. The survey focused on student perceptions of the relative difficulty in understanding and implementing both low level-programming concepts, such as syntax and variables, and high-level concepts, such as OOP principles and efficient program design. An analysis of the approximately 150 responses has indicated that a significant percentage of students experienced difficulties in high-level concepts. Also while many students may indicate an understanding of the principles of many high level concepts more students reported experiencing difficulty in implementing such concepts. This indicates that many students may achieve a level of understanding allowing near transfer of domain knowledge but fail to reach a level of understanding that enables far transfer.
Understanding how a program is constructed and how it functions are significant components of the task of maintaining or enhancing a computer program. We have analyzed vidoetaped protocols of experienced programmers as they enhanced a personnel data base program. Our analysis suggests that there are two strategies for program understanding, the systematic strategy and the as-needed strategy. The programmer using the systematic strategy traces data flow through the program in order to understand global program behavior. The programmer using the as-needed strategy focuses on local program behavior in order to localize study of the program. Our empirical data show that there is a strong relationship between using a systematic approach to acquire knowledge about the program and modifying the program successfully. Programmers who used the systematic approach to study the program constructed successful modifications; programmers who used the as-needed approach failed to construct successful modifications. Programmers who used the systematic strategy gathered knowledge about the causal interactions of the program's functional components. Programmers who used the as-needed strategy did not gather such causal knowledge and therefore failed to detect interactions among components of the program.
The present study investigated the effects of experience and comprehension on reading time, recall and recognition memory for computer programs. Twenty computer science students, who varied along the dimension of experience, were presented with two lists of PL/I computer programming statements. List 1 was a meaningful program and contained programming constructs which all the programmers had used. List 2 was a random list of PL/I statements. Each list was presented four times. More-experienced programmers read the meaningful program faster than less-experienced programmers. Comprehension was positively correlated with recall of the meaningful program. Results from recognition tests revealed a strong positive correlation between comprehension and recognition of meaningful units. Neither experience nor comprehension were related to performance with random information. These results are discussed in terms of elaboration, the concept of knowledge compilation (Anderson, 1982) and the contribution of experience and comprehension to performance.
This paper presents five abstract characteristics of the mental representation of computer programs: hierarchical structure, explicit mapping of code to goals, foundation on recognition of recurring patterns, connection of knowledge, and grounding in the program text. An experiment is reported in which expert and novice programmers studied a Pascal program for comprehension and then answered a series of questions about it, designed to show these characteristics if they existed in the mental representations formed. Evidence for all of the abstract characteristics was found in the mental representations of expert programmers. Novices' representations generally lacked the characteristics, but there was evidence that they had the beginnings, although poorly developed, of such characteristics.
It is suggested that expert programmers have and use two types of programming knowledge: 1) programming plans, which are generic program fragments that represent stereotypic action sequences in programming, and 2) rules of programming discourse, which capture the conventions in programming and govern the composition of the plans into programs. Two empirical studies that attempt to evaluate the above hypothesis are reported. Results from these studies do in fact support the claim.
Thesis (Ph. D.)--Harvard University, 1983. Includes bibliographical references (leaves 113-117).