INTRODUCTION
As a major topic in information technology education, computer programming has been taught to both major and non-major students in universities. While there has been ongoing debate on whether students should be taught programming (Soloway, 1993), the literature shows that learning to program poses a lot of difficulties to novices (Bonar & Soloway, 1989). Dijkstra (1989) describes programming as “radical novelty” in which our usual strategy of metaphors and analogies simply does not apply. Pea (1986) identifies three types of conceptual bugs which are rooted in a superbug where “there is a hidden mind somewhere in the programming language that has intelligent interpretive powers”.
Why is learning to program so difficult? One difficulty is that learning to program needs the acquisition of a multitude of inter-related skills. Jenkins (2002) argues that programming is a complicated task, which requires the mastery of a number of skills such as problem solving, abstraction, mathematical logic and testing, debugging and so forth. A novice programmer simply lacks these skills. More importantly, success in learning to program demands knowledge of computer itself. Ben-Ari (1998) points out that students lack a viable mental model to learn programming. On the other hand, undue emphasis is placed on the learning of programming syntax (Deek, 1999). In this article, we will focus on approaches of teaching computer programing. Winslow (1996) introduced the term “programming pedagogy” in his paper. Although programming pedagogy is not explicitly defined in the paper, the term here refers to any instructional methods and strategies which are used to teach students introductory programming. Due to these reasons, programming pedagogy calls for special attention.
BACKGROUND
Over the years, pedagogical innovations have been proposed to cope with these difficulties. These include a variety of programming tools (Smith & Webb, 2000). These tools help novice programmers to develop programs through program visualisation and algorithm animation. Deek and McHugh (1998) evaluate programming tools used to teach programming. One common problem among these tools is that they fail to integrate into the curriculum. This suggests that there is a need to investigate what programming pedagogy should be adopted together with tools to bring about innovations in programming instruction. This article intends to review on programming pedagogy reported in the literature. A theoretical framework on programming pedagogy grounded on literature review is proposed which attempts to conceptualise pedagogy in terms of the cognitive and technological dimensions. For researchers, this review not only provides a summary of pedagogy adopted to date, but also theoretical underpinning for future research on programming pedagogy. For practitioners, the proposed framework can help them to evaluate and reflect on their own pedagogy with an aim to improve the quality of teaching and learning computer programming.
APPROACHES OF TEACHING PROGRAMMING
We identified seven pedagogical approaches of teaching computer programming arising from the review of appropriate literature. The following sections provide a brief description of each of these approaches.
Structured Programming Approach
In the 1970s, one catchword in programming is structured programming. It is an approach, which intends to “support the production of correct, understandable programs which are easy to modify and maintain” (Freiburghouse & Liskov, 1973). The approach allows control structures of sequence, selection, and repetition only. The GOTO statement is considered detrimental to structured programming (Dijkstra, 1968). To facilitate the development of a structured program, a top-down design, which decomposes a large program into a manageable smaller program, is used. Programs are improved successively through stepwise refinement. In this manner, it is hoped that quality program can be produced. Although it was advocated in the 1970s, it is still one of the prevalent programming approaches today.
Problem Solving Approach
Barnes, Fincher, and Thompson (1997) describe a programming methodology consisting of four steps, namely, Understanding, Designing, Writing and Reviewing. Following the same line of thinking, Thompson (1997) proposes a problem solving approach in teaching functional programming. He claims that using the approach, ” a novice can make substantial progress in completing a programming task before beginning to write any program code.” Gries (1974) emphasizes the importance of problem solving in programming. He argues that usual assumption that students should have learned programming after giving tools and examples is not peda-gogically sound. To address this problem, he suggests the four-phase process of problem solving by Polya (1957).
Software Development Approach
It is equally important that students should know how to translate algorithms into syntactically and semantically correct solution of the problem that form the program. In this regard, Deek (1999) develops a methodology which incorporates both the problem solving skills and the programming skills into a single process that provides a framework for beginning students. As noted by Deek (1999), there are three kinds of difficulties faced by students when learning to program: (1) deficiencies in problem solving strategies and tactical knowledge; (2) ineffective pedagogy of programming instruction; and (3) misconceptions about syntax, semantics, and pragmatics. The new approach, which incorporates both the problem solving skills and the programming skills, can help address all the three kinds of difficulties.
Small Programming Approach
If programming creates a large cognitive load on novices, it is reasonable to reduce such load by programming in a “small” scale. In this sense, we distinguish between the terms Programming-in-the-small and Programming Lan-guage-in-the-small.
Glaser, Hartel, and Garratt (2000) introduce the idea Programming by Number in teaching ML and Java. Programming by Number is intended to get students started in writing program by providing a step-by-step guidance to students while allowing flexibility in the design of the solution to a problem. When writing functions, they suggest the following steps: (1) name the function; (2) write down its type; (3) enumerate all cases; (4) deal with any simple case(s); (5) list the ingredients in preparation for the complex case(s); (6) deal with the complex case(s), where some inspiration is required; and (7) think about the result. Brusilovsky, Kouchnirenko, Miller, and Tomek (1994) review on three approaches of teaching introductory programming, namely, the incremental approach, the mini-language approach, and the sub-language approach. In the incremental approach, new language subsets, which introduce new programming language constructs while retaining all the constructs of preceding subsets, are introduced successively to novices. In the mini-language approach, a small and simple language is used to support the first steps in learning to program. In most cases, a student learns how to program by controlling an actor, which can be a turtle, a robot, or any other active entity, in a microworld. The sub-language approach uses a special starting subset of the full language which contains easily visualizable operations to introduce programming to novices. In short, these three approaches provide a simple and small language subsets and a visually appealing metaphor embedded in a context-rich environment to help novices start programming.
Language Teaching Approach
Robertson and Lee (1995) give a research manifesto for the application of a second natural language acquisition pedagogy to the teaching of programming languages. They argue that programming has traditionally taught with little reference to natural language pedagogy. To conclude, they provide some areas for further research such as the value of reading programs before writing, the use of authentic programs, the study of the cultural milieu of programs, and so forth. Baldwin and Macredie (1999) argue that research in the learner strategies in second language pedagogy may provide insight into programming pegadogy. Based on the call for a more learner-centred environment, they believe that learner strategies are one of the issues in teaching programming that can help address difficulties in learning to program. Deek and Friedman (2001) describe their ideas of how programming and writing are learned in parallel. They argue that the common element that exists in both domains, problem solving and program development, provides “new ways for students to transfer skills between domains”.
Learning Theory Approach
Lister and Leaney (2003) argue that traditional norm-referencing approach to grading tends to target at average students. As a result, weaker students cannot program well and stronger students are not challenged. They suggest a criterion-referencing approach to grading so that explicit and clear criteria are set for each grade. In deciding the criteria, reference is made to the Bloom’s Taxonomy of Educational Objectives (Bloom, 1956). Macfarlane and Mynatt (1988) examine the effectiveness of advance organizer in teaching the syntax of arrays. The tasks of the subjects were to enter syntactically and semantically correct Pascal statements to manipulate arrays in a training program. The study used a metaphorical advance organizer-a one-story apartment building. Results revealed that the groups did not differ on syntactic knowledge (near transfer). Yet the advance organizer group outperformed the other two groups in semantic knowledge (far transfer).
Other Approaches
There are other innovative attempts in programming pedagogy. Astrachan and Reed (1995) propose an apprenticeship model of learning in which students begin by reading, studying, and extending programs written by expert programmers. Through this approach, students learn from real-world examples, practice code, and concept reuse. Jenkins (1998) attempts to get students actively participate in learning to program. His participative approach aims to make the learning of some abstract programming concepts such as procedures, parameters, pointers, and linked lists more accessible to students. Proulx (2000) introduces the use of programming patterns in learning to program. The idea is to organize the common used methods like reading data in programming as patterns for reuse.
DISCUSSION
In this section, pedagogical remarks are made on these approaches. Then, it is followed by the discussion of a proposed theoretical framework which attempts to conceptualise programming pedagogy in terms of two dimensions.
Empirical Evaluation
It is common that many approaches lack classroom evaluation of their effectiveness. In many cases, they are simply ideas based on the experience of the practioners in teaching. While some studies show empirical evaluations of their approaches (Glaser et al., 2000; Macfarlane & Mynatt, 1988), many simply do not provide sufficient evidence to support their claims. For instance, Proulx (2000) reports that, “Overall, we felt the course was a success. Students performed better on the midterm exam and seemed more confident than in the past”. Yet, no information on the students’ background or even results of the mid-term examination are provided. Nevertheless, it is of paramount importance that any claims on the effectiveness of an approach should be grounded on empirically tested evidence (Deek & McHugh, 1998) in pedagogical practices.
Support from Learning Theory
If approaches are not grounded on empirical data, an established theory may serve as the foundation for the approaches. However, not many approaches have explicitly mentioned the use of any learning theory in its design. The risk of not basing the approach on established theory can be detrimental since the approach remains ad hoc and may not be generalized to other settings. As pointed out by Berglund (2002), the problem is, “Although valuable as a mean of sharing experiences between computer science educators, the results are…often hard to generalise, since they are not based on pedagogically sound theories of learning or carried out with sound methodological principles”.
Individualization
One of the foci of our curricula in the school education today is learner-centerness. It is our responsibility to provide such an environment for the needs of individuals. In terms of pedagogy, the usual strategy adopted is “one size fits all”. This results in weaker students learn well while stronger students are unchallenged (Lister & Leaney, 2003). It is argued that learning styles provide a vehicle through which individual differences are addressed. The literature has shown that learning styles do affect programming performance (Ross, Drysdale, & Schulz, 2001). It is thus possible to make use of learning style data to individualize pedagogy to bring about innovation in teaching.
Towards a Conceptual Framework
Learning to program is recognized as a cognitively demanding process in the literature. It involves expressing solutions to problems in terms of programming language syntax as well as understanding of how programs work in the computer. In the former case, Linn and Dalbey (1985) propose a chain of cognitive accomplishments for computer programming instruction consisting ofthree main stages: (1) single language features, (2) design skills, and (3) general problem-solving skills. Besides, Bayman and Mayer (1988) propose three interrelated types of programming knowledge necessary to understand the underlying complex processes involved in programming: syntactic, conceptual, and strategic. Such discussion indicates a developmental change from learning programming syntax to learning programming concepts in terms of programming knowledge. Recently, technology advancement has made computer programming more visually than before. This is achieved in one way by visual programming (Green, 1995). It points to a dimension in programming pedagogy in terms of programming representation.
In this article, an initial framework on programming pedagogy is suggested which attempts to conceptualise pedagogy along the two dimensions, namely, programming knowledge and programming representation. For the dimension of programming knowledge, the two poles are programming syntax and programming concept, which correspond to the developmental change in learning programming. For the dimension of programming representation, the two poles are textual representation and visual representation, which reflects the advancement of technology in programming presentation. Figure 1 shows a classification of aforementioned programming approaches under this framework. Structured programming is traditionally learned with focus on programming syntax in textual representation. As a result, it is considered as a more syntax-oriented and textual-based (i.e., syntax-textual pedagogy). Problem Solving, Software Development, Language Learning, and Learning Theory approaches are regarded as more concept-oriented and textual-based (i.e., concept-textual pedagogy) since they emphasise the mastery of problem solving skills. Mini-language and Sub-language approaches usually make use of visual metaphor to help beginners to start programming. In this sense, they focus more on concepts building through a visual programming representation (i.e., concept-visual pedagogy). However, we could not find any approach which is under syntax-visual pedagogy. With a trend towards user-friendliness and technology development, it is anticipated that there will be a gradual shift from the concept-textual pedagogy to concept-visual pedagogy in the future.
FUTURE TRENDS
Guzdial and Soloway (2002) advocate the use of authentic multimedia construction to engage students to learn programming. Jimenez-Peris, Pareja-Flores, Patino-Martinez and Velazquez-Iturbide (2000) foretell a day in a 2020 university, saying that, “current lab programming environments are truly educational, and they are highly visual and intuitive. They detect and accurately diagnose most errors…” From these observations, in the future, learning to program will be probably dominated by a visual and media-rich environment, and this is in agreement with our guess.
CONCLUSION
The fact that programming is difficult to novices is reported enormously in the literature. Pedagogical innovations have been suggested to address the issue. In this article, programming pedagogy is reviewed. Approaches of teaching programming are discussed and grouped under seven categories. Problems associated with these approaches are discussed. To conceptualise pedagogy, a theoretical framework consisting of the programming knowledge and programming representation dimensions is proposed. An attempt has been made to classify the approaches under this framework. While the approaches discussed are not meant to be exhaustive, it is hoped that this article may shed light on the discussion of programming pedagogy and arouse further exploration and research in programming education.
Figure 1. Classification of programming pedagogy
KEY TERMS
Computer Programming: Mainly consists of designing the underlying algorithm and representing that algorithm as a program.
Curriculum: Consists of four interacting components, namely, teaching objective, teaching material, teaching method, and assessment.
Novice Programmer: A computer programmer who is not experienced at programming.
Problem Solving: To solve, problem is to find a way where no way is known off-hand, to find a way out of a difficulty, to find a way around an obstacle, to attain a desired end that is not immediately attainable by appropriate means. The emphasis of problem solving in programming instruction focuses on the expression of solutions in terms of mathematical functions.
Programming Pedagogy: The study and theory of the methods and principles of teaching and learning computer programming. It refers to any instructional methods and strategies which are used to teach students introductory programming.
Textual Programming: The representation of programming processes is based on written texts.
Visual programming: The representation of programming processes is based on graphics and images. It allows the manipulation of visual information and provides support for visual interaction.
