41 research outputs found
Teaching programming at a distance: the Internet software visualization laboratory
This paper describes recent developments in our approach to teaching computer programming in the context of a part-time Masters course taught at a distance. Within our course, students are sent a pack which contains integrated text, software and video course material, using a uniform graphical representation to tell a consistent story of how the programming language works. The students communicate with their tutors over the phone and through surface mail.
Through our empirical studies and experience teaching the course we have identified four current problems: (i) students' difficulty mapping between the graphical representations used in the course and the programs to which they relate, (ii) the lack of a conversational context for tutor help provided over the telephone, (iii) helping students who due to their other commitments tend to study at 'unsociable' hours, and (iv) providing software for the constantly changing and expanding range of platforms and operating systems used by students.
We hope to alleviate these problems through our Internet Software Visualization Laboratory (ISVL), which supports individual exploration, and both synchronous and asynchronous communication. As a single user, students are aided by the extra mappings provided between the graphical representations used in the course and their computer programs, overcoming the problems of the original notation. ISVL can also be used as a synchronous communication medium whereby one of the users (generally the tutor) can provide an annotated demonstration of a program and its execution, a far richer alternative to technical discussions over the telephone. Finally, ISVL can be used to support asynchronous communication, helping students who work at unsociable hours by allowing the tutor to prepare short educational movies for them to view when convenient. The ISVL environment runs on a conventional web browser and is therefore platform independent, has modest hardware and bandwidth requirements, and is easy to distribute and maintain. Our planned experiments with ISVL will allow us to investigate ways in which new technology can be most appropriately applied in the service of distance education
Tools for Search Tree Visualization: The APT Tool
The control part of the execution of a constraint logic program can be conceptually shown as a search-tree, where nodes correspond to calis, and whose branches represent conjunctions and disjunctions. This tree represents the search space traversed by the program, and has also a direct
relationship with the amount of work performed by the program. The nodes of the tree can be used to display information regarding the state and origin of instantiation of the variables involved in each cali. This depiction can also be used for the enumeration process. These are the features implemented in APT, a tool which runs constraint logic programs while depicting a (modified) search-tree, keeping at the same time information about the state of the variables at every moment in the execution. This information can be used to replay the execution at will, both forwards and backwards in time. These views can be abstracted when the size of the execution requires it. The search-tree view is used as a framework onto which constraint-level visualizations (such as those presented in the following chapter) can be attached
Using a fine-grained comparative evaluation technique to understand and design software visualization tools
Software Visualization can be defined as the use of graphical and textual formalisms to describe the execution of computer programs. A large amount of Software Visualization technology has been developed to support computer science education, using a range of interface techniques. Far less effort has been devoted to evaluating the technology. As a result, it is unclear how effective Software Visualization tools are, either for students or professional programmers. Even more worrying, it is doubtful whether lessons are being learnt in successive designs of Software Visualization tools, or whether the application of new technologies (e.g. 3D animation and the internet) has become the primary goal, rather than the true goal of making computer programs easier to understand. To counter this problem the study reported here used protocol analysis to develop a fine-grained account of user behaviour, identifying (i) information access from the display, (ii) the use of comprehension strategies, and (iii) misunderstandings of the visualization and execution. The results were able to motivate future deigns which in turn could be compared and improved. The approach is compared to other evaluation techniques which aim to inform design. Finally, the generalizability of the approach is considered
Recommended from our members
Visual Programming in Prolog
A new, simple, complete visual formalism for programming in Prolog is presented. The formalism is shown to be equivalent to the standard textual notation for Prolog. We demonstrate some kinds of relationships and styles of programming that appear to be particularly lucid for novices when presented in the graphic notation, while other aspects of Prolog are identified that are clearer in the standard notation. The symbolism is proposed as a specialised complement, but not a replacement, for the traditional notation. The design of a computer interface called VPP is presented that supports visual programming in Prolog using the graphical notation. We discuss a prototype of VPP that has been implemented. We give examples to demonstrate how VPP has the capacity to allow users with little or no knowledge of Prolog to explore, understand, modify and create Prolog programs used to represent domain expertise in intelligent tutoring systems and interactive learning environments. We argue that the use of VPP may have advantages for beginners in the early stages of learning to program in Prolog, and may help to avoid certain misconceptions. We informally analyse the structure and properties of the notation from an abstract human-machine interaction viewpoint. An extension of the interpreter (dubbed VPE) designed for visualising Prolog execution spaces is presented. The limitations and possibilities for further work of both systems are identified and discussed
Debugging Trait Errors as Logic Programs
Rust uses traits to define units of shared behavior. Trait constraints build
up an implicit set of first-order hereditary Harrop clauses which is executed
by a powerful logic programming engine in the trait system. But that power
comes at a cost: the number of traits in Rust libraries is increasing, which
puts a growing burden on the trait system to help programmers diagnose errors.
Beyond a certain size of trait constraints, compiler diagnostics fall off the
edge of a complexity cliff, leading to useless error messages. Crate
maintainers have created ad-hoc solutions to diagnose common domain-specific
errors, but the problem of diagnosing trait errors in general is still open. We
propose a trait debugger as a means of getting developers the information
necessary to diagnose trait errors in any domain and at any scale. Our proposed
tool will extract proof trees from the trait solver, and it will interactively
visualize these proof trees to facilitate debugging of trait errors.Comment: 9 pages, 2 figure
Implementation of an event driven scheme for visualizing parallel execution of logic programs
This article presents in an informal way some early results on the design of a series of paradigms for visualization of the parallel execution of logic programs. The results presented here refer to the visualization of or-parallelism, as in MUSE and Aurora, deterministic dependent and-parallelism, as in Andorra-I, and independent and-parallelism as in &-Prolog. A tool has been implemented for this purpose and has been interfaced with these systems. Results are presented showing the visualization of executions from these systems and the usefulness of the resulting tool is briefly discussed
Some paradigms for visualizing parallel execution of logic programs
This paper addresses the design of visual paradigms for observing the parallel execution of logic programs. First, an intuitive method is proposed for arriving at the design of a paradigm and its implementation as a tool for a given model of parallelism. This method is based on stepwise
reñnement starting from the deñnition of basic notions such as events and observables and some precedence relationships among events which hold for the given model of parallelism. The method is then applied to several types of parallel execution models for logic programs (Orparallelism, Determinate Dependent And parallelism, Restricted and-parallelism) for which visualization paradigms are designed. Finally, VisAndOr, a tool which implements all of these paradigms is presented, together with a discussion of its usefulness through examples
CP debugging tools: Clarification of functionalities and selection of the tools
Abstract is not available