Browse Books

Reviewer: Fernando Berzal

Software visualization can be defined as the art and science of generating visual representations of various aspects of software and their development process. As a branch of scientific visualization, its final goal is to support human comprehension. In this case, visualization techniques focus on the structure of software systems, their dynamic behavior, and their evolution. Diehl’s monograph on software visualization is organized around these three research areas. Before delving into particular visualization techniques, Diehl writes a very short introduction to visualization. Almost like class notes, a scant 20 pages present the basics of visual perception and cognition, from school-level eye physiology to the perception of patterns and motion, as well as a bird’s-eye survey of techniques for visualizing textual, hierarchical, and graph-based information (namely, alternative ways to draw graphs and trees). The core of this easy-to-read book delves into particular techniques for visualizing the structure, behavior, and evolution of software systems at different levels of abstraction. Supported by plenty of figures and illustrations, many of them in full color, Diehl steers the reader through different techniques as a good tourist guide would do: pointing out the most significant aspects, while leaving out many details that might be of partial interest for his intended audience, even at the cost of missing the opportunity to provide a more in-depth treatment of many topics. With respect to static program visualization, Diehl overviews different diagrammatic representations of source code, from structure charts to control flow graphs and similar techniques. He also touches on the foundations of control-flow and data-flow analysis (the techniques behind optimizing compilers and the tools that help determine stack usage or worst-case execution times, or detect some kinds of bugs). Finally, many different kinds of diagrams that can help (or hinder) program understanding at a higher level are mentioned, from standard unified modeling language (UML) diagrams to geon diagrams, and from class blueprints and SHriMP/Creole diagrams to simple Kiviat charts (called spider diagrams in the text). Algorithm animation, typically used for educational purposes, is one of the dynamic program visualization techniques discussed in this book. Other techniques that are briefly surveyed include those employed by the data display debugger (DDD). Visual debugging and visual testing aids are also covered, from memory slices and their related techniques to the visualization of test case results and flow patterns. Finally, some techniques are discussed that help us explore and understand the evolution of software systems. For example, such techniques provide insight into changes in software metrics, help analyze software repositories, and allow the detection of evolutionary coupling (detecting the relationships among entities that are usually changed at the same time). The book’s closing chapters start with a short discussion on the evaluation of software visualization techniques. Both quantitative and qualitative evaluation methods are mentioned, with a special emphasis on evaluating the learning effectiveness of algorithm visualizations (maybe the only area where the evaluation of software visualization techniques has attracted enough attention in the past). After an abridged rehash of the techniques covered in the book, and the enumeration of existing visualization tools, Diehl offers his personal view on the main challenges that software visualization researchers will probably have to face in the near future. As the first existing textbook on software visualization, Diehl has managed to put together a good overview of this interesting field. As an introduction, this book can be useful for graduate students and researchers alike. Short and concise, almost laconic, Diehl’s monograph provides the overall picture without unnecessary detail. For those wishing to learn every nook and cranny of particular visualization techniques, the many bibliographic references at the end of this monograph can serve as the starting point for further exploration. Online Computing Reviews Service

Reviewer: Jose Lloret

Using graphics to represent different aspects of software—its structure and execution, for example—is the essence of software visualization. In the introduction, the author defines software visualization, and the book’s framework and goals. In chapter 2, “Visualization Basics,” the author provides a brief description, on the one hand, of the physiological and psychological bases of human perception, and, on the other, of the different techniques for visualizing information. The next three chapters detail three software visualization categories. Chapter 3, “Static Program Visualization,” looks at the program code as a sequence of characters. The author then lists various ways of representing program code, both textually and graphically. The only drawback is that he deals with representations that are no longer in use, compared with more modern ones. Chapter 4, “Dynamic Program Visualization,” explains how to choose and obtain data; several examples are included for clarification. Chapter 5, “Visualizing the Evolution of Software Systems,” describes, in essence, the software tools capable of visualizing this evolution: “A software system has to be adapted to the changing needs and environment of its users.” In these three chapters, different software packages are described for each type. This book’s audience is limited to students preparing for their PhD programs. Each chapter ends with a series of exercises, which allows one to delve more deeply into the topic being studied. In general, the edition is excellent, although there are some diagrams and figures that are not scaled according to the format of the book. A complete list of resources, including an extensive bibliography, can be found on the Web. In summary, this is a book with clear explanations that is well structured and easy to read, yet profound enough for a second, more thorough reading. Online Computing Reviews Service

Reviewer: Andrew Robert Huber

If a picture is worth 1000 words, how many lines of code is a graphical program representation worth__?__ Software visualization is "the art and science of generating visual representations of various aspects of software and its development." Diehl claims that this is the first textbook on software visualization. The intended audience is graduate students and researchers new to the field. This book makes no attempt to be complete, only to cover the most seminal work in software visualization and the most promising new approaches; no background in visualization is required. The book's first seven chapters introduce software visualization, which is defined as transforming information into visual form for observation, with the goal of helping viewers comprehend software systems and improving software development productivity. Software visualization is broadly considered to include artifacts related to software and the development process, not just algorithms or programs. A software visualization model that is used in the rest of the book is introduced: a three-step pipeline with feedback-data acquisition, data analyses, and visualization. Since visualization conveys information through the visual system, chapter 2 briefly looks at visual memory, the human eye, color, and color perception. Advice on the implications of these for visualization design is mostly limited to selecting color palettes. A section on graphs and graph drawing shows examples of many different representations of graphs, but lacks any evaluation of which formats are good, when they should or shouldn't be used, and why. Chapter 3 covers static program visualizations, both text based and diagrammatic, from pretty printing to Jackson diagrams, control flow graphs (flowcharts), Nassi-Shneiderman diagrams (structograms), and control-structure diagrams. The static program analyses discussed include control-flow analysis and data-flow analysis, with some examples of visualizations of the analysis results. The final section takes visualization to a higher level by considering the visualization of software architectures. Diagrams showing architectural structure such as unified modeling language (UML) and class blueprints are discussed, as are some approaches to extracting and visualizing architecture information from a system's sources. There is even some discussion of three-dimensional (3D) visualizations, with examples such as 3D UML and Vizz3D. As a practicing developer, this section merely illustrates how enamored the researchers are with technology?instead of results. Representing architectures as the world, with packages as countries, files as cities, classes as districts, and methods as buildings, may produce sexy displays, but fails to provide meaningful metaphors, insights, and understanding. Dynamic program visualization is covered in chapter 4, addressing issues such as collecting runtime data and visualizing dynamics. Algorithm animation is covered extensively, although it concentrates on well known and somewhat trivial examples: the n queens problem and various sorting methods. More interesting uses are visual debugging and visual testing, where visualization shows real promise for practical benefits in using test results to determine test coverage and find errors. Chapter 5 is devoted to visualizing the evolution of software systems: mainly, the visual analysis of software histories. Using information from source control systems supports the visualization of revision histories and releases, showing things such as which modules have changed in each release and changes in size or other metrics. Especially with data mining, the weakness of these approaches is that the nifty graphics generated still leave the viewer wondering what insights and benefits result. Chapter 6, "Evaluation," attempts to answer the question: "Is software visualization useful__?__" This is a disappointing chapter due to the lack of significant work in this area. Existing evaluations generally lack real datasets, or suffer bias because the developers did the evaluation. As Diehl points out, computer science and software engineering are notorious for their lack of empirical studies¿software visualization is no exception. The discussion of quantitative evaluations is less than one page, and no examples are cited. The discussion of qualitative evaluations is mostly on surveys, with evaluations of whether algorithm animations assist in learning about an algorithm. The final chapter will be especially useful to researchers and graduate students. It summarizes the techniques covered in the book for each data acquisition, analysis, and visualization phase. A table lists 48 current visualization tools, including research projects and commercially available and open-source tools, with uniform resource locators (URLs). The book concludes with some challenges for future software visualization research. There is an extensive list of about 240 references. A few exercises are included at the end of each chapter, and a companion Web-site provides additional examples and source code. Online Computing Reviews Service