Recentering the

https://www.vice.com/en_us/article/pa75a8/worker-owned-apps-are-trying-to-fix-the-gig-economys-exploitation

Goal

A language spoken by the user through gesture to evolve their system.

Clean these notes up!!!

• explain why drafts are a broken pattern

• Filtering cards

  

Clicking on a card, and searching its contents.

• Output of a program should be tied back to the version of the program run.

Specific Setups

Email

What if there was a list inspector view that you could drop your list in, and it would create a side window showing you the last clicked element. Window management.

Maybe when a card is in a list, the card itself shouldn't know what happens you click on it. Maybe the list should know and emit an event. And peerhaps by default that event is for the list to push a copy of the card out of a pipe? And then another card can take that card and expand it?(every card has a small → medium → large version of itself)

What if a list view exported a selection, and you could write an equation like:

List.currentelement = Sideview.activeElement

• A card that takes the last clicked card and renders it large. Can be constrained to a list of cards.
  • Gets rid of the need for dedicated full-screen modes.

Video Notes

This setup, but with cards:

Reading

Expanding a page horizontally, so its content flows in columns. Esp. for TOCs like the Summary of The Language in APL. Then you can click and drag links out of it. Like in:

Tearing off transcluded/quotebacked things.

Freeform hyperetext browsing.

Lectures

People should be able to create a card that contains a presentation on one side and a video-view on the other.

Virtuosity and Language

You can become a virtuoso pianist or a virtuoso python programmer. It's impossible to become a virtuoso computer user because the rules of the system are so inconsistent. If you look at primitive math(like euclid 🚂Personal Notes on "Video Games and the Future of Education") iit's hard to see how you could "standardize"(find better word for this) the freeform text descriptions- perhaps early mathematicians would have said the freeform text is essential! Perhaps fear from what you would lose if you compressed it somehow. But clearly symbolic mathematics is easier, and it lets you develop a skill: the skill of symbol manipulation, which is both a learning aid and a "doing" aid. We don't have that for construcing interfaces on the fly.

• transclusion pointing comics interpolation patterns non-linguistic communication with transclusion of many things like in comics.

Reconfiguration

https://s3-us-west-2.amazonaws.com/secure.notion-static.com/0f6703a4-5cb9-483d-9f7f-ad0f36556a5b/Screen_Recording_2020-07-11_at_14.39.11.mov

Maybe when you drag a window onto another window, you can chose what “glue” to use to bind them. The glue decides how they get rendered together. So there’s a bullet-point glue that binds windows together with some increasing left-padding.

Reality has a rich repository of binding mechanisms for as-hoc combinations of objects. Tape, glue, staples, paper clips etc all allow for different kinds of combinations with advantages and disadvantages. I want to have that same rich language of combination in my computer.

I feel like this is still a case of the “glue” acting more or less like a “container” to the nodes tho... perhaps for any given instance of a node, it should have back links to the glues it participates in. Then, when we render a node, we look at the glues it’s a part of and render those?

What if we only want to render a glue for a specific transclude instance of a card? Maybe you have to surround the card in another card and glue there? Is that convoluted?

• Perhaps, in a certain sense, even the email object is formed by the free association of objects like subject, text, and sender. Another perspective: the subject is a "webpage" that has text in it, which has a bidirectional link to the email. A sender is a web page that has a name and an email address(idk, whatever the email protocol specifies too I suppose.) So far this kind of sounds like XML, but I'm also imagining extending it?

• The nice thing about LEGO bricks is that they advertise their affordances for extension. When you drag and drop a window around, it should do the same.

• Modification should be continuous, perhaps even indistinguishable, from normal use of the software
  • it's important that this happen in-line w/ using the app itself. Because if you have to go into a separate mode or a customizaton menu, then you lose flow. And you can't see how your changes affect the actual concrete example that prompted you to make the change.

• Dragging design tokens onto cards/relations

  

Demo Flow

demo on ipad:

• demo on phone
  • drag email into clipboard
  • open clipboard on computer
  • expand the card inside the clipboard on the computer
  • rearrange the card in the computer
    • show the changes reflected in the phone in REAL TIME
    • push changes to master
    • wow. So it's important that the devices can communicate over bluetooth or a similar ultra low latency nearfield system. Going through the internet won't work.

• color emails based on age?

Todo/Prompts/Unkowns/Problems

• Design the flow of adding a memo or a todo to an email.

• Go through computing spaces log and find my old app iedas and then turn them into flows for the system.

How would I do calendars in the card UI metaphor?

Hmmm I feel like I’ve been down this road with Dango before lol

• I need to put on my ecological hat too. And my ecological hat is not of much substance compared to my programming hat. I need to read a good book on ecology and life.

• On the PC, what is the appropriate gesture for unzipping and zipping?

• play around w/ dango-style notation for vertical lists etc.

• How do maps fit into this? On mobile, if every card is draggable, how do we allow for interactions like Maps that demand freeform panning/zooming gestures?
  • Maybe these sorts of elements should have "lids" that you have to "lift". Imagine a solid lid made of glass, like a CD jewel case, covering the map card. As you scroll and maybe tilt your device, you see it glisten slightly. Perhaps using force touch, you can pull it up.

• How will AR apps like Measure work? - Is there a case for full-screen tools?

• How do you communicate to people all of the things you can do with an object without overwhelming them?

• It's nice to be able to see a preview of a linked card(every card has sm→md→lg so you can show sm(or configure which size you see)). But I don't quite like that it's the default action for hover. Like I want a smooth fast way to see the preview, but still be the initiattor of it?

Seeds

• There should be a flow for quickly turning something into a horizonal list, fullscreening it, and then going into each one.

• email: close as read, close as unread.

• Remember: FB and Netflix have those horizontal scrolling things and it might seem like you need to replicate them but there's nothing fundamental about these. Not all paterns from the current world are valuable.

• highlighting some text
  • and getting its dicttionary definition.
    • perhaps a word that doesn't appear in your statisticsal lexicon should be highlighted? or a word that doesn't have a
  • and seamlessly searching for it in yournotes or on the internet.
    • each action effortless and geometrically connected to the last, continuously retraceable!
      • Maybe the principle of expansion could work here too:

        

• Long-press on iOS app icon → get an action item that says "search here". What is the natural gesture for search?

  

  • again- what is the natural interaction for search?

• Imagining an interaction where we expand buttons to see their composite commands
  • a button labeled "like" → expands: to a box showing a sequence of actions, and just like you can insert new UI elements into cards you can insert a new action to be triggered by the button.

    

  

• On the web, if I see a typo in an article I read, I have to dig up the author's email address and then send them an email. In card-world, where cards are part of reflective associative chains, we can easily tell the card about the typo, and leave it up to some conventional process to figure out how to let the author know. Perhaps it's agreed that there's a "corrections" stream out there that associates card IDs with correction objects, and authors read from those streams into their inboxes or todo boxes.

• A quick command to send a card, or a part of a webpage, to another webpage or a card? - Every card has an inbox?

• maybe there's no email, just people sending cards to each other?
  • consider the outside → inside boundaries in A Pattern Language. We need something like this for cards in shared spaces too. When you chat w/ someone, it should be clear you're not in a public place anymore. i.e.semi-permeable membranes in
  • your inbox is really just that - a box that cards from othere people go into
  • reply to a card - as a message

• Subverting the feed. You can inject cards into lists of cards

  

• Tying your timer to an action. You only need to know about one timer. Like when you want to defer sending a draft email to some other time, you can drag the timer onto the send button? Or maybe you force-push or right click the button, bringing up a defer-press-till action? At some point you need to be taught that buttons can be deferred - is this fundamental enough to be part of the onboarding process? Or perhaps the more fundamental knowledge is that button presses can be wrapped or chained with other actions.

  

• Maybe everything should be moveable at all times. And when you tap on something, whatever lateral force your tap had will slightly shift the card. When you shift the card, you enter the dragged state, and see a drop-menu of actions for the card.

• Imagine this space, permeated with springs, and forces between elements. What if all interactions were driven by continuous physics simulations?
  • Perhaps you wouldn't need flexbox - alignment between elements would just be a property of where they are attached to each other by?
  • Perhaps we could model text editing through springs too, thereby uniting the world of boxes and text
  • "boxes" would simply be boundaries of the spring system!
  • Text would be a linkage of springs
  • Any element can be inserted into a chain of character elements.

    https://s3-us-west-2.amazonaws.com/secure.notion-static.com/800b9aed-832f-47c7-a46d-d6760ccee2d9/Screen_Recording_2020-06-15_at_01.46.03.mov

  • One of: the paragraph, the adjacent characters, or the object itself, tells the object to preferable adapt to the height of the characters. I think I like the idea of the characters telling this to the object the most..
  • lol there's NO way I could do this with React
  • If everything is a spring, then what are the rules for the rearrangement mode?
  • Subtle thought for polish:
    • To keep the system feeling alive, when you drag and move a card, the elements inside of it should move just a little bit too.
    • But if they all move with as much force as is applied to the card itself, then it would be chaos inside of them.
      • Especially if there are nested elements, the deepest children would move like crazy, especially if there is feedback and oscillation.
    • Therefore, the parent card should forward the force applied to its children, but dampened by some factor. So the elements still sway and move as they should, but with increasing less vigor as the force crosses spring boundaries.

• Perhaps a rule is that every card should be backed by an object?

• There is no notes app. There is no email app. Notes are notes, and emails are emails- they are objects of their own, physically independent of any container they happen to be put inside of. If an email is par of a chain of emails, then it will link to the emails that preceded and followed it. But this is a different thing from saying that there is a chain and that this chain has an email.
  • So how do you put things inside of containers?
    • One answer is queries of properties. We can query all emails that

• What about updates?
  • By default, all UI updates are opt-in, granular, and reversible. So you review a changelog of updates and pick and chose the ones that you want. If a component of yours differs from an upstream component, you get a notification, and are shown a view of both of those components side by side. You're told what the new features or bug fixes of the component are. Say your email provider has added a custom "score" or something to an email - you can take just the new subcomponent for the score and add it to your own component.

• Combine this with Data Design Language but w/ an object oriented fashion - there are methods too!

• Creating relations that have identity - for example, the space between two objects is specified by an object that relates them. This object has a uuid, and when you merge upstream changes, they are applied to it.
  • Maybe they have an identifier in the code like r1(Tweet, Comments)
  • r1.distance = 8px
  • Reading - X -> r(A, B, ...) becomes something like Tweet -> r(Sender, Recipients, Text, Media)
    • Alexander says everything is relations, and perhaps with infinite resolution this is true. But on the computer we have to decide on a maximum depth for this recursion- bottom out to Objects.
      • So the language perhaps should have both Objects and Relations. Relations > Messages? Messages are inherently ephemeral. But the relation between a door and a hinge and a wall is not ephemeral, and cannot be modeled, I think, by messages. Well, unless the messages for e.g. "binding" happen very frequently all the time.
  • take: The metaphor is cards coming togethre via glue that bonds them. there are no primitive containers. Only associatinos of objects, like atoms.
    • boxes are a real thing tho?
    • this elegantly solves the problems of forking a "list" and inserting an element between two elements. If every list is an associative list, then insertion only makes sense in relation to two entities.

• Important to acknoweldge that this iiis a document-centric model and not all things are documents

• Morphological processes suggest organic unity of cards?

  

• When you pick something up, modifier keys appear.

  

Object Permanence

In the system, it is significant for a card to be created. That card has a life cycle and a permanence to it. You can annotate and remix it, and it will keep those changes when you next pull it up.

It’s like with actual mail. The mail is permanently altered by your annotations. Of course, because it is a digital copy, it should be possible to see and restore old versions.

So what does this mean then in relation to the pattern that a card has many size based representations? If you annotate the title in the preview, should that be reflected in the main email?

I think so?