%!PS-Adobe-3.0

A Constructivist Approach to Teaching Object-Oriented Programming Said Hadjerrouit Department of Mathematics Agder College N-4604 Kristiansand, Norway Tel. (+47) 38 14 17 93 Said.Hadjerrouit@hia.no

ABSTRACT
Computer science education is drastically affected the object-oriented paradigm. This can be seen in the numerous new teachers being attracked to programming languages such as C++, and particularly Java. Object-orientation provides not simply a new way of pogramming, but a new of thinking about computing. To promote the object-oriented paradigm, a re-examination of the teaching practice is needed. This article describes a new teaching approach rooted in the constructivist epistemology for rethinking programming in a way that is more consistent with the object-oriented approach.

Keywords
Constructivism, Java, object-oriented programming

1. INTRODUCTION
This article describes a new teaching approach to programming motivated by principles found in the constructivist epistemology. The need for developing a new teaching method arose when we realized that the predominant model of instruction in computer science education - the objectivist model of learning - was inadequate for most students to learn object-oriented concepts, because it does not engage the mind appropriately to successfully tackle the challenges of the object-oriented approach. Learning the object-oriented paradigm is indeed difficult for most novice students, mostly because it is more abstract than the procedural approach. Moreover it requires new ways of thinking and more depth to grasp, particularly with regard to the analysis and design activities prior to program coding, and when the problems to be solved were different from those whose solution was explained previously. The constructivist view is more appropriate to deal with the pedagogical problems encountered in switching from the procedural approach to programming to the object-oriented paradigm, since it takes into account students' prior knowledge in programming and students' prior experiences in problem solving [5,6]. Moreover, constructivism offers a potentially powerful way to rethink the pedagogical practice at the introductory level by stressing the need for the learner to play an active role in constructing object-oriented knowledge. Constructivism has been successfully implemented in mathematics and science education [9,10]. It can be adopted to our field with slight modifications.

The remainder of this article is organized as follows. In section 2 we give an overview over the objectivist and the constructivist model of learning. In section 3 we reconceptualize object-oriented knowledge within the constructivist epistemology. In section 4 we outline a constructivist approach for learning object-oriented programming at the introductory level. Finally, some remarks on further work conclude the article.

2. PARADIGMS OF LEARNING
2.1 The Objectivist Model of Learning

Basically, computer science education relies on the objectivist model of learning which views learning as the passive transmission of knowledge from the teacher to the learner. This model does not suggest that prior knowledge, e.g. procedural programming, can affect current learning, e.g. object-oriented concepts, since its metaphor of mind is that of a blank page, a tabula rasa, waiting to be filled with knowledge [10]. Clearly, the objectivist model of learning does not engage the mind appropriately to go beyond inappropriate prior knowledge [4]. The result is, even after one year of instruction, a lack of conceptual understanding, bad programming habits and serious misconceptions about object-oriented program development. Programming is understood as an art rather than a discipline with principles which guide the development of readable, modular, extensible, and reusable objects [8]. This situation is, to some extent, the result of passive learning: listening to lectures, reading textbooks, and doing programming work without engaging the mind appropriately ito successfully tackle the object-oriented paradigm [5,8].

2.2 The Constructivist Model of Learning
In stark contrast to the objectivist view, the constructivist perspective regards learning less as the product of passive transmission than a process of active construction. Learning is an active process in which learners construct new knowledge based upon their prior knowledge. Consequently, a constructivist approach to learning needs to probe prior knowledge and evaluate whether it conflicts with the knowledge being taught. Similarly, a constructivist methodology needs to evaluate how the procedural model of programming conflicts with the object-oriented approach. If it does, new ways must be found of reconstructing the object-oriented concepts; otherwise there is no guarantee that the object-oriented approach will be adopted. The constructivist perspective is clearly divergent from the objectivist model of learning which presumes that knowledge can be put directly into the learner's head. Interested readers should consult [1,4,6,7,8,9,10,12] for more details. There are basic principles for designing a constructivist learning strategy for object-oriented programming.

Object-oriented concepts must be actively constructed by learners, not passively transmitted by teachers.
Students' prior knowledge, e.g. procedural programming, must be taken into account by the construction of object-oriented concepts.
In order to be useful for problem solving, object-oriented concepts must be related to each other.
The process of building interrelated object-oriented knowledge structures requires higher-order thinking skills.
Traditional modes of learning such as lectures should be replaced by a set of activities where the students are actively engaged in the concepts being constructed.
To get students actively involved in problem solving, the activities should focus around a set of realistic, intrinsically motivating problems.

3. A CONSTRUCTIVIST VIEW OF OBJECT-ORIENTED KNOWLEDGE
3.1 The Structure of Object-Oriented Knowledge
From a constructivist point of view, there are three strongly interrelated knowledge categories which are relevant for object-oriented programming:

Object-oriented concepts, that is abstraction, encapsulation, inheritance, polymorphism and dynamic binding. Producing students with a good understanding of the classical object-oriented software development is however not enough, since new object-oriented languages, such as Java, aspires to becoming a standard for the use of object-oriented components within the WWW, by incorporating objects in a form that is reusable, concurrent, interactive, and distributed.
Then, we need an object-oriented language for implementing object-oriented concepts, such as Java and C++. Today, Java is the most popular object-oriented language. It includes powerful means of implementation, such as Java Development Kit (JDK), the WWW, visual application builder tools, existing reusable components - JavaBeans - which can be adapted and extended to fit the requirements of new problems.
Finally, we need a variety of problem situations from which we derive problem-specific knowledge - that is the relevant features and the requirements of the problem in terms of object-oriented concepts.

To be useful for problem solving, these categories of knowledge need to be closely related to each other. This means that object-oriented concepts, means of implementation, and problem requirements must be integrated to knowledge structures which can be retrieved at any time [4].

3.2 Skills for Constructing Object-oriented Knowledge Structures
The constructivist view asserts the construction of useful knowledge structures necessitates higher-order thinking skills. This is consistent with research and the practical experiences of expert software designers. Insights from software engineers indicate that designers focus on the overall structure of the software system, that is on the general functions of the parts and how they interrelate with each other to form the whole. Moreover, the analysis of the problem domain and the design of a conceptual model are more central to the development of software than the code. This means that building interrelated knowledge structures requires thinking at a higher level than the code level, see [11]. Given this background, we can distinguish the following categories of higher-order thinking skills:.

Analysis skills, such as understanding, describing, refining, and representing problem situations using object-oriented concepts.
Formal reasoning skills, such as inductive and deductive reasoning, including modeling object-oriented systems.
Analogical thinking skills, such as comparing and contrasting, as well as recognizing similarities and differences between problem situations, programs, or models using object-oriented concepts
Design skills, such as structuring, integrating, reusing, and combining existing object-oriented components.
Reflexive, critical thinking skills, such as evaluating, explaining, and justifying the solution process.

Novice students use knowledge in ways very differently from experienced software designers. In contrast to experts, beginning students are usually not aware of the importance of higher-order reasoning processes. They focus on programming issues rather than on the conceptual aspects [15]. The result is, even after one year of instruction, a lack of conceptual understanding of the object-oriented paradigm and serious misconceptions about object-oriented program development. Programming is understood as an art rather than a discipline with principles which guide the development of readable, modular, extensible, and reusable objects [8]. In addition, students have a great deal of difficulty to solve new, but conceptually similar problems, because they cannot use object-oriented concepts to understand problem situations. This situation is, to some extent, the result of the objectivist model of learning: passive listening to lectures, reading textbooks, and programming without engaging the mind appropriately in understanding the object-oriented paradigm [5,8].

4. A CONSTRUCTIVIST APPROACH TO OBJECT-ORIENTED PROGRAMMING
The goal of a constructivist approach to object-oriented programming is to help each student to build useful knowledge structures that can be used for efficient problem solving. When knowledge is structured, conceptual understanding of problems is enhanced, design, and implementation ability improves, because object-oriented concepts may be used to understand problem situations, to design conceptual models, and to choose appropriate means of implementation. To be successful, a pedagogical approach motivated by constructivism needs to be organized around a set of activities where students are actively engaged in the knowledge being learned.

4.1 Characteristics of Activities
The goal of the activities is to motivate the students to construct useful knowledge structures in the course of problem solving. Each activity includes four integrated parts:

Firstly, the activity must refer to prior knowledge needed to do the activity. Likewise, substantial attention should be devoted to students' misconceptions, that is practices that directly conflict with the object-oriented approach.
Secondly, the activity must explicitly describe the new knowledge to be learned in terms of object-oriented concepts, including some suggestions as to how it can be constructed using higher-order thinking skills.
Then, the activity must rely on a realistic, intrinsically interesting problem situation that motivate the students to construct the object-oriented knowledge.
The final step consists of reflecting the solution process. This task is of primary importance for the learning process, since it helps the teacher to discover what and how the students have learned.

4.2 Examples of Activities
In this section we give an outline of some activities involving analysis, design, implementation, and evaluation processes. These activities are important for improving the ability to construct useful object-oriented knowledge structures.

Design conceptual models using existing solutions. This activity is based on the idea that solutions of problems in the past could be used to specify the requirements of a new problem. To be able to reuse existing solutions, students need analogical thinking skills to identify conceptually similar problems they have previously analysed. The solutions might be adapted, modified and extended to meet the problem requirements. Finally, the activity consists of designing a conceptual, object-oriented model on the basis of the information available.
Explore the class library for reusable code. This activity will allow to explore class libraries using object-oriented concepts. It is of primary importance for the implementation process. Java and similar languages provide sufficient flexibility to achieve this activity. Basically, objects in class libraries can be reused, and extended with slight modifications through inheritance. With reuse, students learn to incorporate existing software components - for example JavaBeans - , standard classes, and objects into the solutions of new problems. Existing code might be adapted and extended to fit new problems. To be efficient, reusable code should be stored and retrieved at any time.
Study experts' design solutions. Students can learn most effectively from following design practices of expert software designers. Good examples of software design should include a study approach with experts' solutions and a summary of experts' thinking process. Students can then model their solutions on experts' thought processes using higer-order thinking skills. Likewise, substantial attention should be devoted to well-designed code, since it is extremely important for students to be able to read, modify, and extend good examples of well-structured, object-oriented code [15].
Organize object-oriented knowledge in terms of similarities and differences. This activity will help students to structure object-oriented knowledge by continually making connections between previously taught knowledge and new knowledge. For instance, to build connections between simple and distributed objects, we must look backward to what we have previously learned about simple objects. This is followed by looking forward in terms of developing distributed objects. This method allows us to organize knowledge in terms of similarities and differences. Object-oriented concepts, models, or programs are compared («How are they alike?»), contrasted (« How are they different?»), and then reorganized to conceptually similar or different knowledge structures.
Develop alternative solutions. To increase the number of connections between object-oriented concepts and a variety of problem situations, it is important to use the concepts in different contexts. One way to do this is to develop multiple valid solutions for the same problem, for example solutions based on simple, distributed, and concurrent objects. By solving problems in more than one way, students learn to use object-oriented knowledge in different ways which enhances the links between solutions, problems, and concepts.
Reflect on the solution process. Most students do not have the skills needed to reflect on what they are doing. Usually, they focus on the product rather than on the solution process. They conceive a solution is just a program that works for them, rather than a program that is readable for others, modular, and extensible [8]. This activity helps students to reflect their solutions by relating object-oriented concepts to the problem situation they have studied. Therefore, students should be asked questions that probe for understanding of the concepts underlying the problems' solutions. This task will allow to discover students' misconceptions about programming and to correct them. It is clearly evident that without reflection, students will be largely unwilling to abondan their design and programming practices based on misconceptions, see [8].

5. CONCLUSIONS AND FURTHER WORK
In this article, we have presented a new teaching approach to programming motivated by principles found in the constructivist epistemology. We have come to this approach as we realized that the predominant model of instruction - the objectivist model of learning - was inadequate to successfully tackle the pedagogical problems encountered in switching from the procedural approach to the object-oriented paradigm. Although we have only been able to outline the new approach in broader terms, we are convinced that constructivism offers - by defining learning as an active process of construction - a potentially powerful way to rethink the pedagogical practice in computer science. We are now in the process of implementing the new approach by introducing constructivist ideas step by step. Developing a complete teaching strategy requires a long-term effort on several directions: we need to improve our understanding of students' prior knowledge, refine the program of activities, explore higher-order cognitive skills, develop better assessment and evaluation procedures, as well as material and teaching aids to support constructivist learning in computer science.

REFERENCES
[1] Ben-Ari, M. Constructivism in Computer Science. Proceedings of the 29th SIGCSE Technical Symposium on Computer Science Education, March 1998, 257-261.
[2] Berg, D.J., and Fritzinger, J.S. Advanced Techniques for Java Developers, John Wiley & Sons, New York 1998.
[3] Brauer, W. The New Paradigm of Informatics in: Mauer (ed.). New Results and New Trends in Computer Science, Springer-Verlag, 1991, 15-24.
[4] Floyd, C., et al. (eds.). Software Development and Reality Construction, Springer-Verlag, 1992, 86-100.
[5] Hadjerrouit, S. Teaching Java as First Programming Language: A Critical Evaluation. SIGCSE Bulletin, Volume 30, Number 2, June 1998, 43-47.
[6] Hadjerrouit. S. A Constructivist Approach for Integrating the Java Paradigm into the Undergraduate Curriculum. Proceedings of the 3th Annual Conference on ITiCSE, August 1998, 105-107.
[7] Hadjerrouit, S. Educational Impacts of the New Paradigm of Informatics.Proceedings of the Norwegian Annual Conference on Computer Science, Tapir 1998, pp. 185-194.
[8] Kafai, Y., and Resnick, M. (eds.). Constructionism in Practice: Designing, Thinking, and Learning in a Digital World, Lawrence Erlbaum Associates, New Jersey, 1996.
[9] Mereno-Seco, F., and Forcada, M.L. Learning Compiler Design as Research Activity. Computer Science Education 7, 73-98, 1996.
[10] Phye, G..D. (ed.). Handbook of Academic Learning: Construction of Knowledge, Academic Press, London 1997.
[11] Steffe, L.P., and Gale, J. (eds.). Constructivism in Education, Lawrence Erlbaum Associates, New Jersey 1995.
[12] Sims-Knight, J.E., and Upchurch, R.L. Teaching Object-Oriented Design Without Programming: A Progress Report. Computer Science Education 4, 135-156, 1993.
[13] Spivey, N. N. The Constructivist Metaphor: Reading, Writing, and the Making of Meaning, Academic Press, London 1997.
[14] Tewari, R., and Friedman, F. L. A Framework for Incorporating Object-Oriented Software Engineering in the Undergraduate Curriculum. Computer Science Education 4, 45-62, 1993.

[13] Stein, L.A. Interactive Programming: Revolutionizing Introductory Computer Science. ACM Computing Surveys, 28A(4), December 1996.
[14] Sun Microsystems. http://java.sun.com/

-----------------

Traditional modes of instruction based on passive learning are not adequate for the construction of useful knowledge.

Object-orientation is the common pattern of Java conceptual knowledge

Being able to develop solutions at this level becomes fundamental for paradigm shift.

From a constructivist position, there is no objective, fixed knowledge. This means that we do not apply predefined concepts, but we construct them based upon our prior knowledge. Secondly, we do not refer to fixed means of implementation. Instead the meaningful use of means is constructed in the course of problem solving. Finally, problem requirements are not given, but constructed to suit the situation in hand. Moreover,

The constructivist view is more adequate for learning new concepts.

This view of learning relies on the traditional scientific paradigm - often called rationalism or positivism - which assumes that scientific knowledge exits independently of the mind of the observer, and is therefore objective. Consequently, this model does not suggest that prior knowledge can affect current learning, since its metaphor of mind is that of a blank page, a tabula rasa, waiting to be filled with knowledge [10]. As a result, the objectivist model of learning does not engage the mind appropriately to reorganize knowledge into a useful system. Instead, it emphasizes mathematical problem solving and technical ideals detached from the characteristics of the learner [4].

There are basic principles for how to design a constructivist teaching and learning strategy. First, knowledge is actively constructed by learners, not passively transmitted by teachers. Second, learners construct new knowledg, e.g. objects, based upon their prior knowledge. Third, the learning process is more important than the result. Moreover, knowledge needs to be structured in order to be useful for problem solving. The process of building knowledge structures requires higher-order thinking skills. In addition, to get students actively involved in problem solving, learning should focus around a set of realistic, intrinsically motivating problems. Finally, traditional modes of instruction such as lectures should be replaced by a set of activities where learners are actively engaged in the knowledge being constructe

To develop a constructivist approach to programming, object-oriented knowledge must be reconceptualized within the constructivist epistemology.

Specify problem requirements using existing solutions. This activity is based on the idea that solutions of problems in the past could be used to specify the requirements of a new problem. To be able to reuse existing solutions, students need analogical thinking skills to identify conceptually similar problems they have previously analysed, and eventually adapt them to structure the problem being analysed.

Design conceptual models using existing solutions. This activity is similar to the previous one, but it involves design processes. Basically, students must be able to use analogical thinking skills to identify similarities beween the requirements of a new problem and the solutions of problems they have already designed. The solutions might be adapted, modified and extended to meet the problem requirements. Finally, the activity consists of designing a conceptual, object-oriented model on the basis of the information available.