4th International Conference on Principles and Practices ... - MADOC

• Students consume genericity when they first use collections
from the Java Collection Framework, which may be
relatively early on. Defining the element type of a
collection is quite straightforward once the concept of a
type is understood. Producing a generic class, on the other
hand, requires much more knowledge about genericity; this
can be taught much later.
We applied this principle in these and in several more situations
in SD1. We will now turn to this course in more detail.
4. TEACHING INTERFACES BEFORE
INHERITANCE
In this section we describe the structure of SD1 in as much detail
as is necessary to point out our objective: to demonstrate that
teaching interfaces before inheritance can be done
systematically.
We follow an Objects First approach in SD1, as described for
example in [2]. Using BlueJ [11], students work with objects from
day one. BlueJ is a free IDE tailored for teaching object-oriented
programming that we have been using in introductory
programming courses for several years now. Instances of classes
can be created interactively; any of their methods can be called
interactively and their states can be inspected easily. The classes
of a project are visible all the time in an interactive class diagram.
4.1 Interfaces Early
In their first programming tasks, students just create objects of
provided classes. They interact with these objects, calling the
public methods defined by the given classes. For our discussion,
the class editor’s ability to show two different views of a class
definition is an important feature of BlueJ: the implementation
and the interface of the class (generated on the fly using javadoc).
During preparation of the exercises, we save the class definitions
of the provided classes in interface view. When students want to
find out about the services a class offers, they just double-click on
the class symbol and the interface view is presented. Later,
students start to extend the given class definitions and switch to
the implementation view then.
While interactively exploring and extending the services of
provided classes in the first weeks, students get an intuitive
feeling for the interface of a class early on. During this time we
do not make the distinction between methods and operations, as
this would hinder more than help the learning process. The
vocabulary in use thus contains primarily the words class, object,
instance, method, and field. The field types of the classes in use
are primitive types only in the first four weeks.
In week 5 we explicitly introduce the concept of reference types.
We set reference types in relation to the primitive types and
explain the notion of a general type as described in section 3.3,
primarily to explain static type checking in Java.
4.2 Interfaces Next
In week 7 we introduce interfaces together with unit testing.
We explain that a black box test should just test the interface of a
class. We then show how they can use the Java mechanism
interface to explicitly describe the interface of a class. If a
test class is just using this interface it can be expected that
the test cases will treat the object at test really as a black box. In
the test class, any variable should be declared of the interface
type, not of the concrete class type. The object to test is passed in
as a constructor parameter, even this parameter can be of the
interface type. As BlueJ allows passing objects interactively, the
object to test can be created interactively and passed interactively
to a test class object.
This introduction of interfaces automatically leads to the
distinction of the static and the dynamic type of a variable. The
static type of the variables should be of the interface type, the
dynamic type is the concrete class type. This way, students
consume dynamic binding without the necessity to understand the
mechanics behind the scenes.
After writing the black box test class, we introduce JUnit as a
framework for better test support. Using JUnit, students also
consume inheritance (they passively inherit methods of the JUnit
class TestCase that they can use for assertions), but they need
not produce an inheritance relationship (provide an abstraction
that can be reused).
4.3 Collection Interfaces
The second half of the semester is arranged around a central
theme: collections of objects. Again we take a different approach
than most text books: we introduce two basic collection
interfaces of the Java Collection Framework (JCF), namely
Set and List, before we introduce arrays (see [20] for
supporting arguments for this approach). We explain the
interfaces and let the students consume these types (and their
implementations) to solve simple tasks with collections. At this
point we explicitly do not talk about the type hierarchy of the
JCF. As mentioned in section 3.5, students have to consume
genericity without a full introduction of the concept.
For the rest of the semester we “open the hood” of the collection
abstractions and show how lists can be implemented with linked
lists and “growing” arrays, and how sets can be implemented
efficiently with hashing. In the exercises, the students have to
build these implementations for simple (non-generic)
interfaces such as ShortList (for short lists in the sense
of Nick Hornby’s “High Fidelity”) and Vocabulary (a set of
strings for analyzing the corpus of a digital text). Arrays are
described as a (very necessary) low-level construct only that is
used to implement more user-friendly collections.
In summary, we use collection types as prime examples for type
abstraction (section 5.3), without mentioning the term explicitly.
4.4 Students Feedback
SD1 was very well received by the students. In the “official”
informal surveys conducted by the student union, the module got
excellent marks, especially for its clear structure (over 80% voted
“very good” or “good”). Students were quite aware of the fact that
a different path was being taken with respect to interfaces,
some were even excited about the novel approach. No student
complained about the fact that inheritance was not taught and no
student had problems with using interfaces the way we proposed.
5. ADVANCED TERMINOLOGY
The inheritance mechanisms in programming languages support
several inheritance concepts. For first year teaching, the most
important concepts are:
205