Package diva.pod

A Pod, in Diva, is an object that contains a "pile of data." This is our term for complex data structures that evolve with time.

See: Description

Interface Summary

Interface	Description
Channel	A Channel is the object that transmits data between a Transmitter and a Receiver.
Delta	A Delta is an incremental change in the data within some protocol.
Generator	A Generator is an object that generates data.
Pod	A Pod is a "pile of data." This is any complex evolving data structure.
Receiver	A Receiver is an object used by a Pod to receive data from some data source -- such as a data generator, or another Pod.
Transmitter	A Transmitter is an object used by a Pod to transmit data.
View	A View displays data in the Layout protocol.

Class Summary

Class	Description
Protocol	A Protocol is a reification of the concept of protocol, which underlies the connection of Generators, Pods, and Views.

Package diva.pod Description

A Pod, in Diva, is an object that contains a "pile of data." This is our term for complex data structures that evolve with time. Pods communicate with each other to form even more complex evolving data structures. For the background ideas from which this package sprang, see the "Thanksgiving Whitepaper".

The data in a Pod is typed, in a coarse sense. We refer to the "type" of data as a protocol. We have identified the following protocols, which we believe cover almost all of the kinds of data that you are ever likely to want to generate, store, view, and manipulate:

• Graph. A graph-structured Pod contains an attributed graph. Nodes of the graph are connected by edges. Optionally, nodes of the graph can contain ports, which can also be connected by edges.

  We allow a simple form of hierarchy between graphs, but more complex forms of hierarchy are implemented by connecting Pods.

• Tree. Although a tree can be viewed as a degenerate graph, it is sufficiently common to warrant its own protocol.

• Multivariate data. That is, tuples of data, where each slot in a tuple is named.

• Visual layout. Data that represents a visual graphic. All views of data from Pods are done using the visual layout protocol.

The data in a Pod can either be generated internally by the Pod, or come from an external source -- for example, a web crawler, a running simulation, or a visual editing program. A Pod that does not receive data, but only generates it, is called a Generator. By themselves, Pods cannot display data in any way, instead relying on Views to display data.

Pods communicate using Transmitters, Channels, and Receivers. The analogy should be obvious -- except that only a single Channel can be connected to any Transmitter or Receiver. For data to be communicated between two Pods, or between a Pod and a View, some external agent needs to set up the appropriate Channels between these objects. The structure of a system containing multiple Pods and Views can be arbitrarily complex. For example, the Smalltalk Model-View-Controller can be implemented by creating a single Pod, and multiple Views with two channels in either direction between the Pos and each View. (Actually, it's more complex than this, because we have to allow for Layout Pods, which are implicit in most descriptions of MVC. In a non-trivial MVC-style editor, the equivalent of a Layout Pod is required anyway, and significantly complicates the design. By making Layout Pods explicit and reusable, we expect a Pod-based editor to actually be simpler than the equivalent MVC one!)

However, much more than MVC is possible with Pods. For one thing, Pods can receive data from other Pods, and transmute it into a different protocol. Viewers (as opposed to editors) are much simpler to construct than using an MVC-based toolkit. By identifying the key protocols needed for data modeling and visualization, we increase possibilities for reuse -- code is written based around a well-defined protocol, rather than an application need and an ill-formed notion of the structure of the data therein.

In other words, we think Pods are the greatest thing since sliced bread.