Visualizing Transition Diagrams of Action Language Programs (original) (raw)
Related papers
A tool for implementing action graphs
2000
We describe a specification tool for action graphs, which allows the user to naturally switch between between the syntactic and graphical presentations. The implementation includes a general matching algorithm for identifying redexes in a graph, and for animating reductions.
Drawing execution graphs by parsing
In this paper we present an algorithm for drawing execution graphs. Such graphs represent the control flow in a program. The fact that a program is constructed according to a grammar is reflected in the corresponding execution graph. Therefore, we introduce graph production rules that are based on generally used programming language constructs. Each rule is applied to a certain class of topologies of the graph. By parsing an execution graph according to these rules a visually appealing layout of the graph can be generated. We take into account that the nodes in a graph can have variable sizes. Fonnalizing Process Algebraic Verifications in the Calculus of Constructions. p. 49. Concrete process algebra. p. 134.
Proceedings 1996 IEEE Symposium on Visual Languages, 1996
The motivation for this work stems from the lack of good visual tools for describing the execution of procedure-level constructs such as procedures, functions, coroutines, iterators, methods, and processes. Our proposed solution to this problem is an extension of an old technique called the contour diagram, which was originally used to give semantics for Algol-like languages. Our extensions allow the contour diagram to be used for more modern languages, such as object-oriented languages, logic languages, etc. In this paper, we explain this extended notation, and its use in visualizing the execution of procedural, object-oriented and logic programs. The significance of this extension is that it can serve as a basis for program visualization tools.
Flow chart interpreter: an environment for software animation representation
2003
This article discusses the algorithms as basic precondition for quality results from the computer science education. It is written out the main functions of the software visualization and animation and the benefit of their use in the education and software development. A concrete environment FLOW CHART INTERPRETER for algorithm interpretation is presented. The environment functions and the main perspective for its application are described.
Visual Metaphors for Understanding Logic Program Execution
A classic notion in logic programming is the separation of logic and control. Logic is for problem solving; control is for directing inference. However, practical experience in the classroom suggests that problem-solving students nonetheless devote much effort to understanding control issues such as eliminating looping behaviours and improving program efficiency. In the case of Prolog, this requires a clear understanding of the operation of both unification and backtracking. Students often try to get this understand by tracing executions, but the common fourport debugger used in Prolog is not as helpful as it could be. In particular, it provides information in low bandwidth textual form. This paper describes a new visualization system for logic programming that uses colour tagging to trace unification through the Prolog proof tree. A user can dynamically "tag" a term or subterm with a colour that is immediately propagrated through the displayed tree. The colour is also pro...
Adding control-flow to a visual data-flow representation
2005
Abstract Previous studies have shown that novices do not tend to extract or use data-flow information during program comprehension. However, for impact analysis and similar tasks, data-flow information is necessary and highly relevant. Visual data-flow programming languages, such as Prograph/CPX, have been commercially successful, suggesting that they provide effective data-flow representations.
On visualization and comprehension of scenario-based programs
… (ICPC), 2011 IEEE …, 2011
We address the problem of comprehending cause and effect relationships between relatively independent behavior components of a single application. Our focus is on the paradigm of behavioral, scenario-based, programming, as captured by the language of live sequence charts (LSC) or its Java-based counterpart, BPJ. In this programming paradigm, multi-modal behaviors can be specified separately, and are integrated only at run time. We present a tool, with which the user can easily follow the decisions of the collective execution mechanism. It shows the behaviors and events that were executed at each point in time, and those that were delayed or abandoned, as well as the causes and reasons behind these run-time choices. The dynamic effects of such decisions on the system's behavior can be seen easily too.