25,680 research outputs found
Strategies for program inspection and visualization
The aim of this paper is to show the strategies involved in the implementation
of two tools of PCVIA project that can be used for Program Comprehension.
Both tools use known compiler techniques to inspect code in order to
visualize and understand programs’ execution.
On one hand we convert the source program into an internal decorated (or attributed)
abstract syntax tree and then we visualize the structure traversing it, and
applying visualization rules at each node according to a pre-defined rule-base. No
changes are made in the source code, and the execution is simulated.
On the other hand, we traverse the source program and instrument it with inspection
functions. Those inspectors provide information about the function-call flow
and data usage at runtime (during the actual program execution). This information
is collected and gathered in an information repository that is then displayed
in a suitable form for navigation.
These two different approaches are used respectively by Alma (generic program
animation system) and Cear (C Rooting Algorithm Visualization tool). For each
tool several examples of visualization are shown in order to discuss the information
that is included in the visualizations, visualization types and the use of
Program Animation for Program Comprehension.FC
A Framework for Active Learning: Revisited
Over the past decade, algorithm visualization tools have been researched and developed to be used by Computer Science instructors to ease students’ learning curve for new concepts. However, limitations such as rigid animation frameworks, lack of user interaction with the visualization created, and learning a new language and environment, have severely reduced instructors’ desire to use such a tool. The purpose of this project is to create a tool that overcomes these limitations. Instructors do not have to get familiar with a new framework and learn another language. The API used to create algorithm animation for this project is through Java, a programming language familiar to many instructors. Moreover, not only do the instructors have control over planning the animation, students using the animation will also have the ability to interact with it
Code inspection approaches for program visualization
The aim of this paper is to show the approaches involved in the implementation of two tools of PCVIA project that can be used for Program Comprehension. Both tools use known compiler techniques to inspect code in order to visualize and understand programs’
execution but one of them modifies the source code and the other not.
In the non-invasive approach, we convert the source program into an internal decorated (or attributed) abstract syntax tree and then
we visualize the structure traversing it, and applying visualization rules at each node according to a pre-defined rule-base. No changes are made in the source code, and the execution is simulated.
In the invasive approach, we traverse the source program and instrument it with inspection functions. Those functions, also known as inspectors, provide information about the function-call flow and data usage at runtime (during the actual program execution). This information is collected and gathered in an information repository that is then displayed in a suitable form for navigation.
These two different approaches are used respectively by Alma (generic program animation system) and CEAR (C Rooting Algorithm Visualization tool). For each tool several examples of visualization are shown in order to discuss the information that is included in the visualizations, visualization types and the use of Program Animation for Program Comprehension.FC
Animating the evolution of software
The use and development of open source software has increased significantly in the last decade. The high frequency of changes and releases across a distributed environment requires good project management tools in order to control the process adequately. However, even with these tools in place, the nature of the development and the fact that developers will often work on many other projects simultaneously, means that the developers are unlikely to have a clear picture of the current state of the project at any time. Furthermore, the poor documentation associated with many projects has a detrimental effect when encouraging new developers to contribute to the software. A typical version control repository contains a mine of information that is not always obvious and not easy to comprehend in its raw form. However, presenting this historical data in a suitable format by using software visualisation techniques allows the evolution of the software over a number of releases to be shown. This allows the changes that have been made to the software to be identified clearly, thus ensuring that the effect of those changes will also be emphasised. This then enables both managers and developers to gain a more detailed view of the current state of the project. The visualisation of evolving software introduces a number of new issues. This thesis investigates some of these issues in detail, and recommends a number of solutions in order to alleviate the problems that may otherwise arise. The solutions are then demonstrated in the definition of two new visualisations. These use historical data contained within version control repositories to show the evolution of the software at a number of levels of granularity. Additionally, animation is used as an integral part of both visualisations - not only to show the evolution by representing the progression of time, but also to highlight the changes that have occurred. Previously, the use of animation within software visualisation has been primarily restricted to small-scale, hand generated visualisations. However, this thesis shows the viability of using animation within software visualisation with automated visualisations on a large scale. In addition, evaluation of the visualisations has shown that they are suitable for showing the changes that have occurred in the software over a period of time, and subsequently how the software has evolved. These visualisations are therefore suitable for use by developers and managers involved with open source software. In addition, they also provide a basis for future research in evolutionary visualisations, software evolution and open source development
Can Computers Create Art?
This essay discusses whether computers, using Artificial Intelligence (AI),
could create art. First, the history of technologies that automated aspects of
art is surveyed, including photography and animation. In each case, there were
initial fears and denial of the technology, followed by a blossoming of new
creative and professional opportunities for artists. The current hype and
reality of Artificial Intelligence (AI) tools for art making is then discussed,
together with predictions about how AI tools will be used. It is then
speculated about whether it could ever happen that AI systems could be credited
with authorship of artwork. It is theorized that art is something created by
social agents, and so computers cannot be credited with authorship of art in
our current understanding. A few ways that this could change are also
hypothesized.Comment: to appear in Arts, special issue on Machine as Artist (21st Century
Graph Algorithm Animation with Grrr
We discuss geometric positioning, highlighting of visited nodes and user defined highlighting that form the algorithm animation facilities in the Grrr graph rewriting programming language. The main purpose of animation was initially for the debugging and profiling of Grrr code, but recently it has been extended for the purpose of teaching algorithms to undergraduate students. The animation is restricted to graph based algorithms such as graph drawing, list manipulation or more traditional graph theory. The visual nature of the Grrr system allows much animation to be gained for free, with no extra user effort beyond the coding of the algorithm, but we also discuss user defined animations, where custom algorithm visualisations can be explicitly defined for teaching and demonstration purposes
Experiences using Z animation tools.
In this paper we describe our experience of using three different animation systems. We searched for and decided to use these tools in the context of a project which involved developing formal versions (in Z) of informal requirements documents, and then showing the formal versions to people in industry who were not Z users (or users of any formal techniques). So, an animator seemed a good way of showing the behaviour of a system described formally without the audience having to learn Z. A requirement, however, that the tools used have to satisfy is that they correctly animated Z (whatever that may mean) and they behave adequately in terms of speed and presentation. We have to report that none of the tools we looked at satisfy these requirements--though to be fair all of them are still under development
- …