Too much to Viewer

One of my key ideas is the generalised universal viewer. What it does is very simple. It views things. It views anything.

• If you give it text, it will view text.
• If you give it pictures, it will view pictures.
• If you give it sound it will view sound through speakers.
  

So far so good, but how about something more complicated? Well, if you consider it, the generic system output terminals must interface with our human sensory perceptions. That is, the five (main) senses

1. Sight
2. Sound
   
3. Touch
4. Taste
5. Smell

Next, we have to consider what we can realistically manipulate - we cannot manipulate smell, taste or touch with a simple physical instrument. That means that we are limited to sight and sound.

Next, we have to consider what types of sight and sound we can get:

• sight: 3d, 2d, 1d, 1+1d (i.e. lines that change length) 2+1d (i.e. animation/movies), 3+1d (i.e. moving 3d images)
• sound: 1d (i.e. pure note), 1+1d (i.e. music)

Finally, we have to consider what instrumentation we have currently:

• monitors: 2d, projected 3d
• speakers: 1d, 1+1d

To facilitate the +1 dimension (time) or the 3d, we can have extraction functions that take a 3d or a 2+1d or a 3+1d and then extracts a 2d slice from it. So we have a 2+1d projector, which takes a slice from a movie. We have a 3d projector, which takes a view from a 3d scene. Since our systems should be all lazy, it is possible to get away with only doing what is necessary to display what we are interested in.

Now, given a certain amount of information, which we want to display, the easiest way would be to convert it all to text, and then display it as text. At a more complicated level, we would like to be able create a view of this information more graphically. What we can do is to create segments in the information, and then render each component, and then juxtapose them. In fact, the juxtapose meta-container is only one of a set of useful meta-containers:

• Graphs - given a set of relationships and a set of entities, we can render the entities, and then draw in the relationships as a graph - use when there are explicit relationships
  
• Juxtapose - given some information, you specify where to place each element in separate metadata, that might reside as a file, or be generated from the information, and even be edited at run by a user, such as via dragging and dropping - use when there are implicit relationships
• Tree - given a tree, you can display it like in the form of trees, or sets, or zoomable interfaces - use when there are relationships of ownership

• Lists - given a list, we can turn it into a horizontal or vertical list. If you make a vertical list of horizontal lists, then you get a table for free - use when order is important
• Grid - given some elements, the grid display will automatically arrange it into a grid to maximise the size of each grid tile. this can be used for toolbars and the such - use when order is unimportant

So by using these meta-containers, you should be able to specify roughly whatever types of display you would like. If the use requires a more complicated view, then it is possible to implement a custom viewer, however, usually a combination of viewers and metaviewers, it is possible to render anything.

See the idea of Morphic, which is an addon to Smalltalk. (recently discovered these interesting ideas)