Entities and Events

PCE

Observing relationships without context is the best

So, taking a step back from the project for a minute (phew… crisis averted on that stupid delete thing) I wanted to drop in some more philosophical shtuffs. Product, user behavior, events, storage, engineering, it’s all connected. The way a user engages with your app should inform how you store their data, should inform how you ingest their data, should inform what infrastructure you should run your services on, should inform… and on, and on, and on.

Well, I think before we can do any technical solution-ing, we should first develop a shared framework for thinking about user behavior. But we’re gonna flip the explanation on its head… instead of using human words to explain smart technical things, we’re gonna use smart tech words to explain human stuff. But we’re not gonna talk about implementation (I don’t think).

Intro

User behavior is graph-y as well as stack-like. If we think of applications as a maze, our users start at the entrance every time they open their phone and click on your icon. They won’t always enter from the same point in the maze, but they all start at some entry point.

The Maze

The maze isn’t a perfect metaphor though; almost no modern applications have any central point everyone is pursuing. User behavior isn’t uniform-especially in the early days of development.

A better metaphor might be a graph. Users bounce from page to page, node to node, creating and destroying edges.

The Graph

The graph does a better job helping us to view user behavior more systematically and gives us a good mental framework for imagining how a user might bounce from node to node, idea to idea, page to page.

But we also said that user behavior is stack-like and I think this is the key refinement. When people go into something, they need to remember how to find their way back. They need to have an exit plan to feel secure in the environment you’re creating for them. The less you have to dig for content, the more you’ll stay on the platform, because you’re not at risk of getting lost. TikTok has done this beautifully. Twitter made “simple” (just read only what comes across your feed) opt-out and allowed you to go deeper in threads (though we all remember how stressful it was to lose your position and the just spam the back click; now that I think about it, TikTok may have that same problem with the vid-reply to comment thingy, I just wasn’t on there enough). Spam back clicking to get out of a deep thread is the result of “lost in the woods panic” which is experienced to varying degrees for every user learning a new paradigm.

So if we understand that users are mostly going in one of two directions, this is where we refine the graph model and realize we can map behavior to a directed, acyclic graph, not of users, posts, pages, messages, but EVENTS, as they bounce off of the entities around them.

The (Event) Graph

As we see our user go into our application, their behavior starts to look like a “lightening bolt” striking various a tree or flag pole. Often users aren’t looking for something in particular, but instead, many small “lightning rods”. They’re participating in your experience because they’re frantically searching for what will ground them.

If we are going to focus on grounding our users quickly, we need to understand their Event Graphs better (and I don’t think know we don’t need to see the content of their data to refine their event graph). By observing events in the system as “just events and their relationships to entities”, we open our system up to learn the context of the system from the relationships between contextless-entities and their relationship to other contextless-events.

The universe has no concept of a shoe. The shoe was “created” in the confines of the system that the universe understands. The universe doesn’t give a fuck what a shoe is, but it is able to observe it within the system, based on the matter + energy that makes up the shoe and how all of the matter + energy around the shoe are experiencing the shoe.

Anyway… still can’t get technical (even if we really want to *cough* Entity Event Radiation™ *cough*), because… we need to talk more about our diagrams and what I think is the next step to understanding user behavior, and mathematically preparing their views before them, we need to understand The Stack.

The Stack

The critical component of the stack is the BACK. Users, when they engage with an application always go "back" to where they feel comfortable. The length of time which someone spends on a particular tier (and further in passed that tier) is the indication of their level of comfort. We can compare similar events and make inferences about likely trajectories. Keep in mind, that we're not just viewing "user events", users are just one model, for this example. This could be used to synthesize all kinds of data and behavior by recognizing similarities in the relationships between entities and their interaction with events in the world.

I think the critical component to understand here, is, comfort. Users go back when they’re done with what they were engaging with, they go back because it wasn’t what they thought, they go back because it’s upsetting, they go back. Where they go back to, I think is the critical factor in understanding how to actually make them happy. Don’t change the pages they spend the most time on. Create new paces for them to explore new ideas without tanking their home spot? If you want them to try something new, don’t take away their safe space.

Okay, one more diagram…

The Blended Model

If we can visualize the nodes, pages, people, ideas, which might be represented in this graph (I’m sick of trying to label shit), we can now think of each “switch back” as a return to perceived safety, and each step back, both has the option to relieve the user, while also having the potential to create an even more negative relationship with parts or all of the application if they can’t return to “safety” fast enough (or before they exit).

Conclusion

Basically, I’m pretty sure, that if you get enough connections between entities (which are themselves also a collection of events but maybe more on that later) via their relationships to events, the system could start to show us what matters instead of us just keep bashing it with our ideas screaming “LIKE THIS?” like a toddler, cramming a square peg into a round hole.

If we stop telling computers what we think, so that they’ll validate our genius, and instead start letting them show us what is actually happening within the system, then, maybe, we have a shot at predictive caching via Contextless Denormalization Indexes™ (or “entity specific, materialized views, for encrypted content”).

(shit… i went technical)

Originally published at https://problemchild.engineering on August 18, 2023.