DISEÑO PROTOTIPO SECTOR TURÍSTICO

In this chapter, we presented a historical perspective of software visualization. It all started five decades ago with diagrams, pretty printers, and movies that illustrated program behavior. In the 1980s, the focus moved towards creating advanced pretty printers, but also algorithm animation and a few early static visualization approaches. In the 1990s, the points of interest for software visualization research were distilled to three distinct directions, triggered by the aspect of the software system being visualized: static information, dynamic information, and system evolution. However, the turning point towards the thrive of software visualization was in 2002, when the most prominent researchers in the field decided to initiate a series of venues dedicated to software visualization.

These are exciting times for software visualization research. On the one hand, the advances in hardware open new horizons barely imaginable two decades ago. One the other hand, the in- vasion of software visualization approaches—some of them rather futile—raises skepticism and calls for methods for evaluating their usefulness.

The first claims of our thesis is that depicting software systems as cities is a versatile metaphor for software visualization. In Part II we present our approach, based on the city metaphor, and three application contexts we use to demonstrate the versatility of the metaphor.

Approach

Preview

After looking at the history of software visualization and the challenges that lie in front of us, we start our exploration of the city metaphor. This part describes our city metaphor and the three application contexts we employ to demonstrate the versatility of the metaphor.

In Chapter 3, we look at the ideas underlying our city metaphor and how they influenced the design of the metaphor. After describing the metaphor, we apply it in the context of program com- prehension, on two case studies. The insights we learn are a good indication of the usefulness of the metaphor, while the questions remained unanswered drive our research towards the second application context.

In Chapter 4, we extend our approach to enable the visualization of software evolution, by creating three complementary techniques. Using three case studies, we illustrate how we apply our approach in the context of software evolution. We obtain the answers to a number of questions that we could not address in the context of program comprehension. Moreover, we ask the developers of the systems to assist us with fragments of system history they witnessed. In Chapter 5, we present our third application context of our approach, i.e., design quality assess-

ment. We describe a technique called disharmony map, which relies on actual design problem data acquired using an existing technique called detection strategies. We use this approach on several case studies to observe software systems in terms of their deficiencies.

In Chapter 6, we present the tool support we developed to enable us to apply our approach on real systems and discuss how we dealt with a number of challenges related to tool support, such as performance and scalability, configurability, usability, and availability.

A City Metaphor

for Program Comprehension

3.1

Introduction

There’s no place like home. Developers spend an important part of their time constructing com- plex software systems, an activity termed as programming, which is according to Weinberg “a kind of writing”[Wei98]. The more familiar we are with a program, the easier it is to under- stand the impact of any modification we may want to perform, i.e., familiarity has an important influence on program comprehension strategies[SFM99].

Familiarity is strongly related to habitability, which is what makes a place livable, like home. Gabriel[Gab96] states that “habitability is the characteristic of source code that enables pro- grammers, coders, bug-fixers, and people coming to the code later in life to understand its construction and intentions[...]”. While Gabriel’s position stems from the point of view of lan- guage design, we focus on the creation of habitable visual representations of software systems, as support for program comprehension and reverse engineering activities.

We argue that habitability is an important, yet neglected concept in software visualization. The existing approaches fail at conveying a sense of habitability to the viewer. Inherently, 2D visualizations lack the realism required for making the viewer feel immersed in the environment, as opposed to 3D visualization. However, most of the existing 3D visualization do not exploit the

localityof their exploration space, allowing objects to be freely moved. In such environments, viewers are vulnerable to disorientation, one of the main arguments against 3D visualizations.

We chose a city metaphor[WL07b] for our software visualization approach, due to the many similarities between software and civil engineering, which enable a straightforward and intuitive mapping between the two domains. Moreover, a city is an intrinsically complex construct and can only be incrementally explored, in the same way the understanding of a complex system increases step by step.

Before describing our vision of the city metaphor, we briefly describe the underlying meta- model of our approach, which enables us to visualize software systems written in different pro- gramming languages, such as Java, C++, C#, or Smalltalk.