SEKE 2012 Proceedings - Knowledge Systems Institute

epository to view the Java classes, then dragging and
dropping these classes onto a diagram canvas. Most
students chose Amateras because they found it extremely
easy. This is not surprising, as dragging from a
list onto a canvas produces the class, and the tool automatically
provides associations such as inheritance.
The diagram produced by the tool was visually appealing.
This experience suggests that the assignment
should ask more than an intelligently arranged display
of classes. For example, the students may be asked to
comment upon class containment and specialization hierarchies,
or to search for implementations of patterns
such as the model-view-controller [12].
The next reverse engineering assignment involved
drawing sequence diagrams for specifying requirements.
The students were expected to describe how
a planned modification of their software would be implemented
with communicating classes. Both Papyrus
and Amateras provided the ability to draw sequence
diagrams from dragging classes and manually entering
messages. The set up for Amateras is simple. One
places the jar files in a directory within the structure
for Eclipse, starts Eclipse, and finds the capability in
place. Papyrus was even easier to install, following the
normal Eclipse procedure to install new software.
The last assignment involved extracting dynamic sequence
diagrams from the code. Diver, the chosen tool,
posed several problems, although it was tested on two
operating systems (Windows/XP SP3 and Vista) and
on all twenty course projects. Moreover, the test of
the installation on laboratory computers, which were
Windows 7, had proceeded far enough to watch the
collection of events. This testing, however, was not
sufficient and a failure mode surfaced where the events
were collected but not being saved. Availability of the
source code was helpful in debugging, and we discovered
where the files were being saved from two working
installations. We first conjectured that a needed writeprivilege
was absent, however, that was not the case.
We then contacted the developers at University of
Victoria, who were very helpful. Simultaneously, we investigated
the problem in house, in coordination with
the course staff and the staff responsible for maintaining
laboratory computers; the latter finally resolved the
issue. Most students could now generate and record
sequence diagrams. On a subset of the projects, a second
difficulty manifested where the ability to restrict
the tracing events to modules did not seem to work,
though this might be due to a lack of understanding
about what is required for this function. For this subset
of projects, students collected events that were generic
to the Java libraries. They did not see sequences of
calls between top-level objects in their projects.
4.2 Students’ Reactions
The students were exposed to one configuration
management and three reverse engineering tools. They
successfully reverse engineered their projects using
these tools, though with different degrees of support.
They became able, during the course, to express themselves
at this level of abstraction.
The students were delighted to learn the value of
sequence diagrams in understanding their code, and
reported that they wished they had learned about dynamic
analysis earlier. The initial resistance, showed
by some students, dissipated quickly, after they had the
opportunity to study the sequence diagrams produced
by the tool. Some students found the notation (object
instance, timeline, lifeline) in sequence diagrams sufficiently
unintuitive to recognize it right away. Thus,
each student team was given a brief tutorial to the sequence
diagram drawing tool. The tutorial also demonstrated
how constructors or how object construction
appeared on the diagram. Overall, the students enjoyed
sequence diagrams more than class diagrams,
probably because they had not seen this diagram before,
and they became involved with annotating the
messages with the note tool. By comparison, the class
diagrams gave them almost no creative activity.
Retrospectively, we felt that the students would have
better appreciated the value of sequence diagrams if
they had extracted these before drawing one for their
planned enhancement. This extraction may have produced
a detailed understanding of the code, and led to
more meaningful and interesting enhancements. Although
the assignments were handed in this order,
the time consuming difficulties encountered with Diver
forced us to flip their series of completion.
5 Lessons Learned
In this section, we summarize the lessons learned
from the exercise of selecting, evaluating and experimenting
with open source tools to teach SE.
• Installation and set up: It took excessive time
to install the set of tools that ultimately worked together
to provide a laboratory environment. Tool
chains, where each tool complies with the interfaces
of its neighbors, may lack documentation
about data transformations, and hence, may require
cumbersome trial and error.
• Functions and capabilities: The definitions of
terms may not be consistent and uniform. Thus,
although a given tool promises a particular function,
its specific implementation may be different.
165