David Wolber

Adding rule-based reasoning to a demonstrational interface builder

This paper presents a demonstrational interface builder with improved reasoning capabilities. The system is comprised of two major components: an interactive display manager and a rule-based reasoner. The display manager provides facilities to draw the physical appearance of an interface and define interface behavior by graphical demonstration. The behavior is defined using a technique of stimulus-response demonstrations. With this technique, an interface developer first demonstrates a stimulus that represents an action that an end user will perform on the interface. After the stimulus, the developer demonstrates the response(s) that should result from the given stimulus. As the behavior is demonstrated, the reasoner observes the demonstrations and draws inferences to expedite behavior definition. The inferences entail generalizing from specific behavior demonstrations and identifying constraints that define the generalized behavior. Once behavior constraints are identified, the reasoner sends them to the display manager to complete the definition process. When the interface is executed by an end-user, the display manager uses the constraints to implement the run-time behavior of the interface.

A demonstrational technique for developing interfaces with dynamically created objects

The development of user inteijaces is often facilitated by the use of a drawing editor. The user interface specialist draws pictures of the different “states” of the inte~ace and passes these specifications on to the programmer. The user interface specialist might also use the drawing editor to demonstrate to the programmer the interactive behavior that the interface should exhibit; that is, he might demonstrate to the programmer the actions that an end-user can pe~orm, and the graphical manner by which the application should respond to the end-user’s stimuli. From the specljications, and the in-person demonstrations, the programmer implements a protoppe of the interface. DEMO is a User Interface Development System (UIDS) that eliminates the programmer from the above process. Using an enhanced drawing editor, the user interface specialist demonstrates the actions of the end-user and the system, just as he would if the programmer were watching. However no programmer is necessary: DEMO recorak these demonstrations, makes generalizations from them, and automatically generates a prototype of the inte~ace. Key Phrases: User Interface Development System

Using app inventor in a K-12 summer camp

Educators are often seeking new ways to motivate or inspire students to learn. Our past efforts in K-12 outreach included robotics and media computation as the contexts for teaching Computer Science (CS). With the deep interest in mobile technologies among teenagers, our recent outreach has focused on using smartphones as a new context. This paper is an experience report describing our approach and observations from teaching a summer camp for high school students using App Inventor (AI). The paper describes two separate methods (one using a visual block language, and another using Java) that were taught to high school students as a way to create Android applications. We observed that initiating the instruction with the block language, and then showing the direct mapping to an equivalent Java version, assisted students in understanding app development in Java. Our evaluation of the camp includes observations of student work and artifact assessment of student projects. Although the assessment suggests the camp was successful in several areas, we present numerous lessons learned based on our own reflection on the camp content and instruction.

Teaching CS principles with app inventor

Mobile phone programming can provide an authentic and engaging hook into computer science. With App Inventor, developed by Google and recently moved to MIT, programming Android apps is as easy as clicking blocks together. App Inventor has been used successfully in after school programs, roadshows, summer camps, teacher workshops, and computer science classrooms from middle school through college. In this tutorial, participants will get an overview of App Inventor including project ideas and sample curriculum. In addition, the new CS Principles project will be introduced to participants, including a discussion of the Big Ideas and Learning Objectives that have been defined by the College Board and NSF. Specifically, the use of App Inventor as a platform for teaching CS Principles will be discussed with examples from an official Principles pilot effort within Alabama. A virtual panel with App Inventor experts will allow participants to interact and ask questions about the exciting opportunities available with App Inventor.

Novel approaches to CS 0 with app inventor for android

1. SUMMARY Googles App Inventor for Android (AIA) is a visual programming environment for creating mobile phone applications that is designed to be accessible and appealing to college nonmajors taking introductory courses in computer science. Specifically, AIA provides a development environment similar to StarLogo TNG [7], Scratch [5], and Alice [2] but enabling users to create mobile applications incorporating social networking, location awareness, and Web-based services for Googles Android platform [1].

Pavlov: an interface builder for designing animated interfaces

Conventional interface builders provide little support for interactive development of interfaces with application-specific graphics. Some Programming by Demonstration (PBD) systems do provide such support, but none provide full support for demonstrating interfaces, such as those in games, in which the graphics are animated. This article proposes a number of techniques for creating animated interfaces, all of which have been included in an exploratory system, Pavlov. Many of the techniques are based on the addition of timing controls to a form of PBD called stimulus-response demonstration. Others are based on an adaptation of a traditional animation time-line that integrates end-user interaction with animation. The article also evaluates Pavlov with (1) a comparison to other PBD systems in terms of the behaviors that can be specified interactively and (2) a report on an informal user study comparing development in Pavlov to development in a conventional interface builder.

Exposing document context in the personal web

Reconnaissance agents show context by displaying documents with similar content to the one(s) the user currently has open. Research paper search engines show context by displaying documents that cite or are cited by the currently open document(s). We present a tool that applies such ideas to the personal web, that is, the space rooted in user documents but tightly connected to web documents as well. The tool organizes the personal web with a single topic hierarchy based on direct links, instead of the traditional file, bookmark, and (hidden) direct link hierarchies. The tool allows a user to easily navigate through related user and web documents, no matter whether the documents are related by directory-document, bookmark-document, direct-link, or even similar content relationships.

Pavlov: programming by stimulus-response demonstration

Pavlov is a Programming By Demonstration (PBD) system that allows animated interfaces to be created without programming. Using a drawing editor and a clock, designers specify the behavior of a target interface by demonstrating stimuli (end-user actions or time) and the (time-stamped) graphical transformations that should be executed in response. This stimulus-response model allows interaction and animation to be defined in a uniform manner, and it allows for the demonstration of interactive animation, i.e., game-like behaviors in which the end-user (player) controls the speed and direction of object movement.

Designing dynamic web pages and persistence in the WYSIWYG interface

WebSheets is a programming in the WYSIWYG interface tool for building dynamic web pages that access and modify databases. Without programming, designers can specify not only the presentation of a page, but the dynamic content as well. This capability is facilitated through a novel application of Programming by Example (PBE), Query by Example (QBE), and spreadsheet formulas within the WYSIWYG HTML editor environment.

Programming by example: intelligence in demonstrational interfaces

increased intelligence in the system, which AI algorithms have proven useful for demonstrational interfaces, and how we cope with such well-known intelligent-interface-usability issues as knowing what the system can do and what it is doing at any given moment. Demonstrational interfaces allow the user to perform actions on concrete example objects (often using direct manipulation), though the examples represent a more general class of objects. These actions allow the user to create “parameterized” procedures and objects without being required to learn a programming language. We use the term “demonstrational,” because the user demonstrates the desired result through example values. Demonstrational systems vary greatly along many dimensions; some of these systems use inferencing, whereby the system employs heuristics to guess the generalization from the examples; others do not try to infer the generalizations and instead require the user to describe explicitly which of the examples’ properties should be generalized. One way to determine whether a system uses inferencing is that it can perform an incorrect action, even when the user makes no mistakes. A system that doesn’t employ inferencing always performs the correct action if the user is