Visualisation of concurrent and objectoriented programs

visual aspects of program visualisation can make these tasks easier. A simple model of program development cycle is illustrated in Figure 1. First, a programmer creates a mental model of the software/program. This original mental model is then transformed into the corresponding static model using program development tools, such as text editors, CASE tools, and compilers. In this context, a static model comprises source code, the associated binary code, and other intermediate code forms. After the static model is created, it is transformed into the corresponding dynamic model. This model refers to the run-time behaviour of the program. The mapping is done by using program environment run-time control, such as operating systems. This dynamic model can furthermore be mapped into the programmer's mental model, which is a mental representation of the program execution. This mapping is important 4], because it enables the programmer to superimpose the execution mental model with the original mental model to nd the di erences between the initial program speci cations and the nal run-time outputs, or in other words, to identify bugs. Several methods exist to derive an execution mental model of a program from the dynamic program model, such as traditional software testing methods and reverse engineering. Generally, these methods heavily use non-graphical representations. As a result, a programmer may have to exert a considerable amount of e ort to construct this execution model. By using program visualisation tools, this problem is alleviated. The reason is that the tools provide information through visual representation of program execution or elements. Since pictorial information is generally easier to understand, the visual representation provides a matrix or skeleton from which programmers can derive their own mental models. In e ect, this accelerates the whole process of software development. It is worth noting that the use of visualisation tools acts more as
1 Introduction
Program visualisation is the use of graphical artifacts to represent both the static and dynamic aspects of a program 15, 19]. It takes advantage of the human visual ability to perceive pictorial representations of a program faster than the corresponding textual information. Generally, such visualisation is used to enhance human understanding of a program or algorithm 19]. Program visualisation can be used for many programming paradigms, including the concurrent and object-oriented paradigms. Each paradigm needs a di erent approach, as they utilise di erent methods of problem solving, and can bene t from visualisations which emphasise those aspects particular to that paradigm. Visualisation can also be used throughout the program development life-cycle, e.g. during the testing, veri cation and maintenance steps 14]. The
Programmer’s Execution Mental Model
Figure 1: Mental, static, and dynamic models of a program. a complement to the use of other traditional software development tools, such as CASE tools, and textual debuggers. It can not replace the use of these tools. Used in this way, program visualisation adds more perspectives and understanding of the overall software or program. Based on the above discussion, the use of program visualisation for concurrent and object-oriented programs is very important. There are two reasons for this. The rst reason is that complex run-time structures and relationships among program elements may be produced by such programs. This complexity cannot be well captured and represented merely by using textual-representation tools, such as conventional program debuggers and program browsers. Such tools usually provide only snapshots of run-time program structures and states. Basically, they do not convey information holistically. The second reason is that these snapshots and textual information require re-interpretation by the programmer. As previously stated, the use of program visualisation tools can help programmers more easily derive a mental model from the visual representation of program execution or elements. This paper discusses Visor++, a program visualisation tool for concurrent and object-oriented programs. Section 2 discusses the motivation and goals for building the tool, while Section 4 describes the architecture and the approach used to build the tool. Some work related with Visor++ is discussed in Section 6. Section 7 concludes the whole discussion.