I have used well known active learning techniques to teach Object-Oriented ideas in a 10-week Comparison of Programming Languages class. This is part of the Refashioning Object-Oriented Technology Teaching (ROOT) Project in the Computer Science Department. I have evidence that the students learned how to do Object-Oriented Analysis and Design.
California State University San Bernardino (CSUSB) has a diverse and economically challenged population of students taking bachelor and master level degrees. The Computer Science department accepted its first students in 1983. It has a course on the concepts of programming languages (CS320). Computer Science majors take it after completing the first two quarters of programming. Nearly all students already know C++ and how to draw simple UML diagrams. However, they do not use aggregation and inheritance correctly. They have not analyzed a complex problem, proposed an Object-Oriented solution, and had the result critiqued by an expert. They have met not used any design patterns.
The CS320 Languages class [ Botting98 ] covers a variety of programming paradigms. The goal was to help students to understand computer language issues and introduce them to a variety of syntax and semantics plus various metalanguages. CS320 includes laboratory work in HTML, C++, Prolog, LISP and Java. The text is Sebesta. Sebesta's book does have a good chapter on Object-Oriented languages. It does not use the UML or objects otherwise however.
I introduced the Object-Oriented Analysis and Design (OOA/D) using the Unified Modeling Language (UML) into the course in the spring quarter of 1998. This was part of the Refashioning Object-Oriented Technology Teaching (ROOT) Project. This was done by the Department of Computer Science, California State University at San Bernardino, and Rational Software through the Software Engineering Education (SEED) Partnership in Fall 97. The ROOT Project integrated an Object-Oriented analysis and design (OOA/D) methodology in the CS curriculum using the Unified Modeling Language (UML). Instead of compressing the teaching of an OOA/D methodology in the traditional CS 1 and CS 2 courses, we integrated OOA/D in five lower and upper division courses. By teaching the OOA/D methodology in increments, the students are not overwhelmed in learning the OOA/D methodology.
The new syllabus reduced the time spent on Prolog and Logic Programming to make room for the new material. An analysis and design project was added. As detailed elsewhere [ Botting99 ] OOA/D and the UML fitted in as a way to describe the semantic structure of languages.
I adopted an active learning ideas from the British Civil Service training methods, M. L. Johnson Abercrombie's work[ Abercrombie ], training with London University's Education Department [ Bligh72 ], and Donald Mass's techniques. I choose these based on thirty years teaching as the only way I knew for the students to master all the material the department had assigned to the class.
Assigned Work: I require all students to study the set part of the text before class. It must be complete at the start of class. They must submit a few answers to the review questions on the assigned part of the text or handout. This assesses their preparedness for each class. It affects their final grade. No time is spent in class going over the text.
Class Work: Most of the class time was spent with the students working. I start by handing out a sheet with a set of exercises and test-bank questions, and make some short administrative announcements. Note, if this is available before class students prepare less. I then return graded work and set an exercise. Students work on an exercise from the handout while I hand them their work by name. This helps me learn their names.
During the class I set an exercise and invite questions. I ask the class to see how many people know the answer already. If the knowledge is relevant and missing then I may provide a short lecture on the topic. Students do an exercise alone and then share their work in pairs. Pairs often share their work with other pairs -- in groups of four. These groups are called Buzz groups. I walk around and comment on the visible (and audible) work being done. Answers would be presented to the class by students, pairs, or groups. I call the above: think-pair-square-share.
Sometimes I use a technique from the British Civil Service College. I call it the art gallery. This is very good for teaching analysis and design methods. I use it with diagrams or small amounts of text. Each group draws their solution on chalkboards. Because four students are in each group and (typically) thirty-two students in the class this means only eight pieces will be drawn. Forcing the students to think about these solutions is important. I provoke comments from the class in a nonthreatening and impersonal way. Nobody owns the errors on the boards. They do not cost points. However, I clearly label mistakes as mistakes and point out the risks of making them later. I hand out model answers for exercises if they could not figure them out by going back to the book. Finally I hand out a description of the preparation for the next class. I also distribute extra materials that supplement the book. These include a description of OOA/D using class diagrams in the UML and mini-manuals for half-a-dozen languages.
Training given by Donald Maas has shaped the actual interaction between myself and the students [see Maas below ]. These are easier to demonstrate than write about. Many involve asking questions, then some thinking, and finally visible action. The essential pattern is input-covert action-overt action-feedback. It asks the teacher to provide new data, for the students to think about it, for the students to be questioned, and for them to have the work reviewed. Donald Maas teaches some useful ways to respond to answers. An example is when a student gives a good answer to the wrong question. For example, suppose Jo says "Use static function to get polymorphism in C++. "Then I am likely to respond "Static functions show class-wide scope in C++. Pat! What do we use to get polymorphism?" After any answer I can paraphrase the answer in a neutral tone and then ask someone else in the class if they agree with it. Perhaps I might ask the whole class to signal what they think: "thumbs up or thumbs down?" Sometimes, I take a vote. Once the students have thought about it I tell them my answer.
Notice that the details are improvised. They depend on how the students react. This kind of teaching needs extra preparation, a relaxed attitude, confidence, trust in the students, and the knowledge to give an accurate answer to any question that they ask. No two classes have ever gone the same way. It is the antithesis of a boring lecture -- for both the students and the teacher.
Laboratory Work: Each student assembles a WWW site with links to examples of diagrams, code and applets. However, most of this work does not involve teaching object-orientation. One laboratory sets a series of experiments up using a remotely accessible Rational Rose server and a free Linux diagramming tool (Dia). Only about half-a-dozen of the 100 or more experiments demonstrate object-oriented ideas such as polymorphism. However, we cover both C++ and Java in the lab work.
Project Work: In the project students worked in teams. I gave them a small and defective language description using an extended BNF and informal semantics. They first studied the language description and prepared a list of defects that they would fix in a redesign of the language. They then submitted a draft improved BNF+UML description reviewed and graded by the instructor. This step allowed the instructor to correct some gross misunderstandings of the UML. At the end of the class students first present the syntax of their improved language and then the UML semantics.
In the early part of the project students often made the following errors when using the UML:
In response to these, I prepared special handouts on these errors. It stresses the use of polymorphism and covers the Composite pattern that is ubiquitous in programming languages. In later sections they did not make these errors as often.
I have taught the new version of the course half-a-dozen times. In five of these it had the same instructor, similar students, and an almost identical syllabus. Between twenty and thirty-five students have taken each section. In these classes all but one team produced an understandable diagram of the design of a programming language using the UML. The one complete failure was a team of one student who had problems in the class as a whole. Even this student's work was an adequate first step toward an Object-Oriented compiler or interpreter for a small language. Two weaker projects came from teams where a team member had been forced by job pressures to let his or her team down.
In most classes the students take advantage of the project presentations at the end the term to express their creativity. These are also a strong form of feedback to the instructor. There are normally well drawn diagrams using PowerPoint, overhead transparencies, and the blackboard. We have had a Blair Witch project on video, a special edition of the Gerry Springer show (with me as the victim), a super-hero comic with myself as villain, an infomercial, a set of video out-takes, and a perfect parody of my active-learning style. The students feel that I ask them to do too much, perhaps.
In the second to last weeks of most sections, students submitted the CSUSB standard Student Evaluation of Teaching Effectiveness (SETE) forms.The SETE forms contain 10 scores on a 4-point scale: Poor=0, Fair, Good, Excellent=4. The scores in all instructors classes are typical of the CSUSB College of Natural Science: 1% Poor, 7% Fair and 83% either "Good" or "Excellent." The scores on the first two sections were better with 92% Good+Excellent scores. There was no significant difference between the two courses. In the last section all but one score were about half of a standard deviation above the average for the College of Natural Science. One was one-tenth of standard deviation below. The UML did not lower the students opinions of this teacher's effectiveness.
The students can provide anonymous opinions via the World Wide Web in their last laboratory. Many did this in the first two classes. This showed that the students felt that the instructor initially emphasized the UML too much. The consequences seem to appear in the student's knowledge of the UML in the final examination. I analyzed a sample of fifteen final examination papers in the first two courses to see how well they grasped the UML and objects. In both exams, students had to recall how they expressed the semantics in their project. In the first course 60% did this correctly but in the second course only 20% did so correctly. In both exams, I asked students to express the structure of a control statement that I had shown them in handouts and class work. In the first course 50% did this correctly, but in the second only 33% did it correctly. In a third question, they asked students to express the idea that one class implemented an abstract class. In the first class 20% did this correctly, but in the second class none(0%) did it correctly. In summary, when the students felt I pushed them to learn the UML then they learned it better.
After two years of the ROOT Project, other teachers observed a marked improvement on students understanding of the OO paradigm when they apply the OOA/D methodology to programming projects in their senior-level computer science courses. We have traced the evolution in Concepcion98, ConcepcionEtal99, ConcepcionLeachKnight00, and ConcepcionBottingScroggins00.
Active learning lets the UML and OOA/D be taught as an integral part of a traditional "Concepts of Programming Language" class however the instructor has to emphasize and "push" the UML for students to master it. Students learn use Object-Oriented analysis and Design. However, the various forms of feedback from students show that many feel overworked or under pressure in this class. This may be the result of the particular instructor driven form of active learning that I used. When I am a student in such classes I dislike being disturbed from my habitual way of learning.
I cannot prove that active learning techniques made it possible. To do this I would have to experiment by omitting it. Luckily, the educationalists [ for example: Abercrombie, Bligh72, Bligh98, Maas, . . . ] already have the evidence for the value of active learning. My task is to teach upcoming computer professionals in the most effective ways of those I have learned in thirty years of computer science teaching.
These kinds of active learning work for me. They require the teacher to exude a firm yet friendly persona in class. I hope that they will also work for you.