Ramblings

This page is read only. You can view the source, but not change it. Please contact the website administrator if you believe this to be in error.
<WRAP column 18% right>
{{page>Templates:Systems}}
</WRAP>

~~Title:Permissions and Policies~~
<WRAP centeralign>Systems/Mechanics/\\
<fs xx-large>Permissions and Policies</fs></WRAP>
Interaction with oneself and others can be characterized and categorized. Patterns in our behavior, our thinking and our rationale are the result of our own choices, intentionally or not. I think about these patterns a lot and use the concepts of //Permissions// and //Policies// to parse them into ideas that are less abstract than the patterns themselves. It's basically my way of making sense of it all.\\

//Permissions// describe the things I'd be willing to do with or for a person or what I would allow a person to do. Hospitality, sheltering, money, private documents, a lot of things fall into this category. //Policies//, on the other hand, describe overarching guidance on how I approach myself or other people. This is less about binary decisions and more about the manner in which I respond to people. Really they both kind of describe the same thing and that's very much on purpose.

====== Explanation ======
===== Basics =====
The inspiration here comes from [[Minecraft]] server permission configuration. Every possible interaction can be broken down into //nodes//, which can be individually allowed or denied. To capture the full scope of human interaction I use additional options such as Limited and Increased.\\
\\
Nodes are grouped into categories, separated by a point, like this: <wrap hi>private.diary.destroy</wrap>
This expression should be read as follows:

(1) <wrap hi>private</wrap> refers to my private things. Documents, mails, online accounts, but really anything you wouldn't trust a stranger with. Or even close acquaintances.

(2) <wrap hi>diary</wrap> is an object from the category of private things.

(3) <wrap hi>destroy</wrap> refers to the interaction of the destruction of the aforementioned things. Essentially, this node will govern whether a person is allowed to destroy my diary. If, for example, a friend of mine and I decided to burn my diary (for whatever symbolic reason), they would implicitly((Not explicitly of course because nobody would understand and I would sound like a moron.)) be given this permission.\\
\\
\\
Another example would be <wrap hi>private.*.access</wrap>. This one is read similarly to the previous example with two exceptions: The star symbol (*) acts as a wildcard and refers to //all// objects contained in the private category. This would include the diary from the last example, but also everything else. Read means that the permission governs whether a person is allowed to, well, access my private things. For example, I might trust really, really good friends with full access to my private things. It's not that I //want// them in there, but this permission would mean that they are de facto allowed in there if they wanted.

Crucially, however, this permission would //only// apply to the access interaction. Destroying my private things is a different interaction and would need to be separately allowed with a permission like private.diary.destroy or even private.*.destroy .
===== Values =====
While //Nodes// describe an interaction, a //Value// determines whether an interaction is allowed or not. Without it, nodes just point to a particular interaction but would not actually say anything about it as a permission. Nodes can have one of multiple values, such as //Allow//, //Deny//, //Limited//, //Increased//, //Minimum//, //Maximum// or //NORM//.

Most of these explain themselves in context. That, for example, the private.*.access permission is set to //Deny// for every stranger should be obvious. To make this process easier, I use //NORM// to describe a default value for a node((Dynamic depending on the context. A NORM for an internet person is different than a node for a person I know IRL.)), for example <wrap hi>trust.* = NORM</wrap>. Trust is a policy and points to multiple permissions. It is, for example, a private.*.destroy = Deny. It is a private.*.access = Limited. It is a private.vulnerable.access = Deny. It also defines how much I'm willing to believe this person, even if what they say seems unlikely.

I wouldn't let them see my bank details or diary, but I would generally try to trust that they are a good person with good intentions. Over time, this can, but does not have to, change. I may come to believe that they are more trustworthy than what I initially gave them, in which case they might get <wrap hi>trust.* = Increased</wrap>, which would imply private.*.destroy = Deny and private.*.access = Limited but also private.vulnerable.access = Limited.\\

//Minimum// and //Maximum// are used to describe levels of permission that are as close to their reasonable limits as possible. For example, I cannot actually fully Deny communication permission with a person((This is NOT about whether the person is allowed to use their mouth to speak at all! This is about whether I choose to engage with them in a verbal exchange or say anything to them at all.)). There are extraneous situations that can force me into saying things. Refusing to do so might cause damage to life or property or cause social problems((Like refusing to respond to one of your coworkers.)). I mean, I could theoretically Deny that permission and accept these damages, but in almost all cases I will be using //Minimum// instead.
\\
\\
One cool thing about this is that I can set general policies but then make exceptions. I can set a person to trust.* = Increased but then also give them full access to my diary with private.diary.access = Allow, if I've gotten to know a person who I'd entrust with my diary in a way I wouldn't trust them with much else.
===== Modes =====
Modes describe //how// I arrive at values for nodes. Most values will be set automatically depending on context. The mode for these nodes is AUTO. But sometimes automatic values need to be overridden because of extraneous circumstances - their value manually, forcibly //set//, using MANUAL mode.

Example for this include individual agreements with the person who requests I do something different from how I would do it naturally, or situations where I realize that AUTO is producing undesirable results (which happens a lot). I also use MANUAL to force a certain value in cases where I don't trust AUTO to keep it there. For example, I deny myself the permission to lie - this would be a candidate for a NORM value set by AUTO mode, but instead I am using MANUAL to force it to Deny.

====== Important Permissions and Policies ======
===== basic.* =====
The basic permission is //the// most central permission in this system. It is basically a collection, a group of other permissions and policies that would be really annoying to list out again and again every time. 

There are certain permissions and policies between me and others that pretty much everyone, but really everyone gets by default. Think of it like how you have a basic conduct towards pretty much //everyone//, with almost zero exceptions. There is a fundamental bit of behavior in you that you will always apply to everyone, (almost) no matter what. Yes, you adapt your behavior based on the person you're talking to, but there are at least a few fundamental patterns that apply to everyone equally.

The easiest example here is that I will always respect life. People have a [[claim]] on life. I will rescue people if their life is in danger((The exception of course is when I have more reasons to not rescue someone besides dislike. I would not rescue someone who is seeking to cause more damage than what their own death would cause. Terrorists, hostage-holders, war criminals, or everyone else who has caused an extreme amount of damage [ie. negative utility], but obviously this is extremely rare. I know some public figures, but in my own life nobody has ever been at that point.)) and try to help prevent catastrophes where I reasonably can.

Another part is reconciliation. Many people, once you've gotten to a certain point, will not let you try to make remediation anymore at all. Once they've decided that they don't like you, that's it for you and you're now forced to just accept that. I do this differently in that I always, under //every// circumstance, allow people to make a genuine, good-willed effort to try to reconcile if ever something went wrong. For that end, a person //always// has access to their //Record// (an extended copy of the personality profile that includes traits, permissions but also a log of things that happened with them) and is always permitted to make a request for a reconciliatory conversation. There are only extreme circumstances under which I refuse that. The idea is that while it can be more or less easy to make me dislike them, there is //always// a path back out of that for those who genuinely care.
===== trust.* =====
This permission is used as an overall measure of trust.
===== .in & .out =====
Some permissions can be further described by detailing a direction. If I want to say that I am not talking to a person anymore could use social.expression.gratitude.in = Limited to say that I'm ignoring it when a person says thank you (probably because they're doing it excessively and are pissing me off) without affecting whether I express my own gratitude.

After a fight, something like social.comms.* = Minimum may be used to indicate that all communication, both inbound and outbound, are denied except for those handled by the basic permission (ie. life saving or reconciliatory only). A full = Deny would actually override the basic permission and prevent comms even if it was necessary to save life or reconcile (I practically never do this).