Graphical Debugging of Distributed Applications Using UML Object Diagrams to Visualize the State of Distributed Applications at Runtime Andreas Koch and Albert Zundorf¨ Software Engineering Research Institute, Kassel University, Wilhelmshoher¨ Allee 73, Kassel, Germany Keywords: Tool, Debug, Distributed, UML2, Objectdiagram, Eclipse. Abstract: While debugging is one of the most time consuming tasks software developers perform, the tool support, especially for distributed applications, is lacking according to many professional developers. The Visual De- bugger is an approach to provide an easy-to-use tool which gives software developers an abstract view on the current state of their application in debugging sessions. While similar tools for non distributed applications al- ready exist, the Visual Debugger addresses the more complex debugging scenarios in distributed applications. Therefore, several views with different levels of abstraction of the current state of an application are provided. Although the approach may be adapted to other object oriented programming languages, the current target of the Visual Debugger is languages running on the Java Virtual Machine with the focus on Java. 1 INTRODUCTION The steps 1, 3 and 4 are already well supported by tools and frameworks like logging or testing frame- Debugging is one of the most time consuming tasks in works, mature source code editors and more. In con- the daily work of a software developer. To tackle this trast, the second step is the most crucial and most time challenge, many tools were developed in research as consuming part of this process because there are a lot well as in the industry. Additionally, in each modern of different sources of an unwanted behaviour, that IDE as Eclipse, IntelliJ IDEA or NetBeans some kind must be considered: logical failures in algorithms, of debugging support is already integrated. Although performance issues, not catched exceptions and many so much work was invested into this area, there are more. still many professional software developers not sat- Most of these sources result in the same simple isfied with the provided support of debugging tools. outcome: values are changed or not changed as ex- (Layman et al., 2013) pected. To find a reproducible test scenario to trigger Started in a research project with industrial part- unwanted behaviour can be challenging. But even if ners, the Visual Debugger presented in this paper is this scenario is found, the search for the erroneous an approach to fill the gap of an easy-to-use, but help- source code is difficult. One common problem is the ful visualization of the state of distributed and non inability to understand the current state of the appli- distributed Java applications as a helper in debugging cation in a reasonable amount of time when the un- sessions. wanted behaviour occurs. To explain the usage of the Visual Debugger, at Apart from the research area, in the industry, most first it must be positioned in the debugging process. available debugging tools focus on a textual view on This process can be separated into several steps: the application state. One example, which can be 1. An unwanted behaviour of an application takes found in most IDEs and therefore is probably the most place. used tool during debugging sessions, is a tree repre- 2. The problematic part of the source code is located. sentation of the runtime state of objects like the vari- ables view in the Eclipse IDE in figure 1. This has 3. The source code is changed to prevent this be- indeed proven to be useful in many debugging situa- haviour. tions, but tends to be less helpful in object oriented 4. The test scenario is reproduced to ensure this programming languages when the application state changed behaviour is correct. becomes more complex. One reason is the visualiza- Koch A. and Zündorf A.. 223 Graphical Debugging of Distributed Applications - Using UML Object Diagrams to Visualize the State of Distributed Applications at Runtime. DOI: 10.5220/0005233202230230 In Proceedings of the 3rd International Conference on Model-Driven Engineering and Software Development (MODELSWARD-2015), pages 223-230 ISBN: 978-989-758-083-3 Copyright c 2015 SCITEPRESS (Science and Technology Publications, Lda.) MODELSWARD2015-3rdInternationalConferenceonModel-DrivenEngineeringandSoftwareDevelopment non distributed applications have, the Visual Debug- ger provides two modes. One, which targets mainly on applications running in a single JVM and another mode, that adds additional functionality to support the visualization of distributed applications. This paper focuses on the second mode, but explains in the fol- lowing sections some basic behaviour which is valid for both modes and necessary to understand the sec- tions focused on distributed scenarios. Figure 1: A snippet of the Java heap in the Eclipse variables view. 2 RELATED WORK tion of a graph structure in a tree. Relations between objects are only visible from one object to another. Although graphical debugging tools are researched This results in duplications of objects in the variables quite well, they are rarely found as commercial prod- view, when different objects have relations with the uct. Especially when distributed applications come same child. As an example: browsing the state of the into play, most existing tools are limited in their us- topmost object in figure 1 (id=476), the highlighted ability. Besides, many of these tools focus on visu- object with id 427 is reachable (and therefore visible) alizing program behaviour instead of the application three times with different paths. Another reason this state. view is problematic in distributed (or concurrent) sce- Some tools that follow a similar idea as the Visual narios is, it only provides data for the current state Debugger are Jive (Gestwicki and Jayaraman, 2005) the user is looking at. Resuming the program exe- and the eDobs (Geiger and Zundorf,¨ 2002) (Geiger cution results in losing the current viewpoint and the and Zundorf,¨ 2006). But both tools lack of support for state needs to be re-evaluated again at the next inter- the special requirements of distributed applications. ruption of the execution. The situation is worsened There are tools, that are targeted at distributed ap- when a distributed application comes into play. This plications, but serve a different use case. One ex- increases the complexity of the state of an applica- ample for this tool section is the JRastro (da Silva tion. Usually objects live on different Java Virtual et al., 2003). While the Visual Debugger provides Machines (JVM) on the same or even on physically an abstract view on the state of the application during separated devices. the execution, JRastro helps with finding performance Hereinafter, the terms object and instance are used problems by visualizing the communication between in the following way. While the term instance is used the different nodes of the application. Tools follow- to describe the instantiation of a class in a (single) ing a similar idea than JRastro are Atropos (Lonnberg¨ JVM, object is used when two or more equals in- et al., 2011), JACOT (Leroux et al., 2003) or JaVis stances on different JVMs are meant. (Mehner, 2001). Understanding the current state of a distributed JAVAVIS (Oechsle and Schmitt, 2001) shows the application becomes more difficult, because during internal behaviour and state of an application with a debugging session much more state changes take UML sequence and object diagrams. But its usability place. Each time the developer is forcedoo to re- for distributed applications is limited as it is targeted evaluate the state. The identification of different in- on sequential program execution. stances of an object on different JVMs complicates a JAN (Lohr¨ and Vratislavsky, 2003) uses object di- debugging session as these state changes force devel- agrams to visualize the state of an application, but its opers to identify equal instances on different JVMs focus is on the animation of different states of an ap- again and again. Additionally, unexpected program plication to understand the behaviour of a program in- behaviour is more difficult to reproduce, which of- stead of debugging it. ten results in repeatedly executed debugging sessions until the unwanted behaviour appears again and the source behind it can be located. During the debug- ging sessions a lot of time is spent to understand the 3 ARCHITECTURE OF THE current state. The focus of the Visual Debugger is to VISUAL DEBUGGER provide an abstract view on the part of the application state that is relevant for a debugging session. To visualize a complex graph structure like the Java Due to the different requirements distributed and heap, an obvious choice is to use an object diagram. 224 GraphicalDebuggingofDistributedApplications-UsingUMLObjectDiagramstoVisualizetheStateofDistributed ApplicationsatRuntime In the Visual Debugger standard UML2 object dia- lated to the source code and are triggered, for exam- grams are used. While this forced us to use a strongly ple, when a specific line in the source code is exe- formalized and predefined syntax, it provides easy in- cuted, a method is called or the field of an object is teroperability with other tools. Each model created changed. Besides, there are events that notify about during a debugging session can be used as input in started/stopped threads respectively loaded/unloaded other UML compatible tools, for example as part of classes in a JVM or state changes of the JVM itself. the test documentation. On top of the JDI, Eclipse delivers with the JDT Three of the main design goals were to create ac- an easy-to-use layer to access the heap of a JVM. ceptance, simplicity and usability. Creating accep- The JDT is a mature framework and used in almost tance is difficult because many software developers all debugging tools integrated into the Eclipse IDE. have an existing workflow and a given set of tools It provides utilities to register requests, collect values they use in their daily work.