Zooming User Interface (ZUI)
en.wikipedia.org
en.wikipedia.org
------
Speaking of maps, I got to work a fun zoom project a few years ago: https://map.fieldmuseum.org/
We used https://openlayers.org/ and thought long and hard about how to best handle zooming and variable levels of information density & visual hierarchy. If you zoom all the way out, we just highlight where the building is relative to the surroundings. As you start to zoom in, we start to highlight major exhibitions and entrances. Then as you zoom in more, we start showing recommended paths, smaller exhibitions, etc. The label sizes try to scale up and down at each level, smoothly, in order to balance readability and density.
Eventually you can reach the max zoom level and the labels will just grow bigger and bigger, but the SVGs dynamically shrink so they remain pictograms and not just contextless-lines.
Then if you keep going, you eventually find microscopic easter eggs :)
The code is pretty jank (and abandoned), but it's FOSS vanilla JS/HTML/CSS, and the only dependency is on OpenLayers: https://github.com/arcataroger/openlayers_indoor_map
like google maps.
From a quick skim of the source code this is mostly precalulated. Basically each document is rendered as one rectange, where the shader converts the current position to the row/column of the character to be rendered. There is one texture that holds the length and starting offset of each line (using one pixel per line), and another texture that for each offset tells you which glyph to render (using one pixel per glyp). The third texture is the glyph map that holds the actual glpyhs (a simple 256x256 texture of all supported characters). The last texture is static, the other two are calculated once as the document is loaded, and there is a neat shader that uses all three textures to render the actual document view. Since the shader is sampled at fewer points if the rectangle takes up fewer pixels on your screen this works out well for zoomed out views.
1. https://eaglemode.sourceforge.net/screenshots.html 2. https://aur.archlinux.org/packages/eaglemode
https://forum.figma.com/t/link-to-selected-frame-should-be-r...
Indeed. For a concrete example see Ted Nelson's "Zigzag" UI concept:
https://en.m.wikipedia.org/wiki/ZigZag_(software)
https://www.youtube.com/watch?v=WEj9vqVvHPc
tl;dr: a lot of good and interesting ideas that should never actually be implemented.
Google Maps and Waze and friends being universally useful these days?
A little bit of zooming can still work great when you have a very limited item count, e.g. Mission Control on MacOS to manage windows or thumbnail view of tabs in some browsers. But as core UI for the whole OS it gets quite confusing when you don't really have an intuitive understanding of where things should be.
Is it, though? For one thing, many feel that projects like Dataland led directly to the modern Windowed User Interface. One can think of opening windows as a kind of limited zooming with very specific affordances. The iOS UI is cited in the Wikipedia article on ZUI as being another example.
Basically, any UI in which one can "drill down" into greater detail or smaller/more specific contexts is effectively a kind of zooming. The problem, is losing the connection to the larger context.
Another thing to consider: At the time many of these things were tried out, there wasn't enough capability in the CPU and UI to render complex data fast enough. In fact, I was involved with a round-trip UML DB to UI product dating from the 1990's, which looked great in demos. However, it became dog slow when actually given someone's company database. This was a problem which dogged many projects with innovative UI ideas. (A problem which many CAD software apps deal with, and which seem to have been solved to some degree.)
semantics in 2D isn't something that's easy to grasp cognitively unless you specifically arranged things that way
Do you have specific examples?
Funny, but in my comment above, I'm referencing a Smalltalk program!
Smalltalk environments are actually full of things that are functionally just about a REPL.
until I got to a code browser for part of subsystem I wanted to change
There are a variety of query languages for code repos. VisualWorks Smalltalk had two versions of this. One was based on the RefactoringBrowser code. There was another one that was a VisualWorks library. These could be used to pop up a very specific browser. For example, you could have a browser that just showed all of the implementers of a certain method X and referenced instance variable Y and called a method Z.
I wish "modern" IDEs could support something like that. This would actually be very useful for providing context to LLMs.
Many modern text editors have a zoomed out view of the code that you can use to scroll around it.
There's photo browsers with thumbnail views. As you zoom in to each photo, more information is exposed.
Then there's video and audio editing software with complex zoomable timelines.
They're kind of everywhere to be honest, just a bit hidden.
Similarly, it's too often used for (mis)organization, like in Miro or Prezi or "mind map" apps. I feel like those try to shoehorn information into Sherlock-like "mind palaces" in a way that only makes sense for the creator but are inscrutable to everyone else and just makes information harder to find later on. They always lead to some sort of pixel-hunting where the presenter zooms out and in, out and in, out and in, wasting time on navigation and placefinding instead of information dissemination.
-------
On the other hand, it CAN be useful for some visualizations, like taxonomy: https://itol.embl.de/itol.cgi or https://www.onezoom.org/life.html
"Drill down for details" like in disk space analysis: https://www.youtube.com/watch?v=BKClylmlv3w&t=1s (or similar one in D3: https://observablehq.com/@d3/zoomable-sunburst)
Treemaps: https://observablehq.com/@d3/zoomable-treemap
I think the overall point is some types of hierarchical information naturally lend themselves to "drill down" type UIs more than others. When you have levels of detail you don't need to see at first glance, drilling/zooming is awesome. When you have a bunch of things of equal hierarchy, presenting them in a big flat pile isn't any better in the virtual world than in the real world... it's the digital equivalent of 10,000 sticky notes on a wall.
https://www.cs.umd.edu/~ben/papers/Johnson1991Tree.pdf
HCIL Archive: Treemap Home Page:
https://www.cs.umd.edu/projects/hcil/treemap/
How Ben Shneiderman’s Treemaps Found Place In The Museum Of Modern Art:
https://analyticsindiamag.com/how-ben-shneidermans-treemaps-...
>Ben Shneiderman was inspired by the 1960's 'Op Art' and the exhibits that he came across at the Museum of Modern Art in New York. Op Art or Optical art is a form of kinetic art related to geometric designs that create movement in the eyes.
Ben Shneiderman's Treemap Art:
https://treemapart.wordpress.com/
>This site features draft designs and full views of the Treemap Art project. View more about the exhibitions.
>By Ben Shneiderman
>Although I conceived treemaps for purely functional purposes (understanding the allocation of space on a hard drive), I was always aware that there were appealing aesthetic aspects to treemaps. Maybe my experiences with OP-ART movements of the 60s & 70s gave me the idea that a treemap might become a work of art. That idea was revived in 2013 by way of my contacts with Manuel Lima who produced a beautiful coffee-table book on the history of trees that has several chapters on treemaps and their variations.
>I believe that there are at least four aesthetic aspects of treemaps:
>1. layout design (slice-and-dice, squarified, ordered, strip, etc.), >2. color palette (muted, bold, sequential, divergent, rainbow, etc.), and, >3. aspect ratio of the entire image (square, golden ratio, wide, tall, etc.). >4. prominence of borders for each region, each hierarchy level, and the surrounding box
Ben Shneiderman: Every AlgoRiThm has ART in it: Treemap Art Project:
https://www.youtube.com/watch?v=4LW4m6BdQXI
>Ben Shneiderman, distinguished university professor, University of Maryland, College Park and National Academy of Engineering member, spoke at the October 16, 2014 DC Art Science Evening Rendezvous (DASER). Ben Shneiderman described the invention of treemaps and showed examples of its usage. He then turned to the aesthetics of treemaps, which led him to create the “Every AlgoRiThm has ART in it: Treemap Art Project” exhibit on view in the Keck Center first floor galleries (www.cpnas.org). He demonstrated how users of the free treemap application can generate their own artworks, without programming.
The Shape of PSIBER Space: PostScript Interactive Bug Eradication Routines — Don Hopkins — October 1989 (a paper I wrote when I worked with Ben Shneiderman at his University of Maryland Human Computer Interaction Lab):
https://donhopkins.medium.com/the-shape-of-psiber-space-octo...
>The Pseudo Scientific Visualizer
>Darkness fell in from every side, a sphere of singing black, pressure on the extended crystal nerves of the universe of data he had nearly become… And when he was nothing, compressed at the heart of all that dark, there came a point where the dark could be no more, and something tore. The Kuang program spurted from tarnished cloud, Case’s consciousness divided like beads of mercury, arcing above an endless beach the color of the dark silver clouds. His vision was spherical, as though a single retina lined the inner surface of a globe that contained all things, if all things could be counted.
>[Gibson, Neuromancer]
>The Pseudo Scientific Visualizer is the object browser for the other half of your brain, a fish-eye lens for the macroscopic examination of data. It can display arbitrarily large, arbitrarily deep structures, in a fixed amount of space. It shows form, texture, density, depth, fan out, and complexity.
https://www.youtube.com/watch?v=Q4OIcwt8vcE
"Another thing I know about screens is, you can go into them as far as you want forever. And you can come out of them too, but you might not end up in the same place that you started. You might get lost. Or you might not."
It feels to me, instead of exploring different interfacing experiences in terms of zooming/non-zooming it might be more useful to think along the lines of structured/unstructured, contained/uncontained, or gestures/buttons for example.
It was really great for that one use case: something the recipient could click through and continuously be surprised by the complexity of without having to know the tool. Click. Wow! It got bigger. Click. Woah! It got bigger and rotated!
Deep Zoom was pretty revolutionary for its time, but these days we just take it for granted in Google Earth/Maps, being able to zoom all the way from space into street view, seamlessly, with raster and vector tiles effortlessly combined and streamed. It's really pretty amazing if you think about it, IMO.
It's pretty common in variable-scale video games, too. Like Dyson Sphere Project, where you can zoom out from the ground level view of buildings to a solar system and star clusters to a galaxy: https://youtu.be/kNmZTISiH40?si=TfvRoRjHMLSWHF4X&t=36 (because you eventually need to collect and transport resources between star systems)
0: https://github.com/jbuchermn/newm?tab=readme-ov-file 1: https://www.youtube.com/watch?v=otMEC03ie0g
Can be extended to full ZUIs, e.g. https://zoomhub.net/showcase/ecommerce/watches (desktop preferred)
Usually the go to early example of a zooming UI.