Combining several simple ideas into one compound one, and thus all complex ideas are made.
The second is bringing two ideas, whether simple or complex, together, and setting them by one another so as to take a view of them at once, without uniting them into one, by which it gets all its ideas of relations.
The third is separating them from all other ideas that accompany them in their real existence: this is called abstraction, and thus all its general ideas are made.
Applying the quoted **metaphor** to programs:
1. The compound idea *"what is hogging space"* into the simple ideas ``du | sort -n``
2. The relation between the ideas of text editors vi and emacs.
3. Separating the idea of an archive of a directory into a ``.tar`` and ``.gz`` portion; that it might become a ``.tar.xz`` archive instead.
Something useful like a **"shared system clipboard"** might involve all three steps:
* 2: See that both *Writer* and *Calc* have internal ways to copy and paste data.
* 3: Separate their internal copy/paste mechanisms; also their import/export data mechanisms from the rest of the program.
* 1: Connect these mechanisms to a **"shared system clipboard"**.
Re-apply the **metaphor** to art: e.g. factoring an image or music into sections or themes and resampling to a new image or music.
Re-re-apply the **metaphor** to programming an art editor: e.g. having an image or music editor operate on layers or tracks as well as transforms on those layers or tracks.
Re-re-re-apply the **metaphor** to programming a new editor; e.g. a ``minetest editor``. Okay, I have two buildings in random places, I want to copy them next to each other. I also have a generic "sidewalk" tiling with benches and lights and trees in a line I want to place between them, cutting off at appropriate parts. One is built on snow and one on grass so I want to "magic select" the ground layers; delete; and re-apply a gradient.
How hard can this ``minetest editor`` be? Well from painful experience I know it's very hard. But now I have a second question - programming ``audacity`` and ``GIMP`` were **already** very hard, but they are **already** done. Shouldn't there be some way to leverage most of them?
Of course this is also very hard. But it's a dream. Anyway, re-re-re-re-re-apply the **metaphor** to:
1. social programs (that **share** data online)
2. **sharing** data between different social programs (e.g. single sign on, multi-posting)
3. semantic **sharing**; how the posts are connected to each other
4. re-designing the social programs to facilitate the semantic **sharing** when people use them to compose posts
5. what are the common factors among how each social program would want to implement semantic ~~sharing~~ (previous ``sense``, do not re-bold), that themselves could be **shared** among them
And the thesis from #CategoryTheory seems to be: Don't try to start with an absolute conception of **sharing** that encompasses all the above ``senses``; a ``"set that contains itself"`` will blow up. Instead re-build the ``sense`` of **sharing** anew each time by fixing previous ``senses``.
