Zig Zag

The XANADU(R) ZIGZAG(TM) Hyperstructure Kit is available as shareware for $25. The download for the PC will write a Linux boot floppy disk that contains the software.

ZigZag has been playing on my mind lately. It is a excellent and elegant solution to a number of problems. I recommend checking it out.

From their website ...

Zigzag 0.53 is a very early version of a very unusual piece of software by TedNelson.

...VERY SIMPLE and yet VERY HARD TO EXPLAIN. (These two properties are signs of a new paradigm.)

Though perhaps also of poor communication skills.

MIT's Technology Review asks ...

The visionary who dreamed up hypertext has never delivered any software... until now. Will ZigZag pass the test?

Article now requires subscription


Hmm, is this really so difficult to explain? It seems that a particular "rank" of connected cells behaves exactly like a doubly-linked list. But a given cell may form a part of many such ranks. Cells distinguish the ranks that they are in using a classifier called "dimension".

The conventions for producing human-readable views onto this very general structure work by mapping the three dimensions currently chosen by the user onto three orthogonal directions in space. That's quite cute. And it's nice that the model doesn't need to appeal to anything else to be useful: the idea of representing the currently selected cells by linking each one of them to a cell in a rank joined along the selection dimension is nice.

The explanations given in the tutorial seem obfuscated by the continual claims that ZZspace is not like this, not like that, and in fact not like anything else whatsoever in the world. Ironically, the claimed "paradoxical" properties of ZZspace, particularly that two or more ranks can share more than one cell, seem to be an artifact of trying to present ranks as if traversing them corresponded to movement in a direction (which we're explicitly told it doesn't).

It would be interesting to know where the Zig Zag idea came from. It seems as if one could possibly get there by starting with the idea of a doubly-linked list, then relaxing the implicit constraint that a cell has only the one pair of pointers. That kind of thing is very very hard, exactly because the constraint is so well hidden.

The following deals with the current prototype. If you are interested in the underlying principle - of course you are! - first read the tutorial at the website mentioned above.

I have tried to understand what this zigzag thing is all about. I think I understand the concept somehow, but its very hard to describe...

Starting zigzag, you will see two roughly equeal Windows, the left is called "Action Window", the one on the right "Data Window"

Hey, its textmode, so here you see it:

 +---------- Action Window (I) --------+------------- Data Window (I) --------+
 |+---> +d.1                           |+---> +d.1                            |
 ||\                                   ||\                                    |
 || \| +d.3                            || \| +d.3                             |
 |V -+                                 |V -+                                  |
 |+d.2                                 |+d.2                                  |
 |                                     |                                      |
 |                                     |                                      |
 |                                     |                                      |
 |                                     |                                      |
 |                                     |                                      |
 | d.1- Midden - Home                  |  d.1 - Midden - Home                 |
 |                  |                  |                   |                  |
 |               #Edit - #Clone        |                #Edit q#Clone         |
 |                  |                  |                   |                  |
 |               #L-insq#R-insq#U-ins  |                #L-insq#R-insq#U-ins  |
 |                  |                  |                   |                  |
 |               #Deletq#L-breq#R-bre  |                #Deletq#L-breq#R-bre  |
 |                  |                  |                   |                  |
 |               #Mark                 |                #Mark                 |
 |                  |                  |                   |                  |
 |               #L-Hopq#R-Hopq#U-Hop  |                #L-Hopq#R-Hopq#U-Hop  |
 +-----------------------------------0-+-------------------------------------0+

There are two cursors, an "action cursor" associated with the left Window, and a Data-cursor, for the right. You can move the action-courser on the right with keys esfc, the Data-courser on the left simply with the arrow-keys.

Zigzag is about single pieces of Information called "cells". These cells can be created, edited and deleted.

Pressing "Enter" will evaluate the content of the Cell the Action-cursor points at. (If its a command-cell, which start with "#")

Pressing <CTRL>-k fires up vi, so you can edit the Cell, (big K for left Window). q/Q will show a small rectangle with the content of the cell.

Links can be made between Cells. The interesting thing is, that these Links are categorized using "Dimensions".

Quote: STRUCTURE DIMENSIONS

The cell structure may have any number of dimensions, though the system begins with only seven (d.1, d.2, d.3, d.cursor, d.clone, d.mark, d.contain, d.contain2). (The functions of these are explained at the end.)

Two off these Dimensions are visualised by displaying a two-demensional graph of the cell-structure on the screen.

Quote: VIEWING AXES

There are three viewing axes: x, y and z. The current view in each window maps the cell structure to the viewing axes, assigning these three axes to whatever structure dimensions you specify.

VIEWING THE STRUCTURE DIMENSIONS

You may quickly change the mapping of the ZigZag world's dimensions to the window's viewing axes.

Typing x, y or z in lower case causes the view in the right window to step by one dimension on the specified viewing axis (x, y or z). Typing X, Y or Z in upper case causes the view in the left window to step by one dimension in the specified viewing axis (X, Y or Z)

DIMENSION FUNCTIONS.
Structure dimensions d.1, d.2 and d.3 have no assigned functions. Think of d.1 as useful for headings, d.2 as useful for virtual lists, d.1 and d.2 together for ordinary tables and very interesting basket-weave structures, and d.3 as a third dimension.

The "Cursor" dimension, d.cursor, is the dimension on which a cursor (actually a cell) is connected to the cell it's on (the accursed cell); the user cannot change connections on the cursor dimension, except by explicitly moving the cursor, but the cursor dimension can be viewed like any other dimension.

The "Clone" dimension, d.clone, is the dimension on which a cloned cell is always connected to its original; this connection is enforced by the system, so you cannot disconnect a clone from its master, though you can rearrange clones on the clone dimension. Note that editing any clone or its master changes all the others of outs chain -- i.e., any clones of that same master, and the master itself, all are changed identically if any is changed.

Making Links to existing pages require that you clone the cell. So the viewing the Clone-Dimension you see the "Backlinks" of that Cell.

The "Mark" dimension (not implemented) will be for marking cells, especially strips and groups of cells, in preparation for some operation. The marked cells will have other cells (marking cells) connected to them on the Mark dimension.

The "Contain" dimension, d.contain, is the dimension representing containment: we represent cell A as being inside cell B by connecting it posward from B on the Contain dimension. (In the next version it will be called d.inside.)

The "Contain2" dimension (which willl be called "d.contents" in tne next version) allows a given cell to contain more than one thing. Anything contained after the first cell contained is posward on d.contain2 from the first cell contained.

By looking at these specific connections, the system quickly determines what a cell contains or is contained by.

This looks very interesting... but I have to really use the system to actually understand it. -- MarcusDenker
See also http://gzigzag.sourceforge.net. There are several informative postscript documents as well as an early (as of 3/13) version implemented in Java (available from the CVS repository). -- BrianTheado

Note that gzigzag is now known as gzz, see http://www.nongnu.org/gzz/ (due to a trademark conflict with TedNelson). 0.8alpha should be out soon (tm); besides a jar bundle, there's a high-end graphical version based on opengl, and underlying Xanadu coming up as a p2p network hopefully.. -- ToniAlatalo

It appears that gzz development has ceased. The reason given is that the data structure underlying ZigZag is patented, and not available for use under a licence that would enable open source development. Seems like a pity.

(2005) gzz has been superseded by Fenfire. http://www.fenfire.org/

Try out ZigZag online - a dynamic JavaScript/XML implementation of TedNelson's ZigZag data navigation scheme, at http://www.ecs.soton.ac.uk/~lac/zigzag/.


And my response to all the people above so desperately peddling zigzag is a big fat YAWN. How stupid do these people think we are, that we'd invest time in some product based on a hyped up description of what it is, which we really don't care about, when we don't even know what the hell it's for? Oh wait, they were stupid enough to do that. They don't provide one single reason why anyone should go to the trouble of trying out zigzag, and given Ted Nelson's penchant for grossly overhyped crap, I'm not giving him any benefit of the doubt.


CategoryCreativity

EditText of this page (last edited July 24, 2005) or FindPage with title or text search

Meatball