Visual Debugging Techniques for Reactive Data Visualization

Interaction is critical to effective visualization, but can be difficult to author and debug due to dependencies among input events, program state, and visual output. Recent advances leverage reactive semantics to support declarative design and avoid the “spaghetti code” of imperative event handlers. While reactive programming improves many aspects of development, textual specifications still fail to convey the complex runtime dynamics. In response, we contribute a set of visual debugging techniques to reveal the runtime behavior of reactive visualizations. A timeline view records input events and dynamic variable updates, allowing designers to replay and inspect the propagation of values step‐by‐step. On‐demand annotations overlay the output visualization to expose relevant state and scale mappings in‐situ. Dynamic tables visualize how backing datasets change over time. To evaluate the effectiveness of these techniques, we study how first‐time Vega users debug interactions in faulty, unfamiliar specifications; with no prior knowledge, participants were able to accurately trace errors through the specification.     

程序调试中的树形结构演变可视化模型

树形结构作为一种非线性数据结构,在程序执行过程中的演变过程较为抽象,尤其是在对其进行加工型操作时,容易发生内存泄漏。针对编程初学者难以掌握树形结构的逻辑演变过程,以及在程序中发生内存泄漏错误时调试较为困难的问题,文中提出了一种对程序调试过程中树形结构的演变过程进行可视化呈现的处理模型TEVM(Tree Evaluation Visualization Model)。针对单个可视化程序在调试步骤前和调试步骤后的两个树形结构,设计了一种将树形结构转换为线性表示的结构对比算法,得出了它们的包括泄漏树在内的结构差异;同时设计了一种树形结构布局方法,并计算它们的布局差异。根据结构差异和布局差异生成可视化演变序列,调用绘图引擎对该序列进行解析和执行,从而完成对树形结构及其演变过程的动态、平滑和直观的可视化呈现,帮助编程初学者快速理解树形结构相关程序的执行过程,提升调试效率。将TEVM模型集成于一个面向编程实训教学的集成开发环境原型Web AnyviewC中,取得了较好的应用效果。     

Constructing a nutrition diagnosis expert system

This paper presents a research of constructing a web-based expert system for nutrition diagnosis by utilizing the expert system techniques in artificial intelligence. The research implements Nutritional Care Process and Model (NCPM) defined by American Dietetic Association (ADA) in 2008 and integrate the nutrition diagnosis knowledge from dietetics professionals to establish the basics of building the rule-based expert system with its knowledge base. The system is built using Microsoft Visual Studio 2008 on .NET Framework 3.5SP1 utilizing the built in rule engine which comes with Windows Workflow Foundation.With the help of this system, it is easier for dietetics professionals to adapt to the newly introduced concept of nutrition diagnosis. At the heart of the web based expert system is a knowledge base, it has a rule engine which contains the nutrition diagnosis rules converted from signs and symptoms for nutrition diagnosis from dietetics professionals and are expressed in XML format which are then stored in a SQL database. A knowledge engineer will be able to use a rule editor to add new rules or to update existing rules within the rule database. Dietetics professionals would be able to enter patient’s basic data, anthropometric data, physical exam findings, biochemical data, and food/nutrition history into the program. After dietetics professionals complete nutrition assessment, the program will make inference to the rule base and make nutrition diagnosis. Dietetics professionals could then make the final diagnosis decision for the patient based on the diagnosis report generated by the web based nutrition diagnosis expert system.For this study, I have selected 100 chronic kidney disease patients under hemodialysis from a university hospital, recorded their albumin, cholesterol, creatinine before dialysis, height, and dry weight and then use these data to perform nutrition diagnosis with both the expert system and a practicing dietitian. After comparing the result, I found that the expert system is faster and more accurate than human dietitian.     

并行面向对象可视化程序设计环境的设计与实现

将可视化和面向对象技术引入并行程序设计将大大提高并行程序的开发效率，文章介绍了基于并行C＋＋的并行面向对象可视化开发环境的设计思想和组成结构。     

Generating tools from graph-based specifications

This paper describes an approach for generating graphical, structure-oriented software engineering tools from graph-based specifications. The approach is based on the formal meta modeling of visual languages using graph rewriting systems. Besides the syntactical and semantical rules of the language, these meta models include knowledge from the application domains. This enables the resulting tools to provide the user with high level operations for editing, analysis and execution of models. Tools are constructed by generating source code from the meta model of the visual language, which is written in the very high level programming language PROGRES. The source code is integrated into a framework which is responsible for the invocation of commands and the visualization of graphs. As a case study, a visual language for modeling development processes together with its formal meta model is introduced. The paper shows how a process management tool based on this meta model is generated and reports on our experiences with this approach.     

The role of expert systems in producing log interpretation software

Abstract: Log interpretation science is a controversial and rapidly changing domain. Designing interpretation models is a highly experimental process which involves trials with a computer program as an integral part of the design. Therefore conventional software engineering techniques, which require a complete specification of the problem before the program is written, are often not applicable or fail to produce high quality software. The development of expert systems has provided the techniques, tools, and capabilities to let us seek alternate methods to produce log interpretation software: exploratory programming environments and automatic programming systems. An exploratory programming environment combines the power of interactive graphics and programming tools to merge the design and programming tasks into a single process where model and program develop together. An automatic programming system will embody the knowledge of the programming process and of some log interpretation heuristics to produce log processing programs from interactive specifications expressed in familiar terms. These facilities will allow log interpretation model designers, who are non-computer specialists, to produce high quality software as the end result of a model design.     

Visualizing program dependencies: An experimental study

This paper addresses the problem of visualizing program dependencies (i.e. entities and their relations). A code visualization tool that maintains a repository of structural and functional dependencies for C programs is described. Visualization of such dependencies is accomplished by using a presentation model which combines data and control flow information. Moreover, transformation mechanisms and partitioning techniques used by the tool provide the means for managing large graphical representations. The quantitative results from an experimental study using this tool indicate that the productivity of its users was increased and that the quality of changes made during a program modification exercise was improved. Furthermore, the qualitative results have shown that its presentation model, transformation mechanisms and partitioning techniques constitute a promising platform for the comprehension and maintenance of C programs. Finally, the outcome of an empirical evaluation of the tool and the enhancement of its functionality and user interface are also discussed in this paper.     

Strongest postcondition semantics as the formal basis for reverse engineering

Reverse engineering of program code is the process of constructing a higher level abstraction of an implementation in order to facilitate the understanding of a system that may be in a “legacy” or “geriatric” state. Changing architectures and improvements in programming methods, including formal methods in software development and object-oriented programming, have prompted a need to reverse engineer and re-engineer program code. This paper describes the application of the strongest postcondition predicate transformer (sp) as the formal basis for the reverse engineering of imperative program code.     

Incorporating Software Visualization in the Design of Intelligent Diagnosis Systems for User Programming

Program diagnosis systems were developed to help users solve programming problems. By providing guidence on errors and misconceptions, these systems can help the users in writing programs and understanding their dynamic behavior. Features of software visualization which aim at providing visual and concrete depictions to the abstractions and operations of programs have also shown to be making programs more understandable. The main theme of this paper is to asses the usefulness of incorporating features of software visualization into the design of program diagnosis systems intended for novices. We report an empirical evaluation to assess the effectiveness of supporting visualization features during problem solving. The system used in the evaluation integrates visualzation and immediacy features and supports a model-tracing based approach to program diagnosis. Unlike other similar systems, our prototype system supports a more flexible style of interaction by increasing the grain size of diagnosis to a complete programming statement. The evaluation reported here seems to suggest that when supported with visualization features, systems for program diagnosis tend to be more effective in helping the users during problem solving.     

Intelligent computer-aided-design systems: a synergical approach of artificial intelligénce and engineering

A synergism has begun to surface from the artificial intelligence (AI) and engineering communities: an effort to apply AI techniques to engineering problem-solving activities, and to study problems arisen from various engineering fields as a way to develop AI theories and methodologies. This paper first discusses the needs of such a synergical approach and identifies in a broad perspective some AI techniques currently being applied to engineering. It then describes a system, called KREATOR, which applies qualitative reasoning, a subfield of AI, to computer-aided design (CAD). The key observation is that an engineer designer's qualitative knowledge can offer a good basis for the reasoning of device behaviors. Such knowledge, however, is not captured by conventional CAD systems for lack of good representations. KREATOR is a knowledge capturing scheme that allows the designers to record their qualitative knowledge of how mechanical devices behave, KREATOR then automatically generates qualitative simulations.     

Information visualization and visual data mining

Never before in history has data been generated at such high volumes as it is today. Exploring and analyzing the vast volumes of data is becoming increasingly difficult. Information visualization and visual data mining can help to deal with the flood of information. The advantage of visual data exploration is that the user is directly involved in the data mining process. There are a large number of information visualization techniques which have been developed over the last decade to support the exploration of large data sets. In this paper, we propose a classification of information visualization and visual data mining techniques which is based on the data type to be visualized, the visualization technique, and the interaction and distortion technique. We exemplify the classification using a few examples, most of them referring to techniques and systems presented in this special section     

State of the Art Report on Video‐Based Graphics and Video Visualization

In recent years, a collection of new techniques which deal with video as input data, emerged in computer graphics and visualization. In this survey, we report the state of the art in video‐based graphics and video visualization. We provide a review of techniques for making photo‐realistic or artistic computer‐generated imagery from videos, as well as methods for creating summary and/or abstract visual representations to reveal important features and events in videos. We provide a new taxonomy to categorize the concepts and techniques in this newly emerged body of knowledge. To support this review, we also give a concise overview of the major advances in automated video analysis, as some techniques in this field (e.g. feature extraction, detection, tracking and so on) have been featured in video‐based modelling and rendering pipelines for graphics and visualization.     

并行程序开发平台的可视化实现*

并行程序可视化平台的实现有利于网络并行计算的发展,基于WPVM 3.4平台,构建并实现了一个网络并行可视化平台,它由任务描述器、通信代码生成器、代码插入器等主要模块组成。主要讲述了该平台的可视化实现部分,阐述了如何将用户前台的设置按照规则转变为后台的PVM原语代码自动插入,帮助并行程序开发人员从复杂的并行通信的烦琐性和并行系统的底层运作中解放出来。     

Automatic Parallelization: Executing Sequential Programs on a Task-Based Parallel Runtime

There are billions of lines of sequential code inside nowadays’ software which do not benefit from the parallelism available in modern multicore architectures. Automatically parallelizing sequential code, to promote an efficient use of the available parallelism, has been a research goal for some time now. This work proposes a new approach for achieving such goal. We created a new parallelizing compiler that analyses the read and write instructions, and control-flow modifications in programs to identify a set of dependencies between the instructions in the program. Afterwards, the compiler, based on the generated dependencies graph, rewrites and organizes the program in a task-oriented structure. Parallel tasks are composed by instructions that cannot be executed in parallel. A work-stealing-based parallel runtime is responsible for scheduling and managing the granularity of the generated tasks. Furthermore, a compile-time granularity control mechanism also avoids creating unnecessary data-structures. This work focuses on the Java language, but the techniques are general enough to be applied to other programming languages. We have evaluated our approach on 8 benchmark programs against OoOJava, achieving higher speedups. In some cases, values were close to those of a manual parallelization. The resulting parallel code also has the advantage of being readable and easily configured to improve further its performance manually.     

An experimental study of the impact of visual semantic feedback on novice programming

Prior empirical studies of programming have shown that novice programmers tend to program by exploration, relying on frequent compilation and execution of their code in order to make progress. One way visual and end-user programming environments have attempted to facilitate this exploratory programming process is through their support of “live” editing models, in which immediate visual feedback on a program's execution is provided automatically at edit time. Notice that the notion of “liveness” actually encompasses two distinct dimensions: (a) the amount of time a programmer must wait between editing a program and receiving visual feedback (feedback delay); and (b) whether such feedback is provided automatically, or whether the programmer must explicitly request it (feedback self-selection). While a few prior empirical studies of “live” editing do exist, none has specifically evaluated the impact of these dimensions of “live” editing within the context of the imperative programming paradigm commonly taught in first-semester computer science courses. As a preliminary step toward that end, we conducted an experimental study that investigated the impact of feedback self-selection on novice imperative programming. Our within-subjects design compared the impact of three different levels of feedback self-selection on syntactic and semantic correctness: (a) no visual feedback at all (the No Feedback treatment); (b) visual feedback, in the form of a visualization of the program's execution state, provided on request when a “run” button is hit (the Self-Select treatment); and (c) visual feedback, in the form of a visualization of the program's execution state, updated on every keystroke (the Automatic treatment). Participants in the Automatic and Self-Select treatments produced programs that had significantly fewer syntactic and semantic errors than those of the No Feedback treatment; however, no significant differences were found between the Automatic and Self-Select treatments. These results suggest that, at least in the case of novice imperative programming environments, the benefits of delivering a continuously updated visual representation of a program's execution may fail to justify the substantial costs of implementing such feedback. We recommend that programming environment designers instead direct their efforts toward carefully considering when programmers will be ready to take advantage of the feedback that is coming toward them, along with what content will be of most benefit to them.     

DISCOVER: AN INTELLIGENT DISCOVERY PROGRAMMING SYSTEM

Much of research in programming environments for novices has been polarized toward two opposite domains: guided programming environments and free programming environments. Intelligent programming tutors and systems that represent guided environments concentrate mainly on helping novices in acquiring programming skills through a series of problem-solving situations. Most of these systems tend to ignore the significance of a preproblem solving, dynamic, visualization-based, and free environment which would help novices in compiling an effective programming knowledge through a discovery-like process. Free programming environments, on the other hand, concentrate exclusively on helping novices to build correct programming knowledge through visible, exploratory, and free discovery environments. These systems generally tend to neglect the issue of supporting those aspects of intelligent diagnosis and tutoring, through which novices can transform their program knowledge into programming skill. A system has been developed called DISCOVER that occupies a unique niche between the two domains discussed above. The system emphasizes a synthesis-based framework which integrates free programming with guided programming features, and supports software visualization and immediacy of feedback to come up with an environment that facilitates learning programming through discovery and guidance. To assess the usefulness of the design framework presented in this paper, two pilot performance evaluations were conducted. The results provided a number of interesting insights into the implication of incorporating visualization and immediacy features, along with intelligent program diagnosis into the design of programming systems intended mainly for novices.     

Prolog/Rex-a way to extend Prolog for better knowledgerepresentation

Prolog/Rex represents a powerful amalgamation of the latest techniques for knowledge representation and processing, rich in semantic features that ease the difficult task of encoding heterogeneous knowledge of real-world applications. The Prolog/Rex concept mechanism lets a user represent domain entities in terms of their structural and behavioral properties, including multiple inheritance, arbitrary user-defined relations among entities, annotated values (demons), incomplete knowledge, etc. A flexible rule language helps the knowledge engineer capture human expertise and provide flexible control of the reasoning process. Additional Prolog/Rex strength that cannot be found in any other hybrid language made on top of Prolog is language level support for keeping many potentially contradictory solutions to a problem, allowing possible solutions and their implications to be automatically generated and completely explored before they are committed. The same mechanism is used to model time-states, which are useful in planning and scheduling applications of Prolog/Rex     

Using human error information for error prevention

Developing error-free software requirements is of critical importance to the success of a software project. Problems that occur during requirements collection and specification, if not fixed early, are costly to fix later. Therefore, it is important to develop techniques that help requirements engineers detect and prevent requirements problems. As a human-centric activity, requirements engineering can be influenced by psychological research about human errors, which are the failings of human cognition during the process of planning and executinge a task. We have employed human error research to describe the types of problems that occur during requirements engineering. The goals of this research are: (1) to evaluate whether understanding human errors contributes to the prevention of errors and concomitant faults during requirements engineering and (2) to identify error prevention techniques used in industrial practice. We conducted a controlled classroom experiment to evaluate the benefits that knowledge of errors has on error prevention. We then analyzed data from two industrial surveys to identify specific prevention and mitigation approaches employed in practice. The classroom study showed that the better a requirements engineer understands human errors, the fewer errors and concomitant faults that engineer makes when developing a new requirements document. Furthermore, different types of Human Errors have different impacts on fault prevention. The industry study results identified prevention and mitigation mechanisms for each error type. Human error information is useful for fault prevention during requirements engineering. There are practices that requirements engineers can employ to prevent or mitigate specific human errors.     

Incorporating domain knowledge into attribute‐oriented data mining

It is frequently the case that data mining is carried out in an environment which contains noisy and missing data. This is particularly likely to be true when the data were originally collected for different purposes, as is commonly the case in data warehousing. In this paper we discuss the use of domain knowledge, e.g., integrity constraints or a concept hierarchy, to re‐engineer the database and allocate sets to which missing or unacceptable outlying data may belong. Attribute‐oriented knowledge discovery has proved to be a powerful approach for mining multi‐level data in large databases. Such methods are set‐oriented in that attribute values are considered to belong to subsets of the domain. These subsets may be provided directly by the database or derived from a knowledge base using inductive logic programming to re‐engineer the database. In this paper we develop an algorithm which allows us to aggregate imprecise data and use it for multi‐level rule induction and knowledge discovery. ©2000 John Wiley & Sons, Inc.