Vu: visual user-interface design

The development of interactive visual applications is a complex work, usually performed with the help of advanced visual programming environments. Starting from the GUI’s visual specifications, the programming environment generates the corresponding code that implements the interface. In most cases, designers and developers have no tools to keep control over the usability and the maintainability of the resulting applications. In fact, the success of an information system depends on the accessibility and usability of its interface. The evaluation of visual environments is traditionally performed by means of expert-based evaluations or by testing with end users. In this paper, we describe a methodology to design, specify and evaluate interactive visual applications, based on the SR-Action Grammars formalism. We describe how it is possible to assess the usability metrics of consistency, completeness and user control by means of checks performed at high abstraction level of the visual language. In particular, we improve the formalism of the SR-Action Grammars (Cassino et al. (2003): SR-Task Grammars: A Formal Specification of Human Computer Interaction for Interactive Visual Languages – 2003 Symposium on Visual Languages and Formal Methods (VLFM ‘03) – IEEE Symposia on Human-Centric Computing Languages and Environments (HCC’03)) to specify visual languages, so to perform usability checks by the management of the production rules. TAGIVE (Cassino et al. (2006): A Methodology for Computer Supported Development of Interactive Visual Applications – WSEAS Transactions On Information Science and Applications Journal.) is the tool that allows to design interactive visual environments and to generate the related formal specification in automatic manner. Thanks to the controls performed at formal level, the system guides the designer in the correct development of the application.

This paper explores both the design and classroom usage of a visual and interactive programming environment. This environment, named JavaTown, provides a visual representation of the inner workings of object-oriented programs, in which on-screen characters are literally depicted as carrying messages to each other and remembering values. JavaTown was created to aid in the introduction of some of the most elusive concepts in the CS1/CS2 curriculum: object references, parameter passing, variable scope, recursion, and linked lists.

This study aimed to investigate whether the experience of learning using a visual interactive learning environment through visualization impacts performance and dimensions of creative potential in terms of creative thinking. Sixteen (16) non-random non-major undergraduate computer science students learning computer programming subjects were exposed to a visual interactive learning environment through visualization in a pre-experimental single group pre-posttest research design. Before and after participants learn using visual interactive learning environment through visualization for six (6) weeks, they must complete three Visual tests and two verbal tasks of the Torrance Tests of Creative Thinking (TTCT). Both descriptive and inferential statistics were used to analyze the data. The study showed significant evidence that the performance and creative level of the students are better after learning using a visual interactive learning environment except for Verbal Fluency and Verbal Flexibility dimensions of Creative thinking. Implications of these findings for future research are discussed.

End-user programming provides a unique opportunity to study informal computer science education and knowledge acquisition in the real world. We seek to explore the use of community-based scaffolding to deliver computing content knowledge to an audience of graphic design professionals who engage in scripting. We propose an online community that leverages prepared, instructional case studies alongside tools that promote collaborative development and code review activities.

Interactive programming environments , Interactive programming environments , مرکز فناوری اطلاعات و اطلاع رسانی کشاورزی

TEStool: A visual interactive environment for modeling autocorrelated time series

This paper presents the design and implementation of an open visual object-oriented programming environment (VOOPE). The environment supports a programming approach in which a program is created using extended visual objects (EVOs) - the objects having visual forms and dynamic behaviors. The environment allows creation of EVOs and modification of their behavior to adapt the changing software requirements. Thereby, VOOPE allows incremental software development using the learning capability of EVOs without rebuilding the software.

New generations are using and playing with mobile and computer applications extensively. These applications arethe outcomes of programming work that involves skills, such as computational and algorithmic thinking. Learningprogramming is not easy for students children. In recent years, academic institutions like theMassachusetts Institute of Technology (MIT) and hi-tech companies, such as Google and Khan Academy, haveintroduced online environments to facilitate the teaching and learning of programming. Most of these programmingenvironments are web-based, and interactive and are supported with visual multimedia features. Therefore, they havebecome easy to use, very attractive and helpful for teaching children how to program and to develop theiralgorithmic and computational thinking skills. The proposed presentation will describe research that examined theteaching of a course to primary school children based on three on-line interactive environments: "Plastelina" for logicgames, "Code with Anna and Elsa" via the Hour of Code project block-oriented programming environment, forblock programming and "Turtle Academy" for textual programming in the Logo language. The current researchincluded the development, implementation and evaluation of the course at an elementary school. In addition, it wasaimed at investigating the pupils' attitudes toward the learning of computer programming, both before and afterparticipation in the course. The results revealed that the pupils' attitudes towards programming remained positivealso also after the participation in the course. It was also found that programming improved children's problemsolving skills.

Alien is a generator for interactive language-specific programming environments. The system makes a language definition environment available to the language definer and supports him with an interactive generator. Using these tools every syntactic unit of a language can be made available. This can be done by a method of stepwise testing, correction and expansion. Fully defined environments can easily be restricted to subsets of a language.This paper introduces a method making a large software product executable on small UNIX machines as well as a survey of the system's components. These are designed to make the implementation on PCs effective and to develop a powerful generator for programming environments. Therefore the results are of interest to all projects in the programming environment field.ALIEN has been implemented in C running on Siemens PC-X, PC-X10, PC-MX-2 machines and Atari PC. Implementation on Apollo and SUN workstations is still in progress and on IBM PC is planned.The project is supported by the Stiftung Volkswagen-werk under grant 1/61 602.

Future interactive virtual environments will be “attention-aware,” capable of predicting, reacting to, and ultimately influencing the visual attention of their human operators. Before such environments can be realized, it is necessary to operationalize our understanding of the relevant aspects of visual perception, in the form of fully automated computational heuristics that can efficiently identify locations that would attract human gaze in complex dynamic environments. One promising approach to designing such heuristics draws on ideas from computational neuroscience. We compared several neurobiologically inspired heuristics with eye-movement recordings from five observers playing video games, and found that human gaze was better predicted by heuristics that detect outliers from the global distribution of visual features than by purely local heuristics. Heuristics sensitive to dynamic events performed best overall. Further, heuristic prediction power differed more between games than between different human observers. While other factors clearly also influence eye position, our findings suggest that simple neurally inspired algorithmic methods can account for a significant portion of human gaze behavior in a naturalistic, interactive setting. These algorithms may be useful in the implementation of interactive virtual environments, both to predict the cognitive state of human operators, as well as to effectively endow virtual agents in the system with humanlike visual behavior.

A large variety of tools for program development are available today. The tools tend to become more and more sophisticated, but are usually isolated utilities that have to be applied one by one. An alternative to the tool-box approach is an integrated programming environment utilizing powerful interaction facilities.The design and a prototype implementation of an integrated programming environment is described and the qualities of such a system are discussed. One important design goal was to obtain an environment which has an execution efficiency comparable to that of a system based on a conventional compiler, and a reasonable interaction speed. For this reason the system is based on incremental translation to native code. Another goal was to obtain incremental execution, i.e. the possibility to modify an executing program. The properties of this mechanism and its consequences are investigated.

VPL is a visual programming language and environment for interactive image processing. VPL uses a novel system architecture which separates interaction and computation components in order to provide a highly interactive visual programming user-interface. VPL is based on a declarative, demand driven dataflow model of computation. It is a practical, usable visual programming system, integrating tools for browsing, inspecting and editing components and documentation. VPL also provides data persistence and data import/export mechanisms. The visual programming model supports both function extensibility and higher order functions, allowing users to build their own program dataflow structures within the VPL environment. >

Article Free Access Share on Degrees of comprehension: children's understanding of a visual programming environment Authors: Cyndi Rader Department of Computer Science, University of Colorado, Boulder, CO Department of Computer Science, University of Colorado, Boulder, COView Profile , Cathy Brand Department of Computer Science, University of Colorado, Boulder, CO Department of Computer Science, University of Colorado, Boulder, COView Profile , Clayton Lewis Department of Computer Science, University of Colorado, Boulder, CO Department of Computer Science, University of Colorado, Boulder, COView Profile Authors Info & Claims CHI '97: Proceedings of the ACM SIGCHI Conference on Human factors in computing systemsMarch 1997 Pages 351–358https://doi.org/10.1145/258549.258793Online:27 March 1997Publication History 24citation1,017DownloadsMetricsTotal Citations24Total Downloads1,017Last 12 Months24Last 6 weeks6 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF

No abstract available.

The Workshop on Scientific Visualization Environments at Visualization '91 was organized with several purposes in mind. First and foremost was to bring together widely dispersed researchers so they could share information in a relatively informal and interactive environment. The organizers believed this would establish working relationships between the participants, which was a second purpose. It was hoped that a workshop could generate a focus and identify important research directions in the field. Finally, we believed the workshop report could provide a useful overview to a broader audience.With these purposes in mind, we established two specific objectives: (i) review the state of the art and (ii) identify key research issues and directions. Reaching these objectives in a short two day workshop would require an effective mechanism for organizing the discussions. The organizing principle we chose was a software design principle suggested by Dijkstra [ 1 ] some twenty years ago: the notion of an abstract machine. We considered a visualization environment as a special purpose, very high level computer ideally suited to the needs of scientific visualization. We then organized the workshop discussions around the questions of what the memory (data types), instruction set (operations) and control mechanisms (programming interfaces) of this machine might be.Using this organizing principle, we established the following agenda: Monday morning: position statements. Each participant presented a ten minute summary of their position paper Monday afternoon: data types and interfaces What are the (abstract) data types on which a visualization environment is based? What are the interfaces for importing and exporting data from the environment? Tuesday morning: control structures and architecture What are the mechanisms for sequencing and combining the primitive operations provided by the data types. What are the interaction and programming interfaces to the environment? Tuesday afternoon early: reference model Do we understand visualization environments well enough to construct a useful general model of their structure and function? Tuesday afternoon late: other issues and summary What issues are not addressed in the other sections? What have we accomplished? For each section we followed a simple procedure. The organizers presented introductory remarks consisting of a brief review of the state of the art and identification of research issues. The introductory remarks served as a starting point for discussions which followed. Participants were given copies of the organizers' remarks and asked to take notes for contribution to the report. The notes were collected at the end of the workshop and collated into this report. In addition, participants reviewed the first draft of the report and made additional contributions.