piegames.de

Beyond consent

2025-12-23T00:00:00+00:00

Content Note: Explicit mention of various hard kinks and discussion of non-consensual activities, including rape

The basics: FRIES</a></h2>
Let's first look at some simple and straightforward consent models. Most people have probably heard of "no means no", or, preferable in most cases, "yes means yes". But those quickly fail to capture the complex depth of what it means to consent to something.
A more thorough tool to ensure proper consent is called FRIES. It's an acronym: Free, Revocable, Informed, Enthusiastic, Specific. Even if you haven't heard of FRIES before, its definition should hopefully be intuitively clear and easily be mapped onto common practice. If all of this is complete news to you, I'd suggest sticking to this for now.
More on FRIES in this excellent writeup by LilaHexe</a>
CNC: Consensual non-consent</a></h2>
CNC is an umbrella term for various practices in which consent is still present, but not always as clear cut as in the above. However beware, people may sometimes say CNC to refer to a specific practice, and moreover they may be having wildly different and incompatible definitions about it. In order to explain these differences, understanding the concept of safewords is essential.
At its most basic, as safeword is a word or phrase which when spoken will pause or end a scene. Common safewords include Pause/Stop, Green/Yellow/Red (Red means Stop, Green and Yellow can mean different things so always make sure to clarify which one is what), and Mayday (commonly used by kink events to call for external help). Safewords can also be uncommon words with no associated meaning, like "Penguin". Having nonverbal safewords is strongly recommended, for example snapping fingers or "tapping out".
For some people, CNC means the following:

CNC is play that requires the usage of safewords. In CNC, "no" does not necessarily mean "no" anymore, it can be ignored, but a safeword cannot. This contrasts CNC to fully consensual play where no dedicated safewords are necessary, because every word can keep its usual literal meaning. Examples include scenes that involve begging for mercy or rape play. Fundamentally, CNC is about role-playing non-consensual scenes. </blockquote>
However for other people, CNC means this:

CNC is play with limited or no safeword options. Consent is mainly or fully pre-negotiated, which contrasts to fully consensual play where consent is always revocable at any point in time. Examples include "five more hits after the safeword" or hard kinks like torture. Fundamentally, CNC is consensually pre-committing to the enactment of possibly non-consensual elements within a scene. </blockquote>
See the difference? See the big, glaring issue that may arise when people miscommunicate what they specifically mean?
People who use the second definition argue that the first definition is not CNC, it's just common role play. People who use the first definition argue that the second one is not sufficiently consensual and should not be enacted or endorsed.1</a> Some people argue that both definitions fit onto the spectrum of "CNC" as an umbrella term. In my experience, when prompted of a definition, people will say the first definition, but when they talk about actual "CNC" activities then often times those will include some aspects of the second definition instead.
I argue that at this point, the term "CNC" is semantically burnt and should be avoided in favor of more specific communication. "Meta-consent" is already on the rise as the new umbrella term for all kinds of play where consent is not as straightforward as with FRIES. Additionally, I propose the term "Pseudo non-consent (PNC)" to talk about consensual roleplay of non-consent (our first definition here).
Meta-consent</a></h2>
Meta-consent is the preferrable umbrella term for all the kinds of activities where consent is still present, but not always clear cut. The term emphasizes that that at any time, there still is some form of consent on some level, and it avoids the semantic ambiguities of "CNC" (as well as the emotional baggage, as CNC is quite stigma affected).
I like to categorize meta-consent by the aspects of FRIES that are missing in the negotiation. We've already talked in detail about revocability of consent during the scene as part (or not) of CNC, and that is the most common form of meta-consent given. If instead, the consent is unspecific and/or uninformed, this leads to blanket consent instead (see below). Consent may be given "unfreely", for example under the influence of drugs or manipulation.
All of these can be necessary for certain kinds of play, but should not be goals on their own. For example you should never accept the consent of someone on drugs, unless that aspect specifically is an integral part of a scene, and the other person (meta-)consented to this happening in advance.
PNC: Pseudo non-consent</a></h2>
I'm coining this term to give the first definition of CNC a dedicated name: Pseudo non-consent defines all kinds of play that desires to mimic non-consensual situations. This typically requires dedicated safewords to allow interrupting the play where necessary. The name emphasizes that this is about pretense of non-consent. Elements of the play may require meta-consent, but this needs additional communication.
Blanket consent</a></h2>
Blanket consent is the meta-consent given in advance for broad, unspecified kinds of play or under partial lack of information. This can be as ordinary as the consent to bite each other at any time (to the point that some people forget this does require consent!2</a>) or as exciting as agreeing to a surprise scene.
In most situations, consent is not a commodity: It is not something you "obtain" and then "keep" and "use"; instead it is a property of any given situation and has no value in any similar future situation. Blanket consent as a concept is important precisely because it is the exception from this rule.
"Treat success as consent"</a></h3>
This specific form of blanket consent is worth explicitly mentioning, because most consent models fall short for various "mental" kinks like corruption, training, manipulation, hypnosis, personality erasure etc. In these kinks, the dom may initiate some action with the goal to (semi-)permanently alter the sub's mind in a certain way. Given that these processes typically happen on a deep, unconscious level and may affect the sub's desires, it quickly becomes impossible to properly ensure that any consent was given fully freely. (Of course, these questions of "free will" and desire in the presence of e.g. trauma are always of relevance for kink, but nowhere are they as prominent and unavoidable as here.)
"Treat success as consent" sidesteps these issues by transforming the question of consent into a meta-level tug-of-war game: "You may try to clicker train me in whatever way you want, but treat success as consent." If it succeeds, we assume that the sub consented to the mind alteration. If it fails, this could either be because of a lack of skill in the dom's execution, or because of a lack of consent. The ambiguity here is unavoidable: When playing on such a deep, raw level of the mind, consent (or the lack thereof) may be decided on an unconscious level. Importantly, in that "failure" scenario nobody is to blame. The dom may thus try again with more skill or a different approach (unless the consent is revoked in the meantime).
It is important to understand that this approach inherently assumes that the subconscious tends to be more averse to change which is not desired. In reality, this is of course not as clear-cut, and some people may be more suggestible of being manipulated into things they don't actually want than others. Be aware of these risks before getting involved into play with such profound consequences.
Closing words</a></h2>
When planning a scene or initiating a dynamic or a scene, it is important to always look for ways to have the fullest consent possible. Every meta layer carries the risk for things to go wrong, and should be avoided if possible. Always ask questions like: Do I really need uninformed consent? Or is there a way to fulfill that kink with full information? A lot of the time, kinky activities can be made a lot safer with only minor adjustments that don't impact the experience, and that's what we always should be striving for.
Further reading</a></h2>

FRIES</a></li>
This Metaphor for Consent Might Be Just the Thing You Need to Make It Click</a></li> </ul>

Footnotes:
^{1
It is easy to point at some foreign kink and say "this is too unsafe, this shouldn't exist".
But especially for those high-risk activities, it is important to provide people with alternative safety and consent tools for practicing harm reduction.
I'm here to help, not to judge.
</div>
^{2
There is something to be said here about non-verbal or even implicit expressions of consent, but that is a topic for another time.
</div>
Thank you to Nia and leela for helping me shape this text into its current form. Thanks to LilaHexe for writing about FRIES this well so that I did't have to, and thanks to Orange for being a (sadly rare) role model on healthy hard kink.}}

Relationship PVP

2025-10-16T00:00:00+00:00

Most people treat their relationships like a co-op game. However, that is only one way—and admittedly a fairly boring one at that—to approach that topic. For those who crave more intense emotions, the game of relationship also offers a host of more competitive modes.
This is a tutorial for how to win at any adversarial relationship, against partners and metas alike. Fun for the entire polycule!
The core game loop: Martyrship and victimization olympics</a></h2>
You are good, actually, and your partner is flawed. Your love for this seemingly-unlovable person and how much you are self-sacrificing just to be with them is proof of your true love. Unlike in co-op mode, where the goal is to get everyone's needs met as best as possible, in PVP mode the goal is to be as loud as possible about not having your needs met. Optics is key here: Everyone needs to know about your suffering, and how good you actually are, and about all the mistakes your partners are all making.
It is of utmost importance to use any opportunity where you have been wronged. Demand apologies. If multiple people were wronged, make it very clear how you have been hurt the most.
Remember: Every time you succumb to a partner's need, remind them of the sacrifice you are doing for them. They got what they wanted, and they should feel bad about having needs and inconvening you with them. If this happens repeatedly, congrats, you may then play the people pleaser card. You are now a proud victim of abuse :)
How to win at emotions</a></h2>
The primary goal here is to minimize your own discomfort caused by negative emotions. Emotions are kinda fuzzy, but facts can be true or false, and thus all emotions always need to be grounded in facts so that they may be objectively argued about. When telling others your own emotions, make sure to always justify why you are right to feel this way. When others are causing you discomfort with their negative emotions, tell them they are wrong for doing that. Use facts to argue with them why their emotional response to the situation is inappropriate or overblown or wrong. Why are they making such a big fuss over nothing in the first place; some people simply are way too emotional.
Indirect communication tactics</a></h2>
Direct communication with your partners makes you vulnerable to their counter-arguments. Therefore, the safest play is to talk about them instead of with them. An easy win for example is to whine about all your partners' flaws and wrongdoings at length with other people. A more nuanced strategy is to take the game out on social media, with snarky sub-posts and nonmentions. Other people's failings make for great shitposts, but make sure to be ahead of the current discourse or someone else will one-up you before you can one-up them. When others do the same, complain about all the petty drama they're causing.
The art of weaponized non-apology</a></h2>
Sometimes, you may make a mistake. This is problematic because your partner will immediately counter by being hurt and making you look like a bad person. Fortunately, there is a way to parry: You simply need to apologize. Now, the mistake is undone and you are a good person again. Therefore, if your partner remains upset even after your apology, they are clearly the problem here and you are in your full right to be angry at them about that.
This works both with genuine apologies as well as with non-apologies. However beware that genuine apologies make you more vulnerable: Your ~~enemy</del> partner may choose to accept the apology, which will void your parry and lead to a draw.~~
In the end, always remember: Apologies are always about who is right and who is wrong. A genuine apology is akin to admitting defeat, but a good weaponized non-apology can turn the cards in your favor again. Master this skill and you will be above fault.
How to exit PVP mode again</a></h2>
PVP mode can be exited by switching over to a co-op game, or by leaving multiplayer altogether. A crucial observation is that co-op mode can only be entered, well, cooperatively. Trying to cooperate with people who are interested in winning alone is a strategy for self-destruction (Yes this also is a metaphor about our democracies).
Unfortunately, there is a complicating factor to leaving PVP mode: Because many highly ranked competitive teams have been carefully selected over years for the purpose of fighting each other, there is no guarantee that their members may be suited and compatible for cooperative play. In such cases, the best strategy is to disband and exit the current relationship game in order to join a different team later on.

P.S.: I know that someone will end up reading all of this and try to weaponize it against others à la "you're playing in PVP mode and I don't so you're bad and I'm good", and fuck you in advance for that. You've already lost, game over.

Globally applying overlays onto Nixpkgs

2025-04-28T00:00:00+00:00

These days, it is fashionable to have the Nixpkgs for your NixOS system managed alongside its configuration, pinned by some tool of choice. In Pinning NixOS with npins, this time without flakes for real</a>, I've talked about how I want the same Nixpkgs to be used for both my system configuration as well as all my ad-hoc nix-shell</code>s. However, there is a key distinction between any import <nixpkgs> {}</code> used in the wild and the pkgs</code> provided within the NixOS module system: Only the latter has its overlays applied.
I'm a heavy user of overlays, and this discrepancy has bitten me more than once. For example, if I pin a certain version of a tool used for a service, and then do nix-shell -p that-tool</code> to do some maintenance on the service, I suddenly have a version mismatch.
The reason for this dilemma is that NIX_PATH</code> contains, well, a path, and that overlays are configuration for a Nixpkgs instance: import <nixpkgs> { overlays = …; }</code>. Evaluating pkgs.path</code> will yield the original path from <nixpkgs></code>, with any applied configuration erased.
Spray'n'pray: Using global overlays</a></h2> Nixpkgs has a slightly niche feature: It can automatically load overlays impurely from the environment at instantiation time. This is implemented in <nixpkgs>/pkgs/top-level/impure.nix</code>: 39</td> overlays ? let </td></tr> 40</td> isDir = path: builtins.pathExists (path + "/."); </td></tr> 41</td> pathOverlays = try (toString <nixpkgs-overlays>) ""; </td></tr> 42</td> homeOverlaysFile = homeDir + "/.config/nixpkgs/overlays.nix"; </td></tr> 43</td> homeOverlaysDir = homeDir + "/.config/nixpkgs/overlays"; </td></tr></tbody></table></code></pre> as we can see here, it will source and automatically apply overlays from the following locations: <nixpkgs-overlays></code>, set by putting nixpkgs-overlays=/path/to/my-overlay.nix</code> into NIX_PATH</code>,</li> ~/.config/nixpkgs/overlays.nix</code>,</li> and all files in ~/.config/nixpkgs/overlays/*</code> (n.b.: hard-coding ~/.config</code> is not XDG basedir spec compliant!).</li> </ul> This means that if any of these provide any overlays, then any call to import <nixpkgs> {}</code> will behave as if overlays = [ … ]</code> had been passed to it. Equipped with this, we can simply have: { channel.enable = false; nix.nixPath = [ "nixpkgs-overlays=/etc/nixos/nixpkgs-overlays" ]; environment.etc = { "nixos/nixpkgs-overlays".source = put path to overlays here; }; } </code></pre> I decided against putting my overlay into ~/.config/nixpkgs/overlays.nix</code>, because I wanted a truly global solution; I'm afraid things could break pre-login when /home</code> is still encrypted. If Nixpkgs implemented the full XDG basedir specification, then we'd be able to simply put our overlay somewhere into /etc/xdg</code> and wouldn't have to bother with also setting NIX_PATH</code>. With this solution, the overlay will be applied to all Nixpkgs instances, not only those of our system's Nixpkgs as found via import <nixpkgs></code> or behind the scenes in nix-shell -p</code>. Notably, this will also apply to any pinned dev shell à la import sources.pkgs {}</code>, no matter how old or new it is. Impurely meddling with dev environments is a recipe for confusing error messages, and likely to fail: Overlays are typically written to work against a specific Nixpkgs version, and trying to apply it to some very old pinned Nixpkgs pin will likely throw on a missing attribute. This can be a desired outcome, and can work with an overlay carefully designed for such an environment. However, in many other cases it is desirable to only override Nixpkgs instances that aren't explicitly pinned by their own tooling. A more selective approach: applyPatches</code></a></h2> So, NIX_PATH</code> wants a path. Let's give it one. The plan is to patch our system's Nixpkgs so that it will automatically apply a specific overlay when imported. Other Nixpkgs instances, pinned from other sources, will be unaffected. We can simply inject ourselves into Nixpkgs's default.nix</code> entry point, like this: - import ./pkgs/top-level/impure.nix + args: (import ./pkgs/top-level/impure.nix) (args // { overlays = [ @PUT_OVERLAY_HERE@ ] ++ args.overlays or []; }) </code></pre> Applying the patch is slightly involved but straightforward. We need an unpatched Nixpkgs instance for bootstrapping, for accessing applyPatches</code> and other library functions. { pkgsPath = pkgsBootstrap.applyPatches { src = sources.pkgs; # Nixpkgs pin here patches = [ ( # Replace `${./overlay.nix}` with the correct path in there pkgsBootstrap.writeText "overlays.patch" '' diff --git a/default.nix b/default.nix index bdab048245e2..617d15b6bfd5 100644 --- a/default.nix +++ b/default.nix @@ -27,4 +27,4 @@ if !builtins ? nixVersion || builtins.compareVersions requiredVersion builtins.n ${" "}else - import ./pkgs/top-level/impure.nix + args: (import ./pkgs/top-level/impure.nix) (args // { overlays = [ ${./overlay.nix} ] ++ args.overlays or []; }) '' ) ]; }; } </code></pre> Side note: This is why one does not put patches inline in Nix code. All lines of code that start with a space will be fucked up by the editor any time the indentation changes, moreover the patches</code> list wants paths anyways so it requires wrapping in writeText</code>. The ${" "}</code> in the string is a hack to work around the editor eating that one whitespace. Putting the patch in a file with @SUBSTITUTIONS@</code> for the overlay path is the way to go here. </blockquote> This solution still has a kink that needs to be ironed out: As it is, the provided overlay.nix</code> would have to be self-contained, i.e. not import any other Nix code. Often times, this is not the case: A system configuration's overlay may import packages from npins or locally vendored packages. One solution is to put the entire configuration surrounding our overlay into the store (this is what flakes do), but this means that the source path changes any time any bit of configuration is touched, even if it has nothing to do with the overlay. Instead, pkgs.lib.fileset</code></a> offers some functionality to only include the files we care about: { overlaySource = pkgsBootstrap.lib.fileset.toSource { root = ./.; fileset = pkgsBootstrap.lib.fileset.unions [ ./overlay.nix # Add all files/folders that the overlay imports here ./npins ./pkgs ]; }; } </code></pre> In the patch, we then simply replace ${overlay.nix}</code> with ${overlaySource}/overlay.nix</code>. Conclusion</a></h2> If you have an overlay that you want to apply to all Nixpkgs instances, use global overlays. If you have an overlay that you want to globally apply to a specific Nixpkgs instance, apply the overlay as a patch instead. I'm honestly unsure if I'd recommend this approach to anybody else. It works for me and solves this very specific issue I have, though I can imagine most people don't care much about it. Pinning NixOS with npins, this time without flakes for real 2025-04-27T00:00:00+00:00 Last year, Jade posted Pinning NixOS with npins, or how to kill channels forever without flakes</a>. In short, what we want is: Get rid of channels (as in nix-channel</code>, and not any other overloaded meanings of that word) as a source of impurity.</li> Have one blessed Nixpkgs pinned with npins</code> being used for the system's configuration as well as all <nixpkgs></code> invocations system-wide.</li> The solution should behave like nix-channel</code>: When running npins update</code> –and then deploying the configuration–, the entire system should switch over to using the updated Nixpkgs. The currently used Nixpkgs being tied to the current configuration is the key feature here. This means that they always stay in sync, even across rollbacks—unlike nix-channel</code>.</li> </ul> </li> The NixOS configuration should be built with the currently pinned Nixpkgs, and not the current system's Nixpkgs. (Otherwise deployments would take two iterations to converge.)</li> </ul> A naive solution might simply export NIX_PATH=nixpkgs=${pkgs.path}</code> in the system configuration. This, however, comes with a show-stopping drawback: Due to the way environment variables propagate, any updates to it would not propagate until the next relog or reboot. The common solution to this is, as usual in this industry, adding a layer of indirection. For that, Jade's post cleverly uses flake infrastructure: By writing an entry that points the nixpkgs</code> "flake" to the local store path of our nixpkgs in the Flake registry at /etc/nix/registry.json</code>, and then simply setting NIX_PATH=nixpkgs=flake:nixpkgs</code>. This works, but it comes with downsides. First of all, it requires the nix-command</code> and flakes</code> experimental features, and the goal of the exercise is to avoid flakes completely. But more importantly, the flake registry suffers from some of the same issues that plagued us with nix-channel</code> in the first time (albeit they are not surfacing in this usage scenario), and therefore the flake registry is on its way out</a> as well. There is a much simpler solution to using the flake registry: A plain old symlink. It's only five lines</a></h2> We define that /etc/nixos/nixpkgs</code> now is a symlink to our current Nixpkgs (any other path will do, but I liked this one) and simply hardcode that path in NIX_PATH</code> forever. { nix.channel.enable = false; nix.nixPath = [ "nixpkgs=/etc/nixos/nixpkgs" ]; environment.etc = { "nixos/nixpkgs".source = builtins.storePath pkgs.path; }; } </code></pre> Now, with this setup all ad-hoc shells should already work, however when rebuilding your system configuration after bumping the pins it would still take the current Nixpkgs from /etc/nixos/nixpkgs</code> instead of the freshly bumped one. This means that any updates would take two rebuilds to fully propagate. (Note: This mainly applies to nixos-rebuild</code>, YMMV when using different deployment tools. Some of them allow doing the right thing and using a pinned Nixpkgs instead of <nixpkgs></code> out of the box.) To fix this, we must override the Nix path when rebuilding. direnv</a> and a Nix shell to our rescue: use nix </code></pre> let pkgs = import (import ./npins).nixpkgs { }; in pkgs.mkShell { nativeBuildInputs = with pkgs; [ # I recommend also pinning all the local deployment tools while we're at it nix home-manager git npins openssh colmena ]; shellHook = '' export NIX_PATH="nixpkgs=${builtins.storePath pkgs.path}" ''; } </code></pre> Sneak peek: If you prefer a minimalistic setup with only direnv and no shell.nix</code>, in a future release of npins</code> the following will also work: export NIX_PATH="nixpkgs=$(npins get-path nixpkgs)" </code></pre> </blockquote> Note that the shell env approach requires to always nixos-rebuild</code> from that folder, in order to have the path override activated. This isn't a big deal for me as it has always been part of the workflow for various reasons, but if this itches you an alternative solution is to patch nixos-rebuild</code> itself: [ (self: super: { nixos-rebuild = super.nixos-rebuild.overrideAttrs (old: { nativeBuildInputs = old.nativeBuildInputs or [] ++ [ self.makeWrapper ]; postInstall = old.postInstall or "" + '' wrapProgram $out/bin/nixos-rebuild --set NIX_PATH nixpkgs=/etc/nixos/nixpkgs:nixos-config=/path/to/my/configuration.nix ''; }); }) ] </code></pre> Conclusion</a></h2> This approach is not free of gotchas, but neither are flakes or nix-channel</code>. In the future, I'd like to see a replacement for nix-channel</code> that makes such a use case a first-class citizen (maybe leveraging profiles?) instead of having to put a symlink somewhere in /etc</code>. The long-term goal is to have feature parity between flakes and third-party tools. Further reading</a></h2> Pinning NixOS with npins, or how to kill channels forever without flakes</a> by Jade</li> It's not about “Flakes vs. Channels”</a> by samueldr</li> Globally applying overlays onto Nixpkgs</a></li> </ul> A soul in an aquarium 2025-02-21T00:00:00+00:00 A soul in an aquarium The inner world so rich Is shielded from the outside By blurry glass so thick A soul lost in a body Who wasn't made to fit It's yearning for a safe space Some place to call a home A soul on auto pilot To steer while it's away "I'm human" says the pilot And even thinks it's true The soul left its enclosure So fragile and exposed It's looking for a soulmate To share aquariums with </div> Two autonomous units 2024-12-26T00:00:00+00:00 Two autonomous units With a power supply too weak One recharging in the other Taking breaks in alternance Independent but forever linked Two autonomous units Each with some broken gears Switching as to always complement the other The fragmented illusion of function In an eternal synchronous dance One autonomous unit </div> Enablers of abuse in online communities 2024-11-05T00:00:00+00:00 In a lot of conflicts within online communities I've seen, I've noticed a certain pattern of behaviour emerge. To talk about this, let's first distinguish three groups of people that can commonly be found in conflicts: The troublemakers. The trolls, the assholes, the abusers, the bigots.</li> The enablers. Friends of the trouble makers, people who silently hold the same beliefs (or less silently but with more eloquent words), people who feel entitled to knowing exactly what happened, or just libertarians who disagree with the entire concept of community moderation in the first place.</li> The exhausted, fed up by the troublemakers. They'll either silently retreat or eventually snap and explode loudly.</li> </ol> Community moderation and codes of conduct generally focus on the first group, which makes sense because superficially they are the people actively causing problems. However, upon closer inspection, the second group is causing a lot more problems than the actual obvious trolls, because they are actively sabotaging any moderation efforts, and causing large collateral damages to the community as a whole. Enabling abuse</a></h2> The stereotypical script that plays out goes as follows: After many previous incidents involving a problematic person, one incident eventually triggers a moderation action. In response, several enablers will come to the defense of that person and loudly argue against the moderation action. Several heated discussions inflame, dragging in other people, and sucking all air out of the community space to do the things the community actually is set out to do. Alternatively, if the moderation threshold for action was too high in that situation, it can instead happen that a person exhausted by the overall situation snaps. This usually involves mean words and insults towards the problematic person, and sometimes mental breakdowns in public. In that case too, the enablers will come to the defense of the problematic person, reframing this as an attack and abuse, and thus reversing abuser and victim roles. They will complain about the person who snapped to the moderators, and complain about "unjust" or "unfair" treatment. In many cases, the actual incident triggering some moderation action is minor, yet the context for it usually involves a complex and long history of past events. To bystanders without the full context, such action may seem disproportionate, and enablers will happily weaponize this in their opposition of the decision. They will also ask for more and more justification, in the name of "accountability" or "transparency". But no justification will ever be satisfying, as the goal never was to get clarity on the situation in the first place, but to exert social pressure against undesired moderation actions. An important factor is the dynamic of social status. Most troublemakers don't have a big standing in the community, as they tend to not be constructive and productive people overall, and social dynamics in tech communities usually are meritocratic in nature. (Productive problematic people with high status do exist, but are comparatively rare. Read more about them at The Impact of Toxic Influencers on Communities</a>.) Enablers however tend to be well-known community members, and they give their voice and clout to defend abusive behavior. This is highly problematic, because it drags conflicts which should have been a minor issue right into the heart of the community, turning them into something much more serious. If such stories repeat too often over a prolonged period of time, it can erode and reshape a community. People fed up with bullshit will tend to (more or less silently) leave, while combative people attracted by the drama tend to join. (The latter always exist, but in a functional community they get bored and leave unless they are actually interested in what the community is doing.) This slowly turns the community into a political debate club, fueled by inner conflicts. Abuse happening outside of community spaces</a></h2> By default, if a community member is being an asshole in a different corner of the internet, that is of little concern from a community moderation perspective—Community moderation is scoped to what happens within a community. However, the boundaries of where the community starts and ends are of course very fuzzy, and bad actors can weaponize disagreements about where the exact line should be drawn. The Contributor Covenant Code of Conduct</a>, a code of conduct commonly used by tech projects says: This Code of Conduct applies within all project spaces, and it also applies when an individual is representing the project or its community in public spaces. </blockquote> The Covenant ignores one major point: A community member being blatantly sexist on Twitter for example cannot be ignored, even if the respective posts are unambiguously outside of the community boundaries. Not taking action would send the wrong signal: "We are tolerating a known sexist in our space, as long as they're nice while we're looking". Marginalized people will hear such a message loud and clear, and accordingly consider a community which does such as less safe. Such decisions get even harder when they involve interpersonal conflicts, things said in semi-private or said a long time ago. But that is not an excuse to ignore all reports of that kind as "out of scope 🤷" (or even worse, as "we're apolitical") without further consideration. What to do about it</a></h2> The first step is to acknowledge this phenomenon and decide to expand the scope of what moderation means. It is important to note that on the long run, this will cause less work and not more, because the actual bad actors will become a lot easier to deal with. So, what does this mean in practice? Moderation is not equally accountable to everyone. Accountability is important, but it does not imply that fringe members are entitled to knowing everything that happened in full detail. Of course, there should be a space for discussion about how well a moderation case was handled to happen. However, it is crucial to shield it against bad actors abusing the process for their own purposes.</li> Act before someone snaps. When insults go flying towards a person that already is on the moderation watchlist, this is a clear indication that moderation action should have happened sooner. Moderation should be proactive and not wait until problems blow up in public.</li> Consider enablers of abuse in the Code of Conduct. Defending hateful behavior is rarely okay, and this should be reflected in the community rules.</li> Handle reports from outside of the official community spaces. Doing this has nothing to do with "thought policing", instead it is a necessity to keep the community healthy. At the same time, it is important to acknowledge that different rules apply here, and that every case is unique.</li> </ul> Ghost bus 2024-10-30T00:00:00+00:00 A ghost bus, slowly wating through the thick traffic. Blurry lights dance on the fogged windows. The outside world is not real. I blink in and out of existence—In one moment I'm suddenly here, just to slowly fade out again in the next. When I'm not here, will someone else take my seat? A ghost alights from the bus. Floating shifts into walking, as I eventually materialize again. </div> Passive suicidality scale 2024-07-24T00:00:00+00:00 OBVIOUS CW: suicidality and detailed descriptions thereof People sometimes use this suicide scale</a> to help them communicate their state of unwellbeing to friends more easily in situations of strong distress. That scale was initially created as a shorthand between friends and has no medical aspirations, as explained in a follow-up post</a> in more detail. In the spirit of the original scale, I created my own scale as a shorthand with friends, and will share it here in the hope that it will be useful to others as well. It is centered around "passive" suicidality, which is any desire to not exist devoid of any aspirations of actually taking action. It is therefore not meant as a replacement for the original (or any other) scale, but rather complementary. The passive suicidality scale</a></h2> Life is great, and even on bad days I am managing. </li> Life is great on good days, but I'm kinda struggling when I'm down. </li> Even on good days, I feel like my joy of living is being dragged down by some latent negativity. I have to fight to keep the negativity at bay. </li> Life is happening to me, I follow along by lack of other choice, but I'm not thrilled. This "being alive" thing is kind of a lot right now, honestly. </li> I somehow get through the day but don't expect me to do anything beyond that. All my resources are bound by "existing", and even that is a tough ask. I still want to fight, somehow, but I'm very exhausted. </li> "Existing" is too much for me right now. I don't know what to do about it, I don't know how to get through the day. Sometimes I just want to give up. I need help. </li> I can't take it right now, I don't want to fight anymore. I'm daydreaming of falling asleep, for a month, a year, or longer. In the hope of a better time, far away in a distant future. Or a different life in a better universe. Please give me a break. </li> A better future won't help me right now. In my fantasies, I fall asleep and don't wake up anymore. I have many thoughts about me not wanting to exist anymore, I have stopped fighting them. I am done with being alive. </li> This is way too much, I can't take it at all, I just want it stop, I don't care how. All my thoughts share the same tenor: I do not want to be. </li> Please kill me already. Put me down. Finish me. I need to die. </li> </ol> Can I use this?</a></h2> Sure, but will it help you? Maybe consider the following questions to figure that out: Can you empathize with the descriptions, and get a feeling for the mental states they mean to represent?</li> Can you project your own feelings onto the scale, and feel like it describes your mental states, even though you may experience them differently?</li> Does the scale cover a sufficient range of your different mental states? Do you feel like it applies to you in situations where it ought to help you?</li> </ul> If your answer to any of these questions is no, you are probably better off not using it. Find another one which describes what you need better, or consider creating one on your own, tailored to your own states of wellbeing. (For that matter I also recommend asking these questions about the Emmengard suicide scale, if you have been using it.) See also</a></h2> feel free to suggest more additions Comparative Pain Scale</a> for physical pain</li> The Psychological Badness Scale</a> for non-depressive psychological pain</li> Subjective Units of Distress</a></li> </ul> Addendum: Talking about passive suicidality with others</a></h2> Many people who are not accustomed to the phenomenon—and this unfortunately includes a lot of medical professionals who should know better—completely stop listening once they hear "suicidal". Ill-informed preconceptions and stereotypes about what suicidality is and how it actually feels like will override everything else you say in their head. Especially in the context of medical professionals, this can easily lead to harmful or even dangerous situations. When interacting with untrusted people, it is thus advised to reframe these emotions in terms of emotional pain or subjective distress. A big thanks to leela and several other proofreaders for helping out with writing this Against leading commas 2024-03-06T00:00:00+00:00 I've been one of the main people driving automatic formatting for the Nix language forward. As such, a major point of contention which repeatedly appeared is the one about where to put the commas separating function arguments — before or after each item? This question is not new though, and the style can occasionally be observed in other languages as well, like Haskell for example. In this text I will, mostly using the Nix language as an example, show you that commas or other separators need to be put after the item. I will also go into the few rare exceptions. I approach the topic purely from a code formatting perspective, and try to discuss it as exhaustively as possible. I will thus not go into other topics affected by this, like parsing and code generation for example, or languages where this encodes a semantic difference. TL;DR: If your language supports trailing delimiters on the last item, using them is the strictly superior solution</li> Therefore, every language should support them in all cases where this issue may arise</li> In languages which don't, leading commas are the best possible workaround</li> Having a leading delimiter is fine as long as it is also allowed in front of the first item, for example a YAML list starting each element with -</code>.</li> </ul> The issue</a></h2> Let's say you have a list of items separated by a delimiter. I chose commas because this is where you see this issue arise the most often, but this generalizes to any token-separated list of expressions. Let's start with lists as an example, because they are simple and easy: [ 1, 2, 3 ]</code>. Now, let's say the list is getting a bit long and you want to put every item onto its own line: [ 1, 2, 3 ] </code></pre> One thing which is common to do, is to append an item at the end: [ 1, 2, - 3 + 3, + 4 ] </code></pre> As you can see, to do this, one has to touch the line of the previous last element, despite nothing changing on it. Now, if you have a language which allows a trailing comma on the last element, like Rust or Go, you can easily fix this: [ 1, 2, 3, ] </code></pre> [ 1, 2, 3, + 4, ] </code></pre> The diff only has one line. But if you are on a language which does not support this, like Haskell or JSON, you are out of luck. Since this is a so common and prevalent problem in many situations and many languages, people have converged onto a common workaround: [ 1 , 2 , 3 ] </code></pre> [ 1 , 2 , 3 +, 4 ] </code></pre> In situations where a trailing comma is not allowed, this actually is very likely to be the best possible solution to format code in these cases. That's why people have independently converged on it over time again and again. However, as I will show, compared to simply having a trailing comma on the last item, this still has a lot of downsides. Case study: Function arguments in Nix</a></h2> Okay, so let's design a format for function arguments and leading commas and try to make it as good as possible. I'll cover all relevant design questions. (More may come up during an actual implementation attempt, but this should cover most of the ground.) Basics</a></h3> Let's start simple: Just three arguments, all single-line. There are already two possibilities to choose from. # 1 { arg1 , arg2 ? null , arg3 }: # 2 { arg1 , arg2 ? null , arg3 }: [] </code></pre> You may say "obviously we want the second one", but this already produces an inconsistency: In lists and attribute sets, we don't start the first element on the same line as the opening bracket/brace. [ first second third ] { one = "1"; two = "2"; three = "3"; } </code></pre> Of course we could decide to format lists and attribute sets like this for consistency, but pushing this further down the line would create weird situations. In these examples, one cannot easily start the first element on the same line as the opening bracket/brace: rec { one = "1"; two = "2"; three = "3"; } function call [ first second third ] function call # long line [ first second third ] </code></pre> This may even have ripple effects onto other syntax constructs like parentheses. So it looks like accepting the one inconsistency in function declarations is the less bad option here. Now let's have a look at the same situation, but with trailing commas. Same decision as last time: # 1 { arg1, arg2 ? null, arg3, }: # 2 { arg1, arg2 ? null, arg3, }: [] </code></pre> This time it is easy though, we can simply pick style #1 where no consistency issues arise. Multiline arguments</a></h3> Things are already getting tricky. # 1 { one ? [ 1 1 ] , two ? if "two" == 2 then 2 else "two" , three ? function [ 1 2 ] }: # 2 { one ? [ 1 1 ] , two ? if "two" == 2 then 2 else "two" , three ? function [ 1 2 ] }: # 3 { one ? [ 1 1 ] , two ? if "two" == 2 then 2 else "two" , three ? function [ 1 2 ] }: # 4 { one ? [ 1 1 ] , two ? if "two" == 2 then 2 else "two" , three ? function [ 1 2 ] }: [] </code></pre> There are many other variations to handle the indentation here, but the main issue in all of these is that it is ambiguous where the "base indentation" is. Does indentation start at the comma or at the argument? On the trailing commas side, there is little to debate. The syntax looks so similar to bindings in attrsets, that we can simply copy the rules over 1:1 (replacing =</code> with ?</code> and ;</code> with ,</code>). Yay for consistency! # 1 { one ? [ 1 1 ], two ? if "two" == 2 then 2 else "two" three ? function [ 1 2 ], }: [] </code></pre> @</code>-pattern</a></h3> In Nix, you can have the @</code>-pattern either before or after the argument destructuring. Both are equivalent. # 1 args@{ one , two , three }: # 2 { one , two , three }@args: # 3 { one , two , three } @args: # 4 { one , two , three } @ args: # 5 { one , two , three } @ args: [] </code></pre> Currently in Nix, leading @</code> is the more prevalent convention (estimated through some quick greps through nixpkgs</code>), but clearly it doesn't work here: the first argument without a leading comma just looks too inconsistent. (This is the same issue as three sections up coming to bite us again.) So the only sensible option is to normalize them to the trailing version during formatting. (Note that this is not as trivial as it may look like at a first glance, since any token may have comments associated with it which need proper handling as well. But it should be doable.) On the trailing commas side, it does not matter whether the @</code>-pattern is before or after the arguments: # 1 args@{ one, two, three, }: { one, two, three, }@args: # 2 args @ { one, two, three, }: { one, two, three, } @ args: # 3 args@ { one, two, three, }: { one, two, three, } @args: # 4 args @ { one, two, three, }: { one, two, three, } @ args: [] </code></pre> There are many possibilities on how to place the whitespace here, but in all cases this works without having to normalize the code. Comments</a></h3> Arguments may have comments associated with them. These may come in various forms, #</code>, /*</code>, /**</code>, single-line or spanning multiple lines. Trailing comments after the argument name are trivial and don't need to be discussed. # 1 { /* comment */ one , /* multiline comment */ two , # comment three , # multiline # comment four }: # 2 /* comment */ { one /* multiline comment */ , two /* comment */ , three # multiline # comment , four }: [] </code></pre> Style #1 has the disadvantage that the comma gets increasingly distanced from the argument it is associated with (comments may be long). It also loses the clear vertical line to the left which is one of the big advantages of a leading comma style. Style #2 looks more promising though. When using #</code> comments it even has a clear vertical line for visual reference. It may be tempting to thus decide to normalize all /*</code> comments to #</code> for that purpose. But this may be a controversial change on its own, but more importantly this cannot be done for /**</code> doc comments. Additionally, style #2 has the issue that the first comment collides with a potential comment for the entire function, causing ambiguity which would break any documentation tooling. Therefore, using style #1 for comments is the only viable option here. On the trailing commas sie, nothing really to discuss again: # 1 { /* comment */ one, /* multiline comment */ two, # comment three, # multiline # comment four, }: [] </code></pre> Digression: Leading delimiters all the way down</a></h2> There is an interesting observation to be made. Sometimes, expressions are not separated by a delimiter, but they are terminated by one. Think of the semicolon ending statements. Similarly in Nix: let foo = 1; bar = x: x; in {} </code></pre> 1. The semicolon on the last item is not optional. 2. The trailing comma style with a comma after the last item mirrors this. So, what if we flipped this on its head? After all, we are still trying out a style with leading commas. { , foo , bar }: [] </code></pre> Okay, this looks very weird, but one can clearly see that it solves one of the major issues with the usual leading commas style which comes up around the first element. One could even indent the commas by one level to solve the indentation ambiguities discussed earlier. This concept also generalizes to attribute sets: { ; foo = 1 ; bar = x: x } </code></pre> Probably the main reason you find this weird is that the comma is an unusual delimiter to start statements. Same concept in another context and suddenly it doesn't look that weird anymore: - foo - bar </code></pre> Alex Rogozhnikov has a great writeup on this topic: Delimiter-first code</a>. So while this idea requires syntax changes and thus is out of scope from a pure formatting perspective, if you find yourself designing a language, consider to briefly pause and ponder whether starting your statements instead of terminating them with a delimiter might be reasonable. Conclusion</a></h2> When trying to create a good style with leading commas, at every corner we are faced with tough decisions between sub-optimal options and allowing inconsistencies. The only reason to use them in the first place is when they are the less bad option due to language restrictions. In fact, I don't know of any in the wild examples of people using leading commas despite the language supporting a trailing comma on the last item. (If you know of one let me know, but examples where language support was added later on after the style was "established" don't count!) Further reading</a></h2> Other people have written about this topic as well. For now I'll just collect it down here, maybe if my text is not convincing enough one of these will do. If you find something, send it to me! On the virtues of the trailing comma</a></li> Delimiter-first code</a></li> </ul> Things you should read 2024-03-04T00:00:00+00:00 This is a collection of texts and books that I've read which I strongly resonate with or which have had an impact on my life. Some I just recommend reading, others I think everybody should have read, and a few are a must if you want to ever discuss certain topics with me. Posts and Articles</a></h2> undoing the pain – a guide to being free</a> (PDF)</a> A wholesome text about healing, for people who are deeply broken. This is not your usual self-therapy guide. It merely shows you the map, and you will have to navigate the territory yourself. I try to come back to it and read it again multiple times a year, to see where I am, where I want to go, and how far I've come. </li> The Asshole Filter</a> "If everyone around you is an asshole, maybe you are the asshole". This text shows up an alternative explanation than this adage, which also proves to be a very useful framework for interpersonal interactions. </li> Massless Ropes, Frictionless Pulleys: Coordinative Communication</a> This post talks a lot about how costs that are not measured are not controlled, how communication in organizations tends to be an unmeasured cost, how organization design affects communication patterns, and more. But its true value comes from adopting the mentality of finding unmeasured costs in everyday life that have gone out of control as a consequence. For example, finding all the small activities which my brain assumes to take zero time has tremendously helped me fight ADHD time blindness. </li> Letting Them Let Go</a> Grieving is an important part of life which most of us never really learn. Not processing these emotions holds people back and prevents them from moving on. Most importantly, this text shows how grieving happens so much more often than just when a loved one dies, and that acknowledging the grief in those situations as well is immensely important. </li> I'm a Trans Man. I Didn't Realize How Broken Men Are</a> Many trans people have the unique perspective of witnessing our patriarchal and sexist society from "both sides". And many people are not aware how deeply our patriarchy harms men as much as women, albeit in very different ways. (Also this is why I despise "men-vs-women" feminists) </li> Tone-Policing and the Assertion of Authority</a> Especially because I am in a position of social power in several places, I take the issue of tone policing very seriously. This text is my go-to on the subject. </li> What Liberal Arts Education Is For</a> Even when I was still in school, the "what will I need this for later on in my life??" discourse somehow made me cringe a bit. This text puts all my feelings on this topic and related aspects into words better than I ever could. </li> </ul> Books</a></h2> Adult Children of Emotionally Immature Parents – How to Heal from Distant, Rejecting or Self-Involved Parents Even if your childhood was absolutely fine™, chances are you this wasn't the case for many people you know and maybe love. Partners, dates, friends, superiors—This book explains both how to recognize and deal with emotionally immature people, as well as the many struggles of people whose emotional needs were unmet in the past. Moreover, I've found the approach of viewing all interpresonal conflicts through a lens of unmet or colliding needs as extremely helpful in many situations. </li> Meaningness</a> A web book on the meaning of life, religion, spirituality and so much more. </li> </ul> Tardis 2023-08-30T00:00:00+00:00 First non-digital art in the collection: An aquarelle painting. Nix ohne NixOS 2021-05-24T00:00:00+00:00 In 2021 hat das ChaosInKl</a> online eine "OpenTopicNight" zum Thema Nix veranstaltet. Dieser Vortrag über Nix auf nicht-NixOS-Systemen, mit Fokus auf nix-shell</code> und Entwicklungsumgebungen, ist dafür entstanden. Fur balls #2 2018-06-10T00:00:00+00:00 Shamelessly riffing on the success of Fur balls #1</a>, but as we all know the sequel is rarely as good as the original. Purple 2017-08-05T00:00:00+00:00 Brush study with Krita. Inspired by one of the paintings somewhere on the Documenta Kassel 2017. Network 2017-06-06T00:00:00+00:00 A more serious attempt at using the Animation nodes Blender extension for procedural generation. The image is 100% procedural based on modulated noise; the poodle is just a hallucination of your brain. (Seriously though, if you can't see the poodle then good for you because you won't be able to unsee it.) Minecraft #4 – Floating island 2017-04-30T00:00:00+00:00 This is the fourth image of a Minecraft world exported to Blender. It showcases the possibility of using creative materials on the model, in this case an X-ray inspired effect realized through volumetric effects. The third image shows a direct comparison: Minecraft screenshot – X-ray – Fancy render Disorder 2017-04-08T00:00:00+00:00 A small procedual texture experiment which never got past these three test renders. While this is 2D, it too has been realized in Blender: An "Emission" material which procedurally generates the texture acts as a pixel shader. Decompose effect 2017-03-05T00:00:00+00:00 One of the rare videos I did. This is an early experiment with the Blender extension Animation nodes, although more abstractly speaking one would better describe it as a vertex shader. Minecraft #2 – Panorama 2017-01-29T00:00:00+00:00 This is the third image of a Minecraft world exported to Blender. It showcases the theoretically infinite render distance one can achieve. The materials are taken from a texture pack which provides higher resolution and normal/illumination maps for all textures while remaining true to the Default Minecraft look. Planet 2016-12-22T00:00:00+00:00 Minecraft #2 – Nether 2016-10-29T00:00:00+00:00 This is the second image of a Minecraft world exported to Blender. It showcases the raytracing volumetric rendering which creates an atmosphere which cannot be achieved in real time. The second image is a 20% size test render, but which somehow accidentally turned out a lot better than the final version. Minecraft #1 – Flatland 2016-10-14T00:00:00+00:00 This is the first successful export from a Minecraft world to Blender using my (unpublished) tool Wavecraft. Pixel factory #2 2016-07-18T00:00:00+00:00 Floating island 2016-06-11T00:00:00+00:00 Fur balls #1 2016-05-08T00:00:00+00:00 Created by following a tutorial ·. Note that the second image is the original one. The first one is a higher quality re-render from 2019, in which the background was redone together with some other small improvements on the lighting. Pixel factory #1 2016-02-23T00:00:00+00:00 Entrance 2016-01-16T00:00:00+00:00 First 2D image, done with Krita and a graphics tablet. This image initially started as a 64px × 64px canvas with random lines scribbled on it. (All gray, color got only added at the end.) Then it got repeatedly upscaled with details filled in, until it converged to some kind of meaningful image. This is also why the lines in the image are so big and a bit blurry. Music box 2016-01-11T00:00:00+00:00 Winter #3 2015-12-24T00:00:00+00:00 Study for a shiny snow material. Winter landscape 2015-12-15T00:00:00+00:00 I have deleted all other Christmas-themed winter images except for this one. So, enjoy this rarity. Carousel #3 2015-10-18T00:00:00+00:00 This image was inspired by "Skyfall", one of the "zero G" free fall towers. Landscape #2 2015-10-12T00:00:00+00:00 First attempt at a low-poly style. Carousel #2 2015-10-10T00:00:00+00:00 Continuation of Carousel #1</a>. The carousel model is slightly improved and placed in a proper scene. Landscape #1 2015-09-06T00:00:00+00:00 Carousel #1 2015-02-01T00:00:00+00:00 Small modelling study Marble maze 2015-02-01T00:00:00+00:00