Constructivism in Software Engineering
Sheryl Duggins, Ph.D. 1
Abstract
This paper explores the constructivist theory of teaching and learning which has its roots in cognitive psychology,
philosophy, learning theory, and education theory. A constructivist approach to teaching software engineering is
proposed and an initial set of pedagogical design elements are presented. This paper addresses “how-to-teach”
software engineering in a style that incorporates process in the way we teach in addition to what we teach.
Introduction
One of the many challenges facing software engineering educators is how to teach the subject matter in a way that
both does justice to the material and stimulates the students to learn. While there have been many papers written
about software engineering curriculum issues [1,2,3,4,5], and even more addressing specifically what body of
knowledge we should be teaching [6,7,8,9,10], very little has been written for the software engineering education
community to address the specifics of how we should teach. While we all generally agree that one fundamental idea
that is crucial to include in our curriculum is the topic of the role of process in software engineering, we typically
fail to incorporate the very fabric of process in the way we teach. The point here is that most of us still follow the
traditional model of teaching in which the teacher, being the knowledge holder, lectures to the students, who are
passively trying to receive and absorb as much knowledge from the teacher as they can. There are many problems
with this approach, most of which focus on the passive role of the student in the learning process. In examining the
software engineering curriculum from many universities, the good news is that most of us do have project-based
courses in which a significant portion of the course involves working in a team to solve some “real-world” problem.
That is definitely a step in the right direction. This paper will explore an approach to teaching software engineering
that has its roots in cognitive psychology, philosophy, learning theory, and education theory and will show the
reader how to take another step in the right direction. This paper will address “how-to-teach” software engineering
in a style that incorporates process in the way we teach in addition to what we teach.
Constructivist Theory
The education theory this approach is based on is called constructivism and it stems from the work done by several
theorists including Jean Piaget [11], Seymour Papert [12], Jerome Bruner [13,14], and John Dewey [15]. Education
courses are frequently designed to be “how-to-teach” courses, but very few software engineering (SwE) or computer
science (CS) professors, typically having been educated in Colleges of Engineering and not in Colleges of
1
Associate Professor
School of Computing and Software Engineering
Southern Polytechnic State University
Marietta, GA 30060
sduggins@spsu.edu
770-528-7401
2000 ASEE Southeast Section Conference
1
Education, have ever been exposed to this type of material. Consequently, SwE and CS professors learn how to
teach from all those years spent being a student. Generally, most university classes follow the typical “teacher as
lecturer” model, so it stands to reason that most of us teaching today would also be using this familiar technique.
In addition to referring to an educational philosophy, the term constructivism applies both to the underlying learning
theory, which has its foundations in research in cognitive psychology, as well as to epistemology, or the nature of
knowledge. This multi-disciplined approach suggests that the way educators teach should be based on how students
learn, which should be directly related to the nature of knowledge and meaning.
The basic ideas behind constructivism [13] focus on the students taking an active role in their own learning as they
“construct” their own knowledge by integrating the new information with pre-existing semantic constructs. Key to
this style of teaching and learning is the notion that the learning activity must be relevant and engaging to the
student. This approach centers on problem-solving and critical thinking skills which the student utilizes by applying
approaches based on their prior knowledge and experience to a new problem situation, and integrating those
approaches with new experiences and knowledge, to construct a new level of understanding.
The teacher is typically viewed as a facilitator or coach in the constructivist learning approach. That means the
teacher guides the student through the learning process by stimulating the student’s critical thinking skills and
providing learning situations, environments, skills, content, and tasks that are relevant and realistic and simulate
real-world contexts. The emphasis is on active knowledge construction rather than just passive, knowledge
reproduction. This knowledge construction is individual, but often occurs as a result of social experiences including
negotiation, collaboration, and authentic experiences. The role of teacher as facilitator does not preclude the teacher
from presenting new material in a formal class lecture; it just emphasizes the need to have the student actively
involved in applying the knowledge in a problem-solving situation.
Constructivist Theory Applied to Software Engineering
While this theory can obviously be applied in project-based software engineering courses, it can just as easily be
applied in all types of software engineering courses, even those that do not typically involve a group project. The
key to application of this approach is that the teacher must be willing to change his or her paradigm of teaching. As
we all know, that is no simple matter. Successfully applying the constructivist approach to teaching requires that we
view ourselves in a different light: as educators, we are co-learners in the process of education with our students.
Just as important is the change in what we consider valuable learning experiences, which requires us to change
preconceived notions about teaching and learning. We must relegate the importance of the memorization of facts
about our subject content as being less significant than the goal of students being able to use, or apply, the content as
they construct their own knowledge. Hence, the emphasis is on the process of active learning, and that process itself
is what we are ultimately teaching and evaluating.
For years, I have been teaching about the necessary paradigm shift when changing from structured software
development to object-oriented (OO) development. Many case-studies have addressed the efficacy of businesses
taking an evolutionary approach rather than a revolutionary approach to their adoption of OO technology. In this
paper, I am making a similar suggestion with respect to constructivism. The ideas being proposed here are not going
to be easily adopted in their entirety, and thus the reader is urged to ease into constructivism. Try to incorporate
these suggestions into your courses, and slowly adjust your teaching style as you become comfortable with the new
paradigm.
A Pedagogical Design for Teaching Software Engineering Theory
This section defines a pedagogical design appropriate for software engineering courses based on the constructivist
philosophy of teaching. In addition to identifying the design elements, the underlying theory addressed by each
2000 ASEE Southeast Section Conference
2
element is discussed. I propose including the following pedagogical elements in each of your software engineering
courses. It is not necessary to incorporate all of the elements at once; rather, it is suggested that you slowly integrate
them into your classroom as your learning environment evolves into a constructivist classroom. This educational
design has evolved in my software engineering classes over the last nine years. I have been successfully utilizing
the pedagogical design and have had very positive results.
The theoretical elements identified below are very familiar in the constructivist literature, and have been gathered
from all of the previously cited theorists as well as from the work of Jonassen [15] and Vygotsky [16]. The
application of the theory to Software Engineering, and the resulting ideas, are original.
1. The students work on at least one team project.
For project-based SwE classes, a team project is a major part of the course requirements, and the activities involve
team problem-solving on some portion of a software project. In advanced classes, this project involves the entire
SDLC. In other types of SwE classes, this team project may not be related to the development of a software
product, but may focus on the group investigating some topic. My suggestion here is to incorporate some type of
team project in every course because significant learning occurs in a group setting, and the nature of that learning
experience is authentic and unique for each individual. There are two theoretical ideas at work here: to embed
learning in a social experience and to put the student in a central role in mediating and controlling their own
learning. Social constructivist theory as purported by Dewey, Vygotsky, and Piaget emphasizes the importance of
the social context for cognitive development.
2. Each student is required to give at least one presentation to the class.
In the constructivist learning process, the student is responsible for their own learning. The point here is to
encourage ownership and voice in the learning process. Thus the professor is not seen as the only knowledge
source; and the students gain an appreciation for multiple perspectives. Additionally, another aspect of
constructivism is to encourage the use of multiple modes of representation. Classroom presentations provide the
student with a unique learning opportunity allowing them to use alternative modes and contexts.
3. The curricular emphasis is always on application of the material in a problem-solving context.
Here problem-solving, higher-order thinking skills and deep understanding are emphasized. The constructivist
approach challenges students to think beyond merely reproducing factual responses, and encourages independent
thinking. Students are asked to analyze, summarize, and defend their solutions. This can be incorporated into SwE
instructional design by solidifying concepts, methods, techniques, or skills by introducing short problems into the
lesson that provide the learners with an opportunity to apply the process in a problem-solving context.
4. Provide frequent classroom activities in which the students get into small groups and “present” the results of
their group efforts to the class.
The idea is that collaborative and cooperative learning are used to expose the learner to alternative viewpoints. This
is a direct application of Bruner and Dewey’s theories which state that learning is an active process in which the
student constructs knowledge; that learning in not the passive acceptance of knowledge, but rather that the learner
needs to do something. Group discussion helps students reinforce their ideas and both presenting what they think
and hearing other students’ viewpoints allows students to challenge hypotheses.
5. Students should be provided the opportunity for apprenticeship learning in stages that have an increasing
complexity of tasks, skills and knowledge acquisition.
Apprenticeship learning means that while they learn by doing, they are also becoming more proficient as they learn,
and able to proceed to more complex tasks. There are many possible applications of this educational design element
in software engineering courses. At many varied points in SwE curriculum the concepts of process and iterative
development are relevant. As an example, I developed an analysis and design project that is done in five stages,
2000 ASEE Southeast Section Conference
3
each of which builds upon the previous work; and is very typical of what our SwE students will actually be doing in
industry.
6. Students should be given a pretest assessment that is used as a basis for structuring course curriculum.
The basic idea is that an initial student assessment of their prior knowledge should be used as a basis for diagnostic
teaching to remedy prior deficiencies and misconceptions. As the learner constructs new knowledge, they must
integrate the new information with existing cognitive structures. Thus the educator must be able to translate the
information into a format appropriate to the students’ current state of understanding [Bru66]. This requires
diagnostic teaching and is not possible without an initial student assessment.
7. Use student errors as a mechanism to provide feedback on their understanding.
The process-oriented nature of software engineering facilitates this element. In my SwE courses I frequently apply
the concept of “Mastery Learning” which means that I evaluate their work, and allow them to make corrections
(i.e., to apply my feedback) and then resubmit the work without any grade penalty. The theory behind this approach
focuses on the mastery of the concept rather than on getting it correct the first time. Thus, this very process-oriented
pedagogical approach fits in very nicely with the subject matter content. This iterative process can continue many
times, as the student takes responsibility for their own learning and their own grade.
8. Learning is assessed through performance-based projects rather than just through traditional testing.
I evaluate the students’ learning on these projects in two ways: I assess the product they deliver, and I allow them to
evaluate themselves and their teammates. This is to motivate them to see evaluation as a self-analysis tool and to
make them aware that they are responsible for their own learning. I use the team assessments as a factor in my
overall project evaluation.
Summary and Conclusion
Of the many challenges facing software engineering educators, how to teach the subject matter so as to optimally
stimulate the students to learn, is typically left up to the individual professor, with little guidance given by the
software engineering education community. This paper explored the constructivist theory of teaching and learning,
a multifaceted theory with roots in cognitive psychology, philosophy, learning theory, and education. A
constructivist approach to teaching software engineering was proposed and an initial set of pedagogical design
elements were presented. This paper presented “how-to-teach” software engineering in a style that incorporates
process in the way we teach in addition to what we teach.
References
[1] Ardis, Mark and Ford, Gary (1989) “SEI Report on Graduate Software Engineering Education” in Proceedings
of the Software Engineering Education Conference, edited by Gibbs, N., July 1989, Springer-Verlag.
[2] Freeman, Peter, Wasserman, A.I., and Fairley, R. E., (1976) “Essential Elements of Software Engineering
Education”, in Proceedings of the 2nd International Conference on Software Engineering, pp. 116-122.
[3] Freeman, Peter (1987) “Essential Elements of Software Engineering Education Revisited.” IEEE Transactions
on Software Engineering, SE-13, pp. 1143-1148.
[4] Duggins, Sheryl (2001) “Curriculum Impact of the Maturing Software Engineering Profession”, in Proceedings
of the 2001 American Society for Engineering Education Southeast Section Conference.
[5] Thomas, Barbara and Duggins, Sheryl (2000) “The Evolutionary Changes of Undergraduate Software
Engineering Curriculum”, in Proceedings of the 2000 American Society for Engineering Education Southeast
Section Conference.
2000 ASEE Southeast Section Conference
4
[6] Bourque, P., Dupuis, R., Abran, A., Moore, J., Tripp, L., & Frailey, D. (Jan. 19, 1999) Approved Baseline for a
List of Knowledge Areas for the Stone Man Version of the Guide to the Software Engineering Body of
Knowledge, http://www.swebok.org/
[7] Bourque, P., Dupuis, R., Abran, A., Moore, J. W., & Tripp, L. (November/December 1999) “The Guide to the
Software Engineering Body of Knowledge”, IEEE Software, vol 16, pp.35-44.
[8] Dupuis, R., Bourque, P., Abran, A., Moore, J. W., & Tripp, L. (March 26, 1999) A Baseline for a list of Related
Disciplines for the Stone Man Version of the Guide to the Software Engineering Body of Knowledge,
http://www.swebok.org/
[9] Notkin, D., Gorlick, M., & Shaw, M. (May 2000) An Assessment of Software Engineering Body of Knowledge
Efforts.
[10] Guide to the Software Engineering Body of Knowledge – A Stone Man Version (Version 0.6) SWEBOK
February 2000. http://www.swebok.org/documents/stoneman06/
[11] Piaget, Jean (1968) The Psychology of Intelligence, Littlefield, Adams.
[12] Papert, Seymour (1991) Constructionism: Research Reports and Essays, 1985-1990, Ablex.
[13] Bruner, Jerome (1960) The Process of Education, Harvard University Press.
[14] Bruner, Jerome (1966) Toward a Theory of Instruction, Belknap Press of Harvard University.
[15] Jonassen, D. (1994) “Thinking Technology”, in Educational Technology, 34(4), 34-37.
[16] Vygotsky, Lev (1978), Mind in Society: The Development of Higher Psychological Processes, Harvard
University Press.
2000 ASEE Southeast Section Conference
5
Sheryl L. Duggins
Sheryl Duggins is an associate professor in the Computer Science department of Southern Polytechnic State
University in Marietta, Georgia. She has served as the Graduate Coordinator for Software Engineering and was
integral in developing the Master of Science in Software Engineering degree. She has written numerous papers in
her areas of interest, which include object-oriented analysis and design, software engineering, formal specification
methods, and software engineering education. She obtained her Ph.D. degree in Computer Science from the
University of Florida in 1991. She also holds an MS degree in Computer Science and a BS degree in Mathematics
and Education, both from the University of Missouri. Before coming to Southern Polytechnic, she taught at the
University of Florida and the University of Missouri.
2000 ASEE Southeast Section Conference
6