To me, "layering" means complete isolation - more than just encapsulation.
In terms of software, to me layering means starting with software LEGO® blocks. This is hard to do using only FP, but a lot easier with shell pipelines. LEGO® blocks and processes and closures-with-queues allow you to isolate. Shell scripts allow you to layer (if you are careful).
In Kinopio, layering means self-contained "spaces" with links between them (created by explicitly specifying the "/" op).
The article, "Structured Message Passing”, shows layering applied to electronics schematics and hints at layering of software diagrams.
The feature that makes layering work in any context, is complete isolation with very explicit entry and exit points.
For software, I use the word "port". In software, data isolation - “encapsulation” - is not enough. You need to ensure that control-flow is isolated, too. I touch some of these issues in this old blog article, and this old article, and this old article.
I disregard LabView because it looks like it allows layering, but, nonetheless, allows lines to cross component boundaries in an ad-hoc manner.
I've used photoshop-ish tools that provide layering which doesn't really encapsulate anything. You can slap layers over top of other layers and the level of detail remains the same (actually, the level of detail gets more complicated).
As far as editing goes, Kinopio gives me the best feeling about layers - you create a completely different "space" and put the detail there. As you step back up to upper levels, the detail is elided and you only see the name of the layer.
I haven't played with semantic zooming, but, to satisfy me, you would need to be able to use it to elide details when you zoom out. This implies that blocks are connected in some relatively thin manner - "wires"? - with a very explicit definition of what can and cannot cross boundaries of parts (boxes, rectangles, enclosing figures).
Emacs’ markdown mode gives you the ability to expand/contract whole portions of text. Likewise, text editors that perform code-folding and eliding, do the same, but, text is "too linear" and "too sequential" IMO. Text is strictly read in one direction (top to bottom, left to right, in the West). Layers should go in multiple directions, but, should not criss-cross.
When I used to draw electronics schematics, I used to use off-page connectors to elide big chunks of circuitry, but tended to put too much detail on schematics anyway. Our schematic-drawing tools were not encouraging me to elide and simplify.
Off-page connectors are like X/Y panning. One needs to push into a block in the Z direction. Currently, Kinopio "/" and URL-linking fit best what I'm talking about, but they are unstructured, like GOTO was for programs, and can result in a mess.
I tend to think that business ORG charts are a good model for scalability and containment.
See Also
References: https://guitarvydas.github.io/2024/01/06/References.html
Blog: guitarvydas.github.io
Videos: https://www.youtube.com/@programmingsimplicity2980
Discord: https://discord.gg/65YZUh6Jpq
Leanpub: [WIP] https://leanpub.com/u/paul-tarvydas
Gumroad: tarvydas.gumroad.com
Twitter: @paul_tarvydas
Substack: paultarvydas.substack.com