Improvise users build and browse multiview visualizations interactively using a simple shared-object coordination mechanism coupled with a flexible, expression-based visual abstraction language. By coupling visual abstraction with coordination, users gain precise control over how navigation and selection in a visualization affects the appearance of data in individual views. As a result, it is practical to build visualizations with more views and richer coordination in Improvise than in other visualization systems. Building and browsing activities are integrated in a single, live user interface that lets users alter visualizations quickly and incrementally during data exploration.

A major goal for Improvise has been to increase coordination flexibility substantially without significantly decreasing ease-of-use, as compared to similar systems; to make simple coordinations (like synchronized scrolling) easy, and complex coordinations (like semantic zoom) possible. Highly-coordinated visualizations appear to be much easier to build in Improvise than other visualization systems because views are connected indirectly through a coordination model in which navigational parameters, selections, data, and visual encodings are shared objects that can be edited on-the-fly. Unlike other visualization systems, there is no need to link views pairwise or in sequence to achieve complex coordination semantics.

Improvise is similar to other visualization systems based on the relational data model. These systems follow a recent trend toward interactive construction approaches that employ simple combinations of well-known coordination and view types. Although building small visualizations in these systems is very easy, the number of views and the degree of coordination that can be practically incorporated during data exploration is limited.

LinkWinds uses non-view controls to append clauses to queries for filtering purposes. The ability to reference shared objects in coordinated queries has a similar flavor. Whereas LinkWinds has a “track” mode in which mouse drags continuously update coordinated views, views in Improvise are always tightly coupled over all coordinations, including all coordinated queries.

IVEE automatically selects appropriate controls (such as range sliders or checkboxes) for each data attribute in a given input table. Users can create one or more views (scatterplots, geographic maps, or cluster views) and specify projections that map attributes into view parameters. The conjunction of slider selections is used to filter the contents of all views (as well as the contents of the sliders themselves). In Improvise, views can be filtered independently using filter expressions that depend on navigation or selection in any combination of sliders or views.

DataSplash (Tioga-2) uses a data flow model to support advanced navigation features such as tunneling (wormhole-like hyperlinks), view cloning, and nested views. It supports end-user visualization construction in the form of tuple painting and a zoom layer manager for editing how tuples appear at different levels of magnification. VIQING is an extension of DataSplash that allows users to express queries by conjoining views into the visual equivalent of projections, selections, and joins. The elements of Improvise visualizations are declarative rather than procedural; users can generate nested views and semantic zoom, but approaches like tunneling and layer management have to be built into views as fixed features that allow little or no customization by the user.

Polaris automatically generates multiscale visualizations and the queries needed to draw them using a formal specification language. Zooming in Polaris is conceptually equivalent to traversing an edge of a zoom graph in which each node corresponds with a particular visual representation in a data cube. Nodes are drawn in a graphical notation that describes the visual query at that point in the graph. Because Improvise users build coordinated queries using custom-defined expressions, complex or unusual visual representations are possible, but simple or common ones cannot be manipulated as quickly or as easily as in Polaris.

CViews prototypes a coordination model in which explicit coordination objects in a coordination space manage visual parameters and access data using a dataflow model to define a particular type of coordination, such as brushing. Views connect to coordination objects through translation functions. The equivalent space in Improvise consists of coordinated query graphs that connect views through navigational parameters, selections, data, and expressions. In this space, coordinations exist implicitly as recognizable patterns of interactive dependence between views, rather than as explicit objects. Translation (spatial transformation, rendering, and so on) is an inherent function of views and is not user-customizable.

Snap-Together Visualization uses a relational data model that coordinates views using primary key actions. When two views are coordinated, invoking an action in one view causes the other view to perform its corresponding action. Actions are extensible and include loading (of a relation), selection (of tuples), and scrolling (over a list of tuples). Coordinated queries create similar interactive dependencies between views, but allow fine-grain user customization of dependencies between visual encodings as well as data.

DEVise uses a relational data model to coordinate multiple views of large datasets. Users can create, destroy, coordinate, and specify the contents of views interactively. Its only view—the scatterplot—and few coordination types—cursor, visual link, record link, and set link—are quite powerful. However, reproducing common visualization constructions in DEVise frequently involves convoluted chains of linked scatterplots (many of which are undesirable artifacts that must be intentionally hidden offscreen). Coordination graphs of DEVise visualizations reveal that all four coordination types can be reproduced by treating the X and Y ranges of scatterplots as shared objects or as dynamic parameters in simple query expressions. This discovery motivated the design of live properties and coordinated queries in Improvise.

Live properties may be thought of as an instance of the Model-View-Controller architecture with many small models. Similarly, the Abstraction-Link-View paradigm employs an encapsulated communications mechanism between views and data to link views shared by one or more users. However, live properties is not a constraint model (as in ThingLab). By implementing controls so as to change their live properties only in response to user interaction, potential cycles and deadlocks are avoided.

Athena MUSE defines integer values in bounded ranges as global parameters on views (“multidimensional information”) and uses bidirectional equality constraints to link parameters to view attributes through reversible linear functions (“declarative constraints”). Variables are like these parameters, but are neither bounded nor limited to integers. Bindings between variables and live properties are like declarative constraints limited to the identity function.