Position paper for OOPSLA '96 workshop
"Teaching and Learning Object Design in the First Academic Year"
In order to properly teach object design in the first course covering
that topic, a complete introduction to the entire object-oriented paradigm
is necessary for a proper understanding of the object methodology. Such
an introduction should include an overview of how the object-oriented paradigm
provides an appropriate means for real-world problem modeling; a demonstration
of how the paradigm can be used to solve large-scale problems; at least
one means of expressing the paradigm, and in describing objects, that is
not solely-text based; a focus on the reuse aspects of the paradigm; and
practice in how the paradigm can be used for within software design and
implementation teams.
Included in the discussion of describing objects is BACCII++, an iconic programming environment developed at Texas Tech, which contains the facilities for the creation and maintenance of objects. A complete set of course materials for the use of BACCII++ in teaching first-year students was developed under an NSF grant. An experiment also run under that grant, addressing the question "Can icon-based programming languages be used to teach object-oriented programming concepts to undergraduate students more effectively than text-based languages?", and found that students using BACCII++ performed significantly better than those students who did not.
My interest in the object-oriented paradigm as from the point-of-view
of a computer science and software engineering educator at both the undergraduate
and graduate levels. I teach undergraduate courses in data structures/introduction
to software engineering (to first-year students), concepts of programming
languages and software engineering (to juniors) and senior project design
and implementation, as well as graduate courses in software engineering
and object-oriented systems development; all of these courses involve the
use of the object-oriented paradigm.
My interest in teaching and learning of object design also stems from educational research in the area. Currently, I have two educational grants, one which involves using iconic programming environments to teach both the procedural and object-oriented paradigms in first-year programming courses (see the footnote given at the beginning of the paper); the second involves using Ada 95 as the central language in a Concepts of Programming Languages course., including using that language in the portion of the course devoted to the study of object-oriented languages.
The object-oriented paradigm has gradually taken its place at the forefront of design methodologies over the last several years. Therefore, inclusion of this paradigm in the first year of a computer science curriculum is essential.
However, many current textbooks for first-year courses which introduce the object-oriented methodology only focus on certain aspects of the paradigm, thereby giving the student an incomplete introduction which may inhibit a proper understanding of the paradigm, even if the missing pieces are provided in later courses. Therefore, a course which introduces the object-oriented paradigm must do so by providing a complete overview of the methodology.
In order to properly learn how to design objects, each of the topics noted below should be covered in the first course covering the object-oriented paradigm. At Texas Tech, this first course is Computer Science (C S) 2463 (Fundamentals of Computer Science II), a course in data structures, object-oriented programming and (introduction to) software engineering taught in the second semester of the first year to computer science majors.
An introduction to the object-oriented paradigm should include the following:
A. An overview of how the object-oriented paradigm provides an appropriate means for modeling most real-world problems. Most people view the world as a series of objects interacting with other, and conceptualize using their minds accordingly. This is what makes the object-oriented paradigm ideal for performing real-world problem solving. When introducing the object-oriented methodology to students, I always start with model real-world situations using the paradigm independent of any computer software that might be written. Most of the students quickly pick up on the fact that this is a natural modeling technique.
Individual objects can also be discussed in the same manner. Taking
a real-world object such as a chair or a person, the student can be introduced
to the concepts of attributes, services, and message passing. The need
for inheritance in the methodology can be demonstrated, for instance, through
the use of biological classification schema.
B. A demonstration of how the paradigm can be used to solve large-scale problems. It is then only a short leap to discuss how the software design for a large-scale problem can be modeled using the object-oriented paradigm. Several such problems can be found in books on object-oriented analysis and design; however, they are usually absent in first-year textbook which include coverage of the same topic. The student gains a better understanding of the paradigm through such large-scale examples, even if they are not covered in the detail that would be provided in later courses.
C. At least one means of expressing the paradigm, and in describing objects, that is not solely text-based, preferably using CASE tools. Many noted researchers (e.g. Glinert [4] and Scanlan [5]) have empirically established the cognitive advantage which graphical methodologies provide over textual ones. Such methodologies allow for learning using both sides of the brain. Research undertaken by the author, along with Ben A. Calloni, resulted in development a Windows-based iconic programming environment named BACCII. This environment was originally created for the teaching of procedural programming; several experiments using BACCII in a CS1 course have shown a significant increase in learning and comprehension [1,2,3].
More recently, work on adding object-oriented extensions to BACCII for use in the CS2 course was undertaken, resulting in BACCII++. Students design their programs (including objects) in BACCII++, using icons, and then generate source code in C++. An example of how objects are iconically displayed is the class icon (Figure 1); more examples can be found in [1,2].
Figure 1. A class icon.
CS2 course materials developed for BACCII++ were tested in the spring
of 1996. Each course had closed laboratories, with each lab section having
no more than 25 students. Half of the students would used on BACCII++,
while the other half was a control group using only C++. Statistically
significant differences were found favoring BACCII++ on the following criteria:
programming assignments, exams (which were the same for all students, and
covered only C++) and final course average [2].
D. A focus on the reuse aspects of the object-oriented paradigm. Showing the benefits of reuse is covered fairly well in current first-year courses; however, the student is rarely shown how to develop new classes using existing ones, except through simple inheritance schemes. More complex class design employing reuse, such as creating a new abstract class from an existing class, in order to provide inheritance to a new class, is rarely done in the first year. This is something that once again can be covered using class design examples from object-oriented analysis and design texts.
E. Practice in how the paradigm can be used within software design teams. Students in C S 2463 at Tech do their final projects in teams of four or five using CRC cards and BACCII++. (In the spring of 1996, it was a simulating an Internet-style electronic mail system.) In this manner, the students learn about the advantage of object decomposition techniques, and contracting for services from the designers of other classes within the team.
Currently, most first-year courses which study the design of objects are primarily centered on other topics such as data structures. In the future, courses to meet the future needs must be developed with the object-oriented paradigm as the focal point. In that way, object design can be properly taught from the beginning of the curriculum.
As mentioned above in section C, it has been experimentally demonstrated that the use of BACCII++ to design classes and objects implemented in C++ allows for the significantly better learning of CS2 topics. As regarding the other points listed above, no experiments have been run at Texas Tech; however, anecdotal data suggests that using the method above allows for a significantly better understanding of all aspects of the object-oriented paradigm, including object design, than is provided in a standard CS2 text (or, for that matter, in an object-based CS1 book).
[1] Bagert, Donald J.; Calloni, Ben A.; and Haiduk, H.
Paul. Iconic vs. text-based programming in the introductory programming
sequence. Proceedings of the ASEE Annual Conference and Exposition,
23-26 June 1996, Washington, DC (CD-ROM proceedings).
[2] Bagert, Donald J.; Calloni, Ben A.; and Haiduk, H. Paul. Using BACCII++ courseware in the entire first-year programming sequence. In preparation for submission to the 1997 SIGCSE Technical Symposium on Computer Science Education.
[3] Calloni, Ben A. and Bagert, Donald J.. Iconic programming
in BACCII vs. textual programming: which is a better learning environment?
Proceedings of the 25th SIGCSE Technical Symposium on Computer Science
Education, Phoenix AZ, 10-11 March 1994, pp. 188-192.
[4] Glinert E. and Tanimoto S. Pict: An interactive graphical programming environment. IEEE Computer, 17, 11 (November 1984), pp. 7-25.
[5] Scanlan, David. Structured flowcharts outperform pseudocode:
an experimental comparison, IEEE Software, Vol 6, No 5, Sept. 1989, pp.
28-36.
Donald Joseph Bagert, Jr. taught his first course as a teaching assistant in 1978, and has been a computer science faculty member various universities since 1979. He is currently a tenured Associate Professor of Computer Science at Texas Tech University. Dr. Bagert's research primarily focuses on object-oriented systems and iconic programming.
Dr. Bagert has either presented a paper or moderated a panel at several
Computer Science Education Symposiums starting in 1988. In all, he has
had published over thirty papers in the area of computer science education,
and has also presented papers at the Conference on Software Engineering
Education, ASEE/IEEE Frontiers in Education Conference, and
the ASEE Annual Conference, among other places. He has also participated
in educational research workshops at the International Conference on
Software Engineering, and the National Educational Computing Conference,
as well as (non-educational) OOPSLA workshops. He is also currently
the Principal Investigator for two education-related grants: one for the
National Science Foundation, and the other for the Defense Information
Systems Agency (DISA).
Dr. Bagert has taught undergraduate and graduate object-oriented related courses continuously since 1988, for both the Computer Science and the Master of Science in Systems Engineering programs at Texas Tech. He has received the President's Excellence in Teaching Award, the highest teaching award given at Texas Tech University (1995-96), and the Halliburton Award for Teaching Excellence from the Texas Tech College of Engineering (1994-95).