SEKE 2012 Proceedings - Knowledge Systems Institute

Evaluating Open Source Reverse Engineering Tools
for Teaching Software Engineering
Swapna S. Gokhale, Thérèse Smith, and Robert McCartney
Department of Computer Science & Engineering
University of Connecticut, Storrs, CT 06269-2155
E-mail: {ssg,tms08012,robert}@engr.uconn.edu
Abstract
This paper reports our experiences and lessons
in the evaluation of open source, reverse engineering
tools to teach Software Engineering (SE). The
chosen tools were expected to meet a dual objective,
namely: (i) teach students software comprehension,
maintenance and evolutions skills; and (ii) train
them in modern SE tools. A majority of the tools
were disappointing because they did not deliver their
promised functionality. Moreover, the tool that was
ultimately selected because it appeared to function as
stated, posed unexpected problems. We summarize our
lessons, which we hope will inform others who wish to
undertake a similar exercise.
Keywords
Software Engineering Education, Tools, Reverse Engineering
1 Introduction and Motivation
The software industry has witnessed phenomenal
growth over the past two decades. Starting from its
humble beginnings in the 1950s [17], today it is worth
more than $233 billion with a projected annual growth
rate of 17% [23]. This dramatic explosion has created
an extensive need for skilled and talented software engineers.
To respond to this need, most educational
institutions now include Software Engineering (SE) as
a mandatory course in their computing curriculum.
The two key realities of today’s software development
environment include: (a) multiple implementation
technologies; and (b) the need for maintenance
over extended lifetimes [28]. As a result, students hoping
to work as software engineers can expect to maintain
and evolve large, complex legacy software. Therefore,
one of the primary objectives of the SE course
should be to teach students how to comprehend and
evolve existing code. Development of several subsidiary
supporting competencies is implied. For example, the
students should be able to: (i) extract design decisions
and rationale from the code in a top-down, organized
manner using abstractions and tools; (ii) distinguish
between well- and poorly-specified requirements, and
especially identify those that will be difficult to implement
given the structure and organization of the existing
code base; and (iii) produce documentation of good
quality explaining the design rationale.
The software industry commonly uses various tools
to perform software development activities. Some of
these tools improve efficiency and quality of management
and housekeeping tasks; for example, defect
tracking and cost estimation tools [13]. Some tools,
on the other hand, support core design, implementation
and testing functions; for example, configuration
and version control, test case generation and reverse
engineering tools [13]. Increasingly advanced tools
continue to be developed, however, software engineers
show tremendous resistance to their adoption. This
resistance, in part, could be attributed to the sharp
learning curve associated with these tools [9]. Alleviating
this resistance can encourage the adoption of
these tools, and ultimately increase the efficiency and
reduce the costs associated with software development
and maintenance. A possible way to mitigate this resistance
may be to expose and train students in the
different types of SE tools during their school projects.
Our SE course thus has a two-fold objective, namely,
to teach students maintenance and evolution skills,
while training them in modern SE tools. To meet this
dual objective, we sought to evaluate contemporary,
open source tools that would reverse engineer UML diagrams
from the source code. What we expected to be
relatively straightforward, given the plethora of open
source UML tools, turned out to be rather cumbersome
162