Learning and teaching programming: A review and discussion
---
paper_title: Programming pedagogy—a psychological overview

paper_content:

Can we turn novices into experts in a four year undergraduate program? If so, how? If not, what is the best we can do? While every teacher has his/her own opinion on these questions, psychological studies over the last twenty years have started to furnish scientific answers. Unfortunately, little of these results have been incorporated into curricula or textbooks. This report is a brief overview of some of the more important results concerning computer programming and how they can affect course design.
---
paper_title: Zero Defect Software: Cleanroom Engineering

paper_content:

Publisher Summary Software is either correct or incorrect in design to a specification, in contrast with hardware that is reliable to a certain level in performing to a correct design. Certifying the correctness of such software requires two conditions—namely, statistical testing with inputs characteristic of actual usage, and no failures in the testing. Cleanroom Engineering introduces new levels of practical precision for achieving correct software, using three engineering teams—namely, specification engineers, development engineers, and certification engineers. Software can be developed and certified as correct under statistical quality control (SQC) to well-formed specifications of user requirements. The chapter discusses history and application of SQC to software development. Two major properties of Cleanroom Engineering are: no debugging by the developers before the software goes to independent testers and statistical testing taking into account both the usage and the criticalness of software parts. Cleanroom software engineering achieves statistical quality control over software development by strictly separating the design process from the testing process in a pipeline of incremental software development. There are three major engineering activities in this process are software specification, software development, and software certification. The chapter elaborates the statistical quality control in software engineering. Markov chain techniques for software certification are discussed. The cleanroom engineering methods are outlined. Box Structured Software System Design is discussed.
---
paper_title: Software Metrics: An Analysis and Evaluation

paper_content:

Software metrics is a new area of computer science designed to enable programmers and other practitioners to assign quantitative indexes of merit to software. In this volume, "software" is defined broadly as a generic for all the stages of tailoring a computer system to solve a problem. "Software Metrics" is the first book to survey this new area, measuring its present extent, describing its characteristic features, and indicating directions of potential expansion.The aim of the articles included in the book is to provide precise, quantified answers to such questions as: What are the memory requirements of the software? The speed requirements? What is the cost of production? The likely time schedule of production? When will it have to be replaced? What manpower loading should be used? how close to its limits is the system expected to run? What levels of satisfactory testing are sufficient? How well does the testing environment approximate the execution environment? What is the enhancement cost? To what extent has the problem--of the technology--moved beyond the program? Would it cost less to rebuild the system than to maintain and enhance it?"In software, evolutionary complexity is probably more important than the classical time and space measures with which computer science has been concerned so far," the editors note in their introductory overview. This overview gauges the range of the book's fifteen contributions by the major developers of software metrics.
---
paper_title: Software Engineering Economics

paper_content:

This paper summarizes the current state of the art and recent trends in software engineering economics. It provides an overview of economic analysis techniques and their applicability to software engineering and management. It surveys the field of software cost estimation, including the major estimation techniques available, the state of the art in algorithmic cost models, and the outstanding research issues in software cost estimation.
---
paper_title: Studying the Novice Programmer

paper_content:

Parallel to the growth of computer usage in society is the growth of programming instruction in schools. This informative volume unites a wide range of perspectives on the study of novice programmers that will not only inform readers of empirical findings, but will also provide insights into how novices reason and solve problems within complex domains. The large variety of methodologies found in these studies helps to improve programming instruction and makes this an invaluable reference for researchers planning studies of their own. Topics discussed include historical perspectives, transfer, learning, bugs, and programming environments.
---
paper_title: Expert Software Design Strategies

paper_content:

Early studies on programming have neglected design strategies actually implemented by expert programmers. Recent studies observing designers in real(istic) situations show these strategies to be deviating from the top-down and breadth-first prescriptive model, and leading to an opportunistically organized design activity. The main components of these strategies are presented here. Consequences are drawn from the results for the specification of design support tools, as well as for programmers' training.
---
paper_title: Knowledge exploited by experts during software system design

paper_content:

High-level software design is characterized by incompletely specified requirements, no predetermined solution path, and by the integration of multiple domains of knowledge at various levels of abstraction. The application of data-driven knowledge rules characterizes expertise. A verbal protocol study describes these domains of knowledge and how experts exploit their rich knowledge during design. It documents how designers heavily rely on problem domain scenario simulations throughout solution development. These simulations trigger the inferences of new requirements and complete the requirement specification. Designers recognize partial solutions at various levels of abstraction in the design decomposition through the application of data-driven rules. Designers also rely heavily on simulations of their design solutions. but these are shallow, that is, limited to one level of abstraction in the solution. The findings also illustrate how designers capitalize on design methods, notations, and specialized software design schemas. Finally, the study describes how designers exploit powerful heuristics and personalized evaluation criteria to constrain the design process and select a satisfactory solution. Studies, such as this one, help map the road to understanding expertise in complex tasks.
---
paper_title: Models and theories of programming strategy

paper_content:

Abstract Much of the literature concerned with understanding the nature of programming skill has focused explicitly upon the declarative aspects of programmers' knowledge. This literature has sought to describe the nature of stereotypical programming knowledge structures and their organization. However, one major limitation of many of these knowledge-based theories is that they often fail to consider the way in which knowledge is used or applied. Another strand of literature is less well represented. This literature deals with the strategic elements of programming skill and is directed towards an analysis of the strategies commonly employed by programmers in the generation and the comprehension of programs. In this paper an attempt is made to unify various analyses of programming strategy. This paper presents a review of the literature in this area, highlighting common themes and concerns, and proposes a model of strategy development which attempts to encompass the central findings of previous research in this area. It is suggested that many studies of programming strategy are descriptive and fail to explain why strategies take the form they do or to explain the typical strategy shifts which are observed during the transitions between different levels of skill. This paper suggests that what is needed is an explanation of programming skill that integrates ideas about knowledge representation with a strategic model, enabling one to make predictions about how changes in knowledge representation might give rise to particular strategies and to the strategy changes associated with developing expertise. This paper concludes by making a number of brief suggestions about the possible nature of this model and its implications for theories of programming expertise.
---
paper_title: Expert Programming Knowledge: A Strategic Approach

paper_content:

This chapter considers an alternative to the ‘programming plan’ view of programming expertise, namely that expert programmers have a much wider repertoire of strategies available to them as they program than do novices. This analysis does not dispute that experts have ‘plan-like’ knowledge, but questions the importance of the knowledge itself versus an understanding of when or how to use that knowledge. This chapter will firstly examine evidence which challenges the completeness of the plan-based theory and then it will look at evidence which reveals explicit strategic differences. As the studies are presented a list of strategies available to experts will be maintained. Although the emphasis of this section of the book is on expert performance, the chapter concludes with a brief look at studies of novices, since the strategic approach includes the assumption that the strategies used by novices are different from those available to experts. From all these studies it will be seen that experts choose strategies in response to factors such as unfamiliar situations, differing task characteristics and different language requirements, whilst many problems for novice programmers stem not only from lack of knowledge, but also from the lack of an adequate strategy for coping with the programming problem. ::: ::: The previous chapter has presented studies of expertise in computer programming that have concentrated on the content and structure of expert knowledge. The dominant concept has been the ‘programming plan’, which has been proposed as the experts' mental representation of programming knowledge, and which has been used in the development of programming tutors and environments for novice programmers. ::: ::: This chapter examines those aspects of expertise that are not easily explained by plan-based theories. It is intended that the strategic approach described in this chapter should be seen as a complementary, rather than alternative, explanation of expertise. As the various studies are described a list of important strategies which programmers may use will be developed. The studies that are to be presented reveal problems with two implications of the plan-based approach: ::: 1 ::: that ‘programming plans’ provide a complete explanation of expert programming behaviour; ::: ::: 2 ::: that a novice can be defined as someone who does not possess this expert knowledge. ::: ::: ::: ::: ::: An important, but often implicit assumption of the plan-based theorists is that the cognitive processes underlying programming are relatively straightforward. Often based on ideas from artificial intelligence, these processes are taken to be general problem-solving skills (cf. SOAR, Laird et al., 1987; ACT*, Anderson, 1983), which a novice programmer also possesses. The learning of computer programming is the acquisition of the appropriate knowledge structures for the problem-solving skills to use. These knowledge structures may then be labelled ‘plans’ (see Chapter 3.1 for more details), though other possibilities exist. The critical feature is that expertise is seen as the acquisition of knowledge. ::: ::: The alternative position is that expertise in programming may involve a variety of cognitive processes which, coupled with changes in knowledge, can give rise to a choice of different methods for solving any particular programming problem. These different methods can be termed strategies. The critical feature of the strategy argument is that observations of novice-expert differences can be caused by either knowledge differences, processing differences, or both. ::: ::: Any assessment of this argument has two important strands. Firstly some evidence questioning the plan-based theory will be presented (evidence for the theory has been covered by the previous chapter) and then evidence of strategic differences will be described. For these reasons it is important that the evidence for alternative aspects to expertise beyond the plan-based theories is carefully considered
---
paper_title: Programming pedagogy—a psychological overview

paper_content:

Can we turn novices into experts in a four year undergraduate program? If so, how? If not, what is the best we can do? While every teacher has his/her own opinion on these questions, psychological studies over the last twenty years have started to furnish scientific answers. Unfortunately, little of these results have been incorporated into curricula or textbooks. This report is a brief overview of some of the more important results concerning computer programming and how they can affect course design.
---
paper_title: Studying the Novice Programmer

paper_content:

Parallel to the growth of computer usage in society is the growth of programming instruction in schools. This informative volume unites a wide range of perspectives on the study of novice programmers that will not only inform readers of empirical findings, but will also provide insights into how novices reason and solve problems within complex domains. The large variety of methodologies found in these studies helps to improve programming instruction and makes this an invaluable reference for researchers planning studies of their own. Topics discussed include historical perspectives, transfer, learning, bugs, and programming environments.
---
paper_title: Acquisition of Programming Knowledge and Skills

paper_content:

Acquiring and developing knowledge about programming is a highly complex process. This chapter presents a framework for the analysis of programming. It serves as a backdrop for a discussion of findings on learning. Studies in the field and pedagogical work both indicate that the processing dimension involved in programming acquisition is mastered best. The representation dimension related to data structuring and problem modelling is the ‘poor relation’ of programming tasks. This reflects the current emphasis on the computational programming paradigm, linked to dynamic mental models.
---
paper_title: Comprehension and recall of miniature programs

paper_content:

Abstract Differences in the comprehensibility of programming notations can arise because their syntax can make them cognitively unwieldy in a generalized way ( Mayer, 1976 ), because all notations are translated into the same “mental language“ but some are easier to translate than others (Shneiderman & Mayer, 1979 ), or because the mental operations demanded by certain tasks are harder in some notations than in others ( Green, 1977 ). The first two hypotheses predict that the relative comprehensibility of two notations will be consistent across all tasks, whereas the mental operations hypothesis suggests that particular notations may be best suited to particular tasks. The present experiment used four notations and 40 non-programmers to test these hypotheses. Two of the notations were procedural and two were declarative, and one of each pair contained cues to declarative or procedural information, respectively. Different types of comprehension question were used (“sequential“ and “circumstantial“); a mental operations analysis predicted that procedural languages would be “matched” with sequential questions, and declarative languages with circumstantial questions. Questions were answered first from the printed text, and then from recall. Subjects performed best on “matched pairs” of tasks and languages. Perceptually-based cues improved the performance on “unmatched pairs” better than non-perceptual cues when answering from the text, and both types of cues improved performance on “unmatched pairs” in the recall stage. These results support the mental operations explanation. They also show that the mental representation of a program preserves some features of the original notation; a comprehended program is not stored in a uniform “mental language”.
---
paper_title: Models and theories of programming strategy

paper_content:

Abstract Much of the literature concerned with understanding the nature of programming skill has focused explicitly upon the declarative aspects of programmers' knowledge. This literature has sought to describe the nature of stereotypical programming knowledge structures and their organization. However, one major limitation of many of these knowledge-based theories is that they often fail to consider the way in which knowledge is used or applied. Another strand of literature is less well represented. This literature deals with the strategic elements of programming skill and is directed towards an analysis of the strategies commonly employed by programmers in the generation and the comprehension of programs. In this paper an attempt is made to unify various analyses of programming strategy. This paper presents a review of the literature in this area, highlighting common themes and concerns, and proposes a model of strategy development which attempts to encompass the central findings of previous research in this area. It is suggested that many studies of programming strategy are descriptive and fail to explain why strategies take the form they do or to explain the typical strategy shifts which are observed during the transitions between different levels of skill. This paper suggests that what is needed is an explanation of programming skill that integrates ideas about knowledge representation with a strategic model, enabling one to make predictions about how changes in knowledge representation might give rise to particular strategies and to the strategy changes associated with developing expertise. This paper concludes by making a number of brief suggestions about the possible nature of this model and its implications for theories of programming expertise.
---
paper_title: Variability in program design: the interaction of process with knowledge

paper_content:

A model of program design is proposed to explain program variability, and is experimentally supported. Variability is shown to be the result of different decisions made by programmers during three stages in the design process. In the first stage, a solution is created based on a particular design approach. In the second stage, actions in the solution are organized by features they share. The actions may then be merged together to define a more concise solution in program code, the third stage of design. Different programs will be created depending, on the approach taken to design the features selected to group actions in a solution, and the features used to merge actions to form program code. Each of the variants observed in the study was traced to the use of a specific piece of information by a programmer at one of the three stages of program design. Many different programs were created as the process of design interacted with the knowledge of the programmer.
---
paper_title: Cognitive Psychology and Its Implications

paper_content:

A fully updated, systematic introduction to the theoretical and experimental foundations of higher mental processes. Avoiding technical jargon, John R. Anderson constructs a coherent picture of human cognition, relating neural functions to mental processes, perception to abstraction, representation to meaning, knowledge to skill, language to thought, and adult cognition to child development.
---
paper_title: Strategies of Discourse Comprehension

paper_content:

rhetorical schemata to be discussed in what follows. Finally, schemata are descriptions, not definitions. The ‘bus’ schema contains information that is nor-
---
paper_title: Program Structure and Design

paper_content:

Abstract Most models of computer programming explain the programmer's behaviour by a single design strategy. This article presents a cognitive architecture that uses cue-based search to model multiple design strategies including procedural, functional, means-end or focal, and opportunistic design. The model has been implemented in an artificial intelligence (AI) system that generates Pascal programs from English specifications. Knowledge is represented as nodes that reside in internal or external memory, where a node encodes an action that may range from a line of code to a routine in size. A program is built by linking nodes through a search cue of the form . The cue is broadcast to memory, and any matching node is returned; the cue provides a question to ask, and the return provides the answer. A cue on the newly linked node is then selected as a new focus, and the search process repeated. Each design strategy defines a specific node visiting order that traverses the program structure through its links.
---
paper_title: Human Cognition and Programming

paper_content:

Abstract This chapter presents an overview of cognition, and reviews the factors that dictate the nature of cognitive models of programming. The computational metaphor is outlined, and the following issues central to information processing are described: knowledge representation, schemas, production rules, procedural and declarative knowledge, attentional and memory resources, semantic memory, problem solving, skill acquisition, and mental models. These issues are fundamental to psychological models of programming presented in later chapters.
---
paper_title: Stimulus structures and mental representations in expert comprehension of computer programs

paper_content:

Abstract Comprehension of computer programs involves detecting or inferring different kinds of relations between program parts. Different kinds of programming knowledge facilitate detection and representation of the different textual relations. The present research investigates the role of programming knowledge in program comprehension and the nature of mental representations of programs; specifically, whether procedural (control flow) or functional (goal hierarchy) relations dominate programmers' mental representations of programs. In the first study, 80 professional programmers were tested on comprehension and recognition of short computer program texts. The results suggest that procedural rather than functional units form the basis of expert programmers' mental representations, supporting work in other areas of text comprehension showing the importance of text structure knowledge in understanding. In a second study 40 professional programmers studied and modified programs of moderate length. Results support conclusions from the first study that programs are first understood in terms of their procedural episodes. However, results also suggest that a programmer's task goals may influence the relations that dominate mental representations later in comprehension.
---
paper_title: Syntactic/semantic interactions in programmer behavior: A model and experimental results

paper_content:

This paper presents a cognitive framework for describing behaviors involved in program composition, comprehension, debugging, modification, and the acquisition of new programming concepts, skills, and knowledge. An information processing model is presented which includes a long-term store of semantic and syntactic knowledge, and a working memory in which problem solutions are constructed. New experimental evidence is presented to support the model of syntactic/semantic interaction.
---
paper_title: Mental Representations Constructed by Experts and Novices in Object-Oriented Program Comprehension

paper_content:

Previous studies on program comprehension were carried out largely in the context of procedural languages. Our purpose is to develop and evaluate a cognitive model of object-oriented (00) program understanding. Our model is based on the van Dijk and Kintsch's model of text understanding (1983). One key aspect of this theoretical approach is the distinction between two kinds of representation the reader might construct from a text: the textbase and the situation model. On the basis of results of an experiment we have conducted, we evaluate the cognitive validity of this distinction in 00 program understanding. We examine how the construction of these two representations is differentially affected by the programmer's expertise and how they evolve differentially over time.
---
paper_title: Cognitive processes in program comprehension

paper_content:

Abstract This paper reports on an empirical study of the cognitive processes involved in program comprehension. Verbal protocols were gathered from professional programmers as they were engaged in a program-understanding task. Based on analysis of these protocols, several types of interesting cognitive events were identified. These include asking questions and conjecturing facts about the code. We describe these event types and use them to derive a computational model of the programmers' mental processes.
---
paper_title: Cognitive Psychology and Its Implications

paper_content:

A fully updated, systematic introduction to the theoretical and experimental foundations of higher mental processes. Avoiding technical jargon, John R. Anderson constructs a coherent picture of human cognition, relating neural functions to mental processes, perception to abstraction, representation to meaning, knowledge to skill, language to thought, and adult cognition to child development.
---
paper_title: Studying the Novice Programmer

paper_content:

Parallel to the growth of computer usage in society is the growth of programming instruction in schools. This informative volume unites a wide range of perspectives on the study of novice programmers that will not only inform readers of empirical findings, but will also provide insights into how novices reason and solve problems within complex domains. The large variety of methodologies found in these studies helps to improve programming instruction and makes this an invaluable reference for researchers planning studies of their own. Topics discussed include historical perspectives, transfer, learning, bugs, and programming environments.
---
paper_title: Acquisition of Programming Knowledge and Skills

paper_content:

Acquiring and developing knowledge about programming is a highly complex process. This chapter presents a framework for the analysis of programming. It serves as a backdrop for a discussion of findings on learning. Studies in the field and pedagogical work both indicate that the processing dimension involved in programming acquisition is mastered best. The representation dimension related to data structuring and problem modelling is the ‘poor relation’ of programming tasks. This reflects the current emphasis on the computational programming paradigm, linked to dynamic mental models.
---
paper_title: More or less following a plan during design: opportunistic deviations in specification

paper_content:

An observational study was conducted on a mechanical engineer throughout his task of defining the functional specifications for the machining operations of a factory automation cell. The engineer described his activity as following a hierarchically structured plan. The actual activity is in fact opportunistically organized. The engineer follows his plan as long as it is cognitively cost-effective. As soon as other actions are more interesting, he abandons his plan to proceed to these actions. This paper analyses when and how these alternative-to-the-plan actions come up. Quantitative results are presented with regard to the degree of plan deviation, the design components and the definitional aspects which are most affected by these deviations, and the deviation patterns. Qualitative results concern their nature. An explanatory framework for plan deviation is proposed in the context of a blackboard model. Plan deviation is supposed to occur if the control, according to certain selection criteria, selects an alternative-to-the-planned-action proposal rather than the planned action proposal. Implications of these results for assistance tools are discussed briefly.
---
paper_title: Language Semantics, Mental Models and Analogy

paper_content:

Abstract The semantics of a number of programming languages is related to the operation of a computer device. Learning a programming language is considered here from the point of view of learning the operating rules of the processing device that underlies the language, as a complement to the learning of new notations, or a new means of expression to be compared to natural language. This acquisition leads beginners to elaborate a new representation and processing system (RPS) by analogy with other systems that are associated to well-known devices. During acquisition, beginners not only learn new basic operations but also the constraints of these operations upon program structures. Learning therefore concerns a basic problem space as well as abstract problem spaces within which planning takes place. The links between this approach to learning to program and a number of related works on learning to use software are underlined. Implications of these research findings in the programmer training are drawn.
---
paper_title: Models and theories of programming strategy

paper_content:

Abstract Much of the literature concerned with understanding the nature of programming skill has focused explicitly upon the declarative aspects of programmers' knowledge. This literature has sought to describe the nature of stereotypical programming knowledge structures and their organization. However, one major limitation of many of these knowledge-based theories is that they often fail to consider the way in which knowledge is used or applied. Another strand of literature is less well represented. This literature deals with the strategic elements of programming skill and is directed towards an analysis of the strategies commonly employed by programmers in the generation and the comprehension of programs. In this paper an attempt is made to unify various analyses of programming strategy. This paper presents a review of the literature in this area, highlighting common themes and concerns, and proposes a model of strategy development which attempts to encompass the central findings of previous research in this area. It is suggested that many studies of programming strategy are descriptive and fail to explain why strategies take the form they do or to explain the typical strategy shifts which are observed during the transitions between different levels of skill. This paper suggests that what is needed is an explanation of programming skill that integrates ideas about knowledge representation with a strategic model, enabling one to make predictions about how changes in knowledge representation might give rise to particular strategies and to the strategy changes associated with developing expertise. This paper concludes by making a number of brief suggestions about the possible nature of this model and its implications for theories of programming expertise.
---
paper_title: What do novices learn during program comprehension

paper_content:

Comprehension of computer programs involves identifying important program parts and inferring relationships between them. The ability to comprehend a computer program is a skill that begins its development in the novice programmer and reaches maturity in the expert programmer. This research examined the beginning of this process, that of comprehension of computer programs by novice programmers. The mental representations of the program text that novices form, which indicate the comprehension strategies being used, were examined. In the first study, 80 novice programmers were tested on their comprehension of short program segments. The results suggested that novices form detailed, concrete mental representations of the program text, supporting work that has previously been done with novice comprehension. Their mental representations were primarily procedural in nature, with little or no modeling using real‐world referents. In a second study, the upper and lower quartile comprehenders from Study 1 were test...
---
paper_title: Mental models and computer programming

paper_content:

Programming is a cognitive activity that requires the learning of new reasoning skills and the understanding of new technical information. Since novices lack domain-specific knowledge, many instructional techniques attempt to provide them with a framework or mental model that can be used for incorporating new information. A major research question concerns how to encourage the acquisition of good mental models and how these models influence the learning process. One possible technique for providing an effective mental model is to use dynamic cues that make transparent to the user all the changes in the variable values, source codes, output, etc., as the program runs. Two groups of novice programmers were used in the experiment. All subjects learned some programming notions in the C language (MIXC). The MIXC version of the programming language provides a debugging facility (C trace) designed to show through a system window all the program components. Subjects were either allowed to use this facility or not allowed to do so. Performance measures of programming and debugging were taken as well as measures directed to assess subjects' mental models. Results showed differences in the way in which the two groups represented and organized programming concepts, although the performance tasks did not show parallel effects.
---
paper_title: The Tasks of Programming

paper_content:

Abstract Computer programming and other design tasks have often been characterized as a set of non-interacting subtasks. In principle, it may be possible to separate these subtasks, but in practice there are substantial interactions between them. We argue that this is a fundamental feature of programming deriving from the cognitive characteristics of the subtasks, the high uncertainty in programming environments, and the social nature of the environments in which complex software development takes place.
---
paper_title: Program Structure and Design

paper_content:

Abstract Most models of computer programming explain the programmer's behaviour by a single design strategy. This article presents a cognitive architecture that uses cue-based search to model multiple design strategies including procedural, functional, means-end or focal, and opportunistic design. The model has been implemented in an artificial intelligence (AI) system that generates Pascal programs from English specifications. Knowledge is represented as nodes that reside in internal or external memory, where a node encodes an action that may range from a line of code to a routine in size. A program is built by linking nodes through a search cue of the form . The cue is broadcast to memory, and any matching node is returned; the cue provides a question to ask, and the return provides the answer. A cue on the newly linked node is then selected as a new focus, and the search process repeated. Each design strategy defines a specific node visiting order that traverses the program structure through its links.
---
paper_title: Characteristics of the mental representations of novice and expert programmers: an empirical study

paper_content:

Abstract 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.
---
paper_title: Conditions of Learning in Novice Programmers

paper_content:

Under normal instructional circumstances, some youngsters learn programming in BASIC or LOGO much better than others. Clinical investigations of novice programmers suggest that this happens in part...
---
paper_title: Programming Languages in Education: The Search for an Easy Start

paper_content:

(i) We first discuss educational objectives in teaching programming, using Logo research as a vehicle to report on versions of the ‘transfer of competence’ hypothesis. This hypothesis has received limited support in a detailed sense, but not in its original more grandiose conception of programming as a ‘mental gymnasium’. (ii) Difficulties in learning quickly abnegate educational objectives, so we next turn to Prolog, which originally promised to be easy to learn since it reduces the amount of program control that the programmer needs to define, but which turned out to be very prone to serious misconceptions. Recent work suggests that Prolog difficulties may be caused by an inability to see the program working. (iii) Does the remedy therefore lie in starting learners on programmable devices that are low level, concrete and highly visible? Research on this line has brought out another problem: learners find the ‘programming plans’ hard to master. (iv) Finally, we sketch a project designed to teach standard procedural programming via ‘natural plans’. Our conclusions stress pragmatic approaches with much attention to ease of use, avoiding taking ‘economy’ and ‘elegance’ as virtues in their own right.
---
paper_title: A goal/plan analysis of buggy pascal programs

paper_content:

In this paper, we present a descriptive theory of buggy novice programs and a bug categorization scheme that is based on this theory. Central to this theory is the cognitively plausible knowledge--goals and plans--that underlies programming. The bug categorization scheme makes explicit problem-dependent goal and plan knowledge at many different levels of detail. We provide several examples of how the scheme permits us to focus on bugs in a way that facilitates generating plausible accounts of why the bugs may have arisen. In particular, our approach has led us to one explanation of why some novice programs are buggier than others. A basic part of this explanation is the notion of merged goals and merged plans in which a single integrated plan is used to achieve multiple goals.
---
paper_title: Pedagogical Changes in the Delivery of the First-Course in Computer Science: Problem Solving, Then Programming

paper_content:

A teaching reform initiative, started in the spring semester of 1993 at the New Jersey Institute of Technology (NJIT), is described. The program seeks to increase student success in a freshman computer science course, and ultimately in the entire NJIT curriculum. The traditional teaching methods where the teacher presided over a lecture session supplying facts and figures, providing ideas, and presenting problems and their solutions, has been altered. The new learning environment described in this paper aims to create an all-inclusive setting inviting the students to make the transformation from passive learners to active participants. Rather than merely listening to lectures, students formulate problems and devise their own approaches to answering questions and finding solutions. Such a teaching/learning methodology requires instructional redesign and role redefinition. The presentation of class material is reordered as the teacher and students cross each other's confines becoming a more cohesive entity.
---
paper_title: Acquisition of Programming Knowledge and Skills

paper_content:

Acquiring and developing knowledge about programming is a highly complex process. This chapter presents a framework for the analysis of programming. It serves as a backdrop for a discussion of findings on learning. Studies in the field and pedagogical work both indicate that the processing dimension involved in programming acquisition is mastered best. The representation dimension related to data structuring and problem modelling is the ‘poor relation’ of programming tasks. This reflects the current emphasis on the computational programming paradigm, linked to dynamic mental models.
---
paper_title: Models and theories of programming strategy

paper_content:

Abstract Much of the literature concerned with understanding the nature of programming skill has focused explicitly upon the declarative aspects of programmers' knowledge. This literature has sought to describe the nature of stereotypical programming knowledge structures and their organization. However, one major limitation of many of these knowledge-based theories is that they often fail to consider the way in which knowledge is used or applied. Another strand of literature is less well represented. This literature deals with the strategic elements of programming skill and is directed towards an analysis of the strategies commonly employed by programmers in the generation and the comprehension of programs. In this paper an attempt is made to unify various analyses of programming strategy. This paper presents a review of the literature in this area, highlighting common themes and concerns, and proposes a model of strategy development which attempts to encompass the central findings of previous research in this area. It is suggested that many studies of programming strategy are descriptive and fail to explain why strategies take the form they do or to explain the typical strategy shifts which are observed during the transitions between different levels of skill. This paper suggests that what is needed is an explanation of programming skill that integrates ideas about knowledge representation with a strategic model, enabling one to make predictions about how changes in knowledge representation might give rise to particular strategies and to the strategy changes associated with developing expertise. This paper concludes by making a number of brief suggestions about the possible nature of this model and its implications for theories of programming expertise.
---
paper_title: Expert Programming Knowledge: A Strategic Approach

paper_content:

This chapter considers an alternative to the ‘programming plan’ view of programming expertise, namely that expert programmers have a much wider repertoire of strategies available to them as they program than do novices. This analysis does not dispute that experts have ‘plan-like’ knowledge, but questions the importance of the knowledge itself versus an understanding of when or how to use that knowledge. This chapter will firstly examine evidence which challenges the completeness of the plan-based theory and then it will look at evidence which reveals explicit strategic differences. As the studies are presented a list of strategies available to experts will be maintained. Although the emphasis of this section of the book is on expert performance, the chapter concludes with a brief look at studies of novices, since the strategic approach includes the assumption that the strategies used by novices are different from those available to experts. From all these studies it will be seen that experts choose strategies in response to factors such as unfamiliar situations, differing task characteristics and different language requirements, whilst many problems for novice programmers stem not only from lack of knowledge, but also from the lack of an adequate strategy for coping with the programming problem. ::: ::: The previous chapter has presented studies of expertise in computer programming that have concentrated on the content and structure of expert knowledge. The dominant concept has been the ‘programming plan’, which has been proposed as the experts' mental representation of programming knowledge, and which has been used in the development of programming tutors and environments for novice programmers. ::: ::: This chapter examines those aspects of expertise that are not easily explained by plan-based theories. It is intended that the strategic approach described in this chapter should be seen as a complementary, rather than alternative, explanation of expertise. As the various studies are described a list of important strategies which programmers may use will be developed. The studies that are to be presented reveal problems with two implications of the plan-based approach: ::: 1 ::: that ‘programming plans’ provide a complete explanation of expert programming behaviour; ::: ::: 2 ::: that a novice can be defined as someone who does not possess this expert knowledge. ::: ::: ::: ::: ::: An important, but often implicit assumption of the plan-based theorists is that the cognitive processes underlying programming are relatively straightforward. Often based on ideas from artificial intelligence, these processes are taken to be general problem-solving skills (cf. SOAR, Laird et al., 1987; ACT*, Anderson, 1983), which a novice programmer also possesses. The learning of computer programming is the acquisition of the appropriate knowledge structures for the problem-solving skills to use. These knowledge structures may then be labelled ‘plans’ (see Chapter 3.1 for more details), though other possibilities exist. The critical feature is that expertise is seen as the acquisition of knowledge. ::: ::: The alternative position is that expertise in programming may involve a variety of cognitive processes which, coupled with changes in knowledge, can give rise to a choice of different methods for solving any particular programming problem. These different methods can be termed strategies. The critical feature of the strategy argument is that observations of novice-expert differences can be caused by either knowledge differences, processing differences, or both. ::: ::: Any assessment of this argument has two important strands. Firstly some evidence questioning the plan-based theory will be presented (evidence for the theory has been covered by the previous chapter) and then evidence of strategic differences will be described. For these reasons it is important that the evidence for alternative aspects to expertise beyond the plan-based theories is carefully considered
---
paper_title: Preprogramming knowledge: a major source of misconceptions in novice programmers

paper_content:

We present a process model to explain bugs produced by novices early in a programming course. The model was motivated by interviews with novice programmers solving simple programming problems. Our key idea is that many programming bugs can be explained by novices inappropriately using their knowledge of step-by-step procedural specifications in natural language. We view programming bugs as patches generated in response to an impasse reached by the novice while developing a program. We call such patching strategies bug generators. Several of our bug generators describe how natural language preprogramming knowledge is used by novices to create patches. Other kinds of bug generators are also discussed. We describe a representation both for novice natural language preprogramming knowledge and novice fragmentary programming knowledge. Using these representations and the bug generators, we evaluate the model by analyzing four interviews with novice programmers.
---
paper_title: Learning flow of control: recursive and iterative procedures

paper_content:

Two experiments were performed to study students' ability to write recursive and iterative programs and transfer between these two skills. Subjects wrote functions to accumulate instances into a list. Problems varied in terms of whether they were recursive or iterative, whether they operated on lists or numbers, whether they accumulated results in forward or backward manner, whether they accumulated on success or failure, and whether they simply skipped or ejected on failure to accumulate. Subjects had real difficulty only with the dimensions concerned with flow of control, namely, recursive versus iterative, and skip versus eject. We found positive transfer from writing iterative functions to writing recursive functions, but not vice versa. A subsequent protocol study revealed subjects had such a poor mental model of recursion that they developed poor learning strategies which hindered their understanding of iteration. It is argued that having an adequate model of the functionality of programming is prerequisite to learning to program, and that it is sensible pedagogical practice to base understanding of recursive flow of control on understanding iterative flow of control.
---
paper_title: Programming pedagogy—a psychological overview

paper_content:

Can we turn novices into experts in a four year undergraduate program? If so, how? If not, what is the best we can do? While every teacher has his/her own opinion on these questions, psychological studies over the last twenty years have started to furnish scientific answers. Unfortunately, little of these results have been incorporated into curricula or textbooks. This report is a brief overview of some of the more important results concerning computer programming and how they can affect course design.
---
paper_title: Fragile knowledge and neglected strategies in novice programmers

paper_content:

Many students have great difficulty mastering the basics of programming. Inadequate knowledge, neglect of general problem-solving strategies, or both might explain their troubles. We report a series of clinical interviews of students taking first year BASIC in which an experimenter interacted with students as they worked, systematically providing help as needed in a progression from general strategic prompts to particular advice. The results indicate a substantial problem of "fragile knowledge" in novices knowledge that is partial, hard to access, and often misused. The results also show that general strategic prompts often resolve these difficulties. Recommendations for teaching more robust knowledge and general strategies are made. Implications for the impact of programming on general cognitive skills are considered.
---
paper_title: A Study of the Development of Programming Ability and Thinking Skills in High School Students

paper_content:

This article reports on a year-long study of high school students learning computer programming. The study examined three issues: I) what is the impact of programming on particular mathematical and reasoning abilities?; 2) what cognitive skills or abilities best predict programming ability?; and 3) what do students actually understand about programming after two years of high school study? The results showed that even after two years of study, many students had only a rudimentary understanding of programming. Consequently, it was not surprising to also find that programming experience (as opposed to expertise) does not appear to transfer to other domains which share analogous forrnal properties. The article concludes that we need to more closely study the pedagogy of programming and liow expertise can be better attained before we prematurely go looking for significant and wide reaching transfer effects from programming.
---
paper_title: Program Structure and Design

paper_content:

Abstract Most models of computer programming explain the programmer's behaviour by a single design strategy. This article presents a cognitive architecture that uses cue-based search to model multiple design strategies including procedural, functional, means-end or focal, and opportunistic design. The model has been implemented in an artificial intelligence (AI) system that generates Pascal programs from English specifications. Knowledge is represented as nodes that reside in internal or external memory, where a node encodes an action that may range from a line of code to a routine in size. A program is built by linking nodes through a search cue of the form . The cue is broadcast to memory, and any matching node is returned; the cue provides a question to ask, and the return provides the answer. A cue on the newly linked node is then selected as a new focus, and the search process repeated. Each design strategy defines a specific node visiting order that traverses the program structure through its links.
---
paper_title: Conditions of Learning in Novice Programmers

paper_content:

Under normal instructional circumstances, some youngsters learn programming in BASIC or LOGO much better than others. Clinical investigations of novice programmers suggest that this happens in part...
---
paper_title: What do novice programmers know about recursion

paper_content:

Recent research into differences between novice and expert computer programmers has provided evidence that experts know more than novices, and what they know is better organized. The conclusion is only as interesting as it is intuitive. This paper reports an experiment which was designed to determine precisely what novice programmers understand about the behaviour of recursive procedures, and exactly how their understanding differs from an expert's understanding of the process. The results show that different novices understand, or misunderstand, different things. Implications of the findings are discussed with respect to other research into novice and expert programming performance.
---
paper_title: Studying the Novice Programmer

paper_content:

Parallel to the growth of computer usage in society is the growth of programming instruction in schools. This informative volume unites a wide range of perspectives on the study of novice programmers that will not only inform readers of empirical findings, but will also provide insights into how novices reason and solve problems within complex domains. The large variety of methodologies found in these studies helps to improve programming instruction and makes this an invaluable reference for researchers planning studies of their own. Topics discussed include historical perspectives, transfer, learning, bugs, and programming environments.
---
paper_title: Cognitive style, personality, and computer programming

paper_content:

Abstract Within the field of computer programming there is evidence of tremendous variation among individuals achievement in programming. Cognitive styles and personality traits have been investigated as factors that may help explain some of that variability; however, they have failed to consistently explain individual differences in achievement. In the majority of these studies, computer programming has been measured as a single activity. Computer programming has been described as an activity having separate and distinct phases: problem representation, program design, coding, and debugging. It may be that certain cognitive styles and personality dimensions affect some phases but not others. The purpose of this review is twofold. First, the empirical studies on the relation between cognitive style, personality traits and computer programming are reviewed. Second, the paper provides an agenda for future research by providing a conceptual framework that organizes and relates the variety of constructs to the specific phases of writing computer programs and identifies a number of distinct gaps in this particular body of research.
---
paper_title: Conditions of Learning in Novice Programmers

paper_content:

Under normal instructional circumstances, some youngsters learn programming in BASIC or LOGO much better than others. Clinical investigations of novice programmers suggest that this happens in part...
---
paper_title: A Study of the Development of Programming Ability and Thinking Skills in High School Students

paper_content:

This article reports on a year-long study of high school students learning computer programming. The study examined three issues: I) what is the impact of programming on particular mathematical and reasoning abilities?; 2) what cognitive skills or abilities best predict programming ability?; and 3) what do students actually understand about programming after two years of high school study? The results showed that even after two years of study, many students had only a rudimentary understanding of programming. Consequently, it was not surprising to also find that programming experience (as opposed to expertise) does not appear to transfer to other domains which share analogous forrnal properties. The article concludes that we need to more closely study the pedagogy of programming and liow expertise can be better attained before we prematurely go looking for significant and wide reaching transfer effects from programming.
---
paper_title: Language Semantics, Mental Models and Analogy

paper_content:

Abstract The semantics of a number of programming languages is related to the operation of a computer device. Learning a programming language is considered here from the point of view of learning the operating rules of the processing device that underlies the language, as a complement to the learning of new notations, or a new means of expression to be compared to natural language. This acquisition leads beginners to elaborate a new representation and processing system (RPS) by analogy with other systems that are associated to well-known devices. During acquisition, beginners not only learn new basic operations but also the constraints of these operations upon program structures. Learning therefore concerns a basic problem space as well as abstract problem spaces within which planning takes place. The links between this approach to learning to program and a number of related works on learning to use software are underlined. Implications of these research findings in the programmer training are drawn.
---
paper_title: Cognitive Principles in the Design of Computer Tutors.

paper_content:

Abstract : A set of principles are derived from the ACT theory of cognition for designing intelligent tutors: identify the goal structure of the problem space, provide instruction on the problem-solving context, provide immediate feedback in errors, minimize working memory loads, use production system models of the student, adjust the grain size of instruction according to learning principles, enable the student to approach the target skills by successive approximation, and promote use of general problem-solving rules over analogy. These principles have successfully guided our design of tutors for college students learning to program LISP and for high school students learning geometry.
---
paper_title: A Study of the Development of Programming Ability and Thinking Skills in High School Students

paper_content:

This article reports on a year-long study of high school students learning computer programming. The study examined three issues: I) what is the impact of programming on particular mathematical and reasoning abilities?; 2) what cognitive skills or abilities best predict programming ability?; and 3) what do students actually understand about programming after two years of high school study? The results showed that even after two years of study, many students had only a rudimentary understanding of programming. Consequently, it was not surprising to also find that programming experience (as opposed to expertise) does not appear to transfer to other domains which share analogous forrnal properties. The article concludes that we need to more closely study the pedagogy of programming and liow expertise can be better attained before we prematurely go looking for significant and wide reaching transfer effects from programming.
---
paper_title: Skill Acquisition and the LISP Tutor

paper_content:

An analysis of student learning with the LISP tutor indicates that while LISP is complex, learning it is simple. The key to factoring out the complexity of LISP is to monitor the learning of the 500 productions in the LISP tutor which describe the programming skill. The learning of these productions follows the power-law learning curve typical of skill acquisition. There is transfer from other programming experience to the extent that this programming experience involves the same productions. Subjects appear to differ only on the general dimensions of how well they acquire the productions and how well they retain the productions. Instructional manipulations such as remediation, content of feedback, and timing of feedback are effective to the extent they give students more practice programming, and explain to students why correct solutions work.
---
paper_title: Cognitive modeling and intelligent tutoring

paper_content:

Abstract : The ACT theory of skill acquisition and its PUPS successor provide production-system models of the acquisition of skills such as LISP programming, geometry theorm-proving, and solving of algebraic equations. Knowledge begins in declarative form and is used by analogical processes to solve specific problems. Domain specific productions are compiled from the traces of these problem solutions. The model-tracing methodology has been developed as a means of displaying this cognitive theory in intelligent tutoring. Implementation of the model-tracing methodology involves developing a student model, a pedagogical module, and an interface. issues associated with the development of each of these components are discussed. Work on tutoring and work on skill acquisition have proven to symbiotic; that is, each has furthered the other's development. Keywords: Analogy; Artificial Intelligence; Cognitive Science; Computer-Assisted Instruction.
---
paper_title: Studying the Use of Peer Learning in the Introductory Computer Science Curriculum

paper_content:

This paper reports the results of studying the use of peer learning in the introductory computer science curriculum. The project involves educators from a variety of institutions who participated in two summer workshops and either introduced or continued their use of peer learning at their institutions as part of this project. The results of the collective work include much experience with different types of peer learning in different settings. Overall, the results indicate that peer learning is a valuable technique that should be used as one pedagogical approach in teaching the introductory computer science curriculum.
---
paper_title: In Support of Pair Programming in the Introductory Computer Science Course

paper_content:

A formal pair programming experiment was run at North Carolina to empirically assess the educational efficacy of the technique in a CS1 course. Results indicate that students who practice pair programming perform better on programming projects and are more likely to succeed by completing the class with a C or better. Student pairs are more self-sufficient which reduces their reliance on the teaching staff. Qualitatively, paired students demonstrate higher order thinking skills than students who work alone. These results are supportive of pair programming as a collaborative learning technique.
---
paper_title: Incorporating problem-solving patterns in CS1

paper_content:

In [Wall96], Wallingford describes an approach to introductory courses that is based on programming patterns, i.e., algorithms or problem-solving approaches that can be applied to various applications. By focusing on patterns such as "Input-Process-Test" or "Process all items in a collection", students reason at a higher-level of abstraction when solving problems. In addition, code schema can be provided which apply to certain patterns, and these schema then serve as frameworks for program development. (See also [Rist89], [Coad92], and [GHJV95].)Closely related to the patterns approach is the use of themes in a programming course. Selecting a particular idea (such as self-reference [Astr94]), methodology (such as formal specifications [MH96]), or application domain (such as databases [AR95]) provides a framework for learning new techniques and concepts. Once a concept has been studied in one context, new applications which similarly utilize that concept can be understood more easily.This paper describes the use of a particular problem-solving pattern, binary reduction, as a recurring theme in the CS1 course. Other problem-solving approaches, such as divide-and-conquer or generate-and-test, could similarly be used. By introducing problem-solving patterns early in the course and then revisiting them in different contexts, students learn to look for common characteristics in problems, and to use an existing solution as a framework for solving related problems. Perhaps more importantly, understanding the behavior of one problem solution can simplify the analysis of other problem solutions based on the same pattern.
---
paper_title: Analysis of Design: An exploration of Patterns and Pattern Languages for Pedagogy

paper_content:

ion also serves a second purpose, that of cohesion of ideas. Practice can be captured at any scale, but it is the combination of capture and abstraction that makes the presentation of the ideas coherent. Lakoff (Lakoff, 1987) presents an example of this coherent use of abstraction in regard to the Linnean taxonomy of botanical classification Genus, Species, Sub-Species, Variety. An oak tree (for example) can be categorised at any level. However, in folk-classification (as opposed to scientific) Lakoff (quoting studies by Brown and Berlin, p.35) notes that the most commonly used (and by extension, the most significant) name and reference is at the level of abstraction that corresponds to the genus level (“oak”) rather than the life-form (“tree”) or variety (“white oak”) levels. Whilst an interesting observation in it’s own right, the more interesting point is that Linneaus actively used folk criteria for the genus level of abstraction which characterise the most readily apprehended (and used) criteria in “the real world”. This is a concept equally important in OO, Booch’s (Booch, 1994) codification of “key abstractions”, notes that there are levels of categorisation which are more significant in the problem space, and useful to the solution design, than others. He, too, suggests that these might most effectively be identified from actual usage “if the domain expert talks about it, then the abstraction is usually important”. What has been noticed here is that some categories of abstraction are more basic, more meaningful to human beings in their relationship with the world than others; that is the level of abstraction that good patterns seek to embrace. 4.3 Organising Principle As we have seen, patterns do not exist by themselves, but within a framework: a catalogue or language. In a catalogue, the power of the collection resides in the material collected. The index, or finding aid or other system of organisation is of secondary importance, it is simply a mechanism to get to the information. In a dictionary, encyclopaedia or thesaurus, the power resides as much in the arrangement of material, in the power that the organising principle confers to it, as in the individual entries themselves. The solitary definition of a word is useful, but much more potent in the context of a dictionary. The Organising Principle of a Pattern Language has a similar gestalt power; the language captures not only the pieces of design, but the shape of the whole into which the pieces fit. The Alexandrian organising principle is scale. A Pattern Language recognises the impossibility of providing a complete solution (“Here’s the plan for the house/street/city you want to build”) so presents many small, transferable solutions arranged in categories of scale, from “city-relevant” to “house-relevant”. Consequently, if I am building a house, not a whole street, I have an obvious entry point to the most appropriate level of patterns. The boundaries for these categories, however, are not hard and Alexander provides pointers, both up and down, through the levels pointing to larger-scale patterns to which a given pattern is contributory and to smaller-scale patterns on which it rests. The GoF framework is much simpler, residing on the applicability of their solutions to different functionality in the design process (Creational, Structural or Behavioural). Reference for this paper: Journal of Computers in Mathematics and Science Teaching: Special Issue CS-ED Research, 18(3):331-348, December 1999. The PPTOT collection has neither order, nor organising principle: instead, four separate “indexes” are provided, each on a different axis: A Learning Objectives Index, a Teaching/Learning Element Index, an Alphabetical Index and an Author Index. It is clear that these indexes have been super-imposed on the collection at a later date, and that they have had no impact at the time of creation. (However, it should be noted that PPOT is a work in progress, and recent work has turned towards structure and taxonomy. Although full details are not available, it would seem that this, too, is based on scale from “a technique pattern aimed at explaining a particular OO concept” to “a complex structure pattern built from smaller fundamental units, such as lectures and exercises” (McLaughlin et al, 1998)). A potentially interesting approach, which has not so far been adopted within the genre is one espoused by Jacobson (one of the original contributors to A Pattern Language) in a later work (Jacobson, Silverstein, Winslow, 1990). In this work the organising principle for good design is the balance achieved on various axes of contrast. Six axes are identified with respect to architecture with “good” design representing an equilibrium along and between these scales. A similar methodological approach (Wildermeersch, 1997) has been taken in an attempt to capture (and improve) the practice and experience of working within project-oriented groups; a domain with more obviously pedagogic potential. 4.4 Value System Design is a purposeful, value-laden activity. Good design encompasses values which are of importance to all the communities (or audience) for which the artefacts are intended. For the purposes of patterns, we can define three audiences: users, other designers and “society”. • Users: Values which are important to users are those embodied in the artefact itself. This is exemplified in the arts-andcrafts motto “Have nothing in your house which you do not know to be useful or believe to be beautiful”. If an object is difficult to use, or ugly, then it fails in its purpose. It is disfunctional. • Other Designers: Whilst fellow professionals might be expected to appreciate the values of the user community, they also hold another set of separate importance. These professional values encompass design notions of “elegance” and “simplicity”. An appreciation of the economy of immaterial processes (such as maintainability, factory production or services) also count here. • Society: Design also addresses ideas of value which are societally constructed. This is a more difficult (and difficult to observe) constituent of patterns and pattern languages. This is because this level is not directly addressed by patterns, although they are created against its backdrop. For example, the Alexandrian pattern 178, describing Composting Toilets, (Alexander et al, 1977) encompasses a far more wide-ranging set of values than a thing designed to do a job efficiently—that is usefully—and/or beautifully. (These values are not necessarily commonly held – but they would have to be, if everyone was to own one. They are of the societal level). Patterns are described and presented as internally consistent system of elements that are good in themselves and in relationship to each other. Any further set of values is extrinsic to this ordering, and therefore not described within a pattern collection. This notion of extrinsic validity is analogous to IQ tests which are internally consistent, valid and predictive (as are measurements of height). Their value, however, is neither measured nor contained within the application of the test but is determined by a separate, external system. A society which values high IQ (or tall people) gives a separate – and extrinsic – meaning to the results. The fact that (to continue the example) A Pattern Language doesn’t explicitly incorporate these values doesn’t mean that the patterns weren’t created with reference to them. It may be that there is no need for these values to be expressed in this way. Just as Fine Art reflects the values of the society in which it is created, so may design: “The best paintings often express their culture not just directly but complementarily, because it is by complementing it that they are best designed to serve public needs: the public does not need what it has already got.” (Baxandall, 1972). Alexandrian patterns have three audiences: architects (other designers) and the inhabitants of the buildings (users) are explicitly addressed, society is implicitly addressed. PPTOT patterns have two audiences, teachers (other designers) and the recipients of teaching (users). GoF patterns have but one audience – other designers – and reflect a single system of purely professional values. Christopher Alexander (whilst acknowledging his lack of expertise in the domain of software) has expressed his opinion that software patterns (and, I think by extension patterns based on that system) are not patterns in his sense but “a neat way to capture a bunch of interesting ideas” (Alexander, 1996). He does not explain why he thinks this is the case. It may be the constraint of their single value system.
---
paper_title: Transfer in cognition

paper_content:

The purpose of this paper is to review the cognitive literature regarding transfer in order to provide a context for the consideration of transfer in neural networks. We consider transfer under the three general headings of analogy, skill transfer and metaphor. The emphasis of the research in each of these areas is quite different and the literatures are largely distinct. Important common themes emerge, however, relating to the role of similarity, the importance of “surface content”, and the nature of the representations that are used. We will draw out these common themes, and note ways of facilitating transfer. We also briefly note possible implications for the study of transfer in neural networks.
---
paper_title: Programming pedagogy—a psychological overview

paper_content:

Can we turn novices into experts in a four year undergraduate program? If so, how? If not, what is the best we can do? While every teacher has his/her own opinion on these questions, psychological studies over the last twenty years have started to furnish scientific answers. Unfortunately, little of these results have been incorporated into curricula or textbooks. This report is a brief overview of some of the more important results concerning computer programming and how they can affect course design.
---
paper_title: Program Structure and Design

paper_content:

Abstract Most models of computer programming explain the programmer's behaviour by a single design strategy. This article presents a cognitive architecture that uses cue-based search to model multiple design strategies including procedural, functional, means-end or focal, and opportunistic design. The model has been implemented in an artificial intelligence (AI) system that generates Pascal programs from English specifications. Knowledge is represented as nodes that reside in internal or external memory, where a node encodes an action that may range from a line of code to a routine in size. A program is built by linking nodes through a search cue of the form . The cue is broadcast to memory, and any matching node is returned; the cue provides a question to ask, and the return provides the answer. A cue on the newly linked node is then selected as a new focus, and the search process repeated. Each design strategy defines a specific node visiting order that traverses the program structure through its links.
---
paper_title: On the Cruelty of Really Teaching Computer Science redux

paper_content:

Is our discipline of computer science in a time of crisis? Our field has helped unlock the human genome, has allowed a hand-held device to be a gateway to the world's information, and has transformed communication and society. Yet students do not want to study computer science. Do enrollment trends portend serious problems requiring immediate solutions or is the crisis greatly exaggerated?
---
paper_title: Programming patterns and design patterns in the introductory computer science course

paper_content:

We look at the essential thinking skills students need to learn in the introductory computer science course based on object-oriented programming. We create a framework for such a course based on the elementary programming and design patterns. Some of these patterns are known in the pattern community, others enrich the collection. Our goal is to help students focus on mastering reasoning and design skills before the language idiosynchracies muddy the water.
---
paper_title: Conditions of Learning in Novice Programmers

paper_content:

Under normal instructional circumstances, some youngsters learn programming in BASIC or LOGO much better than others. Clinical investigations of novice programmers suggest that this happens in part...
---
paper_title: Problem-Based Learning for Foundation Computer Science Courses

paper_content:

The foundation courses in computer science pose particular challenges for teacher and learner alike. This paper describes some of these challenges and how we have designed problem-based learning (PBL) courses to address them. We discuss the particular problems we were keen to overcome: the purely technical focus of many courses; the problems of individual learning and the need to establish foundations in a range of areas which are important for computer science graduates. We then outline our course design, showing how we have created problem-based learning courses. The paper reports our evaluation of the approach. This has two parts: assessment of a trial, with a three-year longitudinal follow-up of the students; reports of student learning improve-ment after we had become experienced in full implementation of PBL. We conclude with a summary of our experience over three years of PBL teaching and discuss some of the pragmatic issues around introducing the radical change in teaching, maintaining staff suppo...
---
paper_title: Rules of the Mind

paper_content:

Contents: Production Systems and the ACT-R Theory. Knowledge Representation. Performance. Learning. N. Kushmerick, C. Lebiere, Navigation and Conflict Resolution. N. Kushmerick, C. Lebiere, The Tower of Hanoi and Goal Structures. F.G. Conrad, A.T. Corbett, The LISP Tutor and Skill Acquisition. F.S. Bellezza, C.F. Boyle, The Geometry Tutor and Skill Acquisition. M.K. Singley, The Identical Elements Theory of Transfer. F.G. Conrad, A.T. Corbett, J.M. Fincham, D. Hoffman, Q. Wu, Computer Programming and Transfer. A.T. Corbett, Tutoring of Cognitive Skill. Creating Production-Rule Models. Reflections on the Theory.
---
paper_title: A Perspective View and Survey of Meta-Learning

paper_content:

Different researchers hold different views of what the term meta-learning exactly means. The first part of this paper provides our own perspective view in which the goal is to build self-adaptive learners (i.e. learning algorithms that improve their bias dynamically through experience by accumulating meta-knowledge). The second part provides a survey of meta-learning as reported by the machine-learning literature. We find that, despite different views and research lines, a question remains constant: how can we exploit knowledge about learning (i.e. meta-knowledge) to improve the performance of learning algorithms? Clearly the answer to this question is key to the advancement of the field and continues being the subject of intensive research.
---

Title: Learning and teaching programming: A review and discussion

Section 1: INTRODUCTION
Description 1: Introduce the importance of programming as a skill, the high demand for programmers, the difficulties encountered by novice programmers, and the scope and focus of the review.

Section 2: Experts Versus Novices
Description 2: Discuss the distinctions and development stages between novice and expert programmers, characteristics of expert programmers, and typical novice deficits.

Section 3: Knowledge Versus Strategies
Description 3: Explore the foundational knowledge required for programming and the different strategies used by programmers, including how these differ between novices and experts.

Section 4: Procedural Versus Object-Oriented
Description 4: Compare issues related to procedural and object-oriented programming paradigms and how they affect novice comprehension and learning.

Section 5: NOVICE PROGRAMMERS
Description 5: Focus on how novices learn to program, including task complexity, cognitive processes, and the mental models they need to develop.

Section 6: Mental Models and Processes
Description 6: Detail the various mental models that programmers must maintain, including models of the problem domain, the notional machine, and the program itself.

Section 7: Novice Capabilities and Behaviour
Description 7: Analyze the specific knowledge and skill deficits of novice programmers, their common misconceptions, and issues with planning and problem-solving.

Section 8: Kinds of Novice
Description 8: Discuss the diversity among novice programmers, including differences in background, motivation, success predictors, and characteristic behaviors such as "movers" and "stoppers."

Section 9: Goals and Progress
Description 9: Explore the goals of introductory programming courses, the concept of "deep learning," and the challenge of fostering significant progress among novices.

Section 10: Course Design and Teaching Methods
Description 10: Review conventional and innovative approaches to course design and teaching methods, with an emphasis on addressing key issues identified in the literature.

Section 11: Alternative Methods and Curricula
Description 11: Consider alternative curricula and teaching methodologies, such as schema-based instruction, problem-solving approaches, and mathematical foundations.

Section 12: Summary and Implications
Description 12: Summarize the review and highlight practical implications for teaching programming, including methodological suggestions and potential areas for further research.

Section 13: A Programming Framework
Description 13: Introduce a programming framework summarizing the relationships between key issues in programming education and its potential uses in course design and student support.

Section 14: Comments and Future Work
Description 14: Provide speculative observations and suggest topics for future research, including the distinction between effective and ineffective novices and the central role of strategies in learning to program.