The use of UML is a common way to communicate software design and analysis models, but once these models are implemented, the documentation containing all the UML representation is seldom used by software developers. In recent times, researchers have begun exploring UML to analyze the execution of software. For example, Mehner extends UML to incorporate execution semantics of concurrent programs [MW00]. The
divide between design and implementation is further impacted by the lack of automated support for testing and debugging with UML. Debugging any system requires structural knowledge of the software and detailed information about components (down to the source code level). Debugging of object-oriented systems is more challenging as it introduces concepts such as inheritance and polymorphism, making program understanding even more difficult. Traditional debugging involves the user creating a mental image of the structure and execution path based on source code. According to Miller, the 7 ± 2 rule makes it very difficult for humans to construct large mental models as the human short-term memory span is generally limited by this constraint [MIL56]. To alleviate this problem, this research aims to enhance an existing visual execution model for object-oriented systems. This model is implemented in a Java based application and uses UML to visually represent the execution of the object-oriented system for the purposes of debugging. Following is a detailed discussion on the visual and design objectives of this research.
3.2.1 Visual Objectives
The main intention of the visualization generated for this research is to enhance the debugging process. For effective debugging, it is essential for users to have access to various levels of abstraction. The system should present both high-level views and detailed information to allow for more precise debugging.
Regardless of the visual language used in any SV tool, large software systems still result in models that are extremely large and complicated. In the case of UML, a typical class diagram for a moderately sized system would cover many pages and be too large for efficient navigation of the whole system. Common solutions to this problem include
multi-page printouts and incorporation of an overview+detail capability. Multi-page printouts or multiple windows as used in IDEs such as JBuilder and TogetherControlCenter can show overall system structure and individual component details. However, this technique has several shortcomings such as increased visual scanning leading to increased cognitive load, difficult production and management and lack of support for interaction and dynamic editing. Furthermore, with the multiple windows method, the ‘big picture’ can be lost. Wong et al. states that when analyzing static information of large software systems, it is preferable to obtain an understanding of the overall, high-level structure of the software before proceeding to lower level details [WTMS95]. On the other hand, use of the overview+detail technique can provide access to overall system structure and individual component details; however, with this technique, the information is not provided in one single view. Therefore, it also suffers from drawbacks such as increased cognitive load and thus reduces the overall effectiveness of the visualization.
In their presentation of principles for a Modeling Language Design, Paige et al. identify nine factors to consider when designing and evaluating modeling languages — simplicity, uniqueness, consistency, seamlessness, reversibility, scalability, supportability, reliability, and space economy [POB00]. This research only considers space economy. The extent to which UML satisfies the remaining criteria will varies depending on the user’s experience with modeling languages, as most of them requires subjective judgment. Space economy requires that “models should take up as little space on the printed page as possible” since smaller models have less to understand and less work is required for modelers and tools to perform in order to maintain the models
[POB00]. UML does not effectively address space economy, leaving a lot of unused space within and between components. Graph layout algorithms are required to make the display of such graphs more space efficient. UML’s inefficient use of space results in models that cover many pages for large systems. Navigating through many pages significantly increases the time to access relevant components. The problem is further compounded by the resulting inability to simultaneously view high-level system structure and individual component details. One goal of this research is to maintain the symbology and semantics of UML while enhancing its space efficiency by the use of visualization and graph layout techniques to accommodate rapid access to both high-level and detailed system information.
The visual objectives of this research are summarized as follows: ● Present information through multiple levels of abstraction. ● Present the visualization model in a familiar manner, ● Preserve context to aid in better program understanding,
● Present a dynamic visualization display such that it is suitable for real time debugging and match the changing runtime nature of programs, and
● Improve space efficiency to reduce search while presenting the user with detail for a region of interest.
3.2.2 System Design Objectives
The prototype system is based on a Java CASE tool, ArgoUML, which is described in more detail. This section addresses the functional, performance and user requirements for this system to be effective. First, the system must be user-friendly and functional. Software engineering principles, including the use of design patterns, are taken into account to make the tool more adaptable to future requirements. As many of the actions
and their associated algorithms are computationally intensive, there is also consideration of efficient processing and data storage. Objectives for the modified ArgoUML as part of this research are summarized below. It shall:
● have the ability to monitor processes for debugging,
● have the ability to automatically reverse engineer object-oriented systems,
● have the ability to display multiple systems over socket connections for debugging,
● have no effect on the functional system behavior of monitored programs, ● have minimal effect on system performance to enable real time debugging, ● provide standard debugging controls,
● provide a well designed GUI with consideration of Shneiderman’s principles as stated in Chapter 2 [SHN98],
● have a low CPU load and memory usage for the monitoring system, and
● have a design adhering to software engineering principles wherever possible to ensure it adapts to future requirements.