robryk @robryk@qoto.org

@lutzky @psn

Fair point. In that case: what makes vigilantism illegal?

I know of attempts to make _some kinds_ of vigilantism illegal: when they end up in illegal acts against the purported criminal (ISTR that some of the "incitement to violence" statutes have such origin), or when they coerce the victim not to make use of the standard justice system (which is often served by the surprisingly broad definition of blackmail in the law).

Note that in particular when one is suspected of committing a crime, and even is acquitted, it's perfectly legal for them to continue to suffer consequences of that suspicion. In fact, they can even lose a civil case that hinges on them committing that criminal act (because the standard of proof is different).

@foone Why should that be a good indicator of unity's ...decision?

@lutzky @psn

I don't think so. Vigilantism, the way I understand it, requires the acts that harm the person accused of committing a crime to be illegal.

@lutzky @psn

What could make that illegal?

@psn

Why is this very different than other associations that have due process for ejecting members? I would expect that they all would be faced with that problem (members claim other members harmed them in a very significant and illegal way but don't want to get the law enforcement involved; the association wants to prevent future harm). Is there something that makes universities more likely to encounter it, or that makes it more difficult for them to deal with it, or that makes the expectations on them different?

@delroth If I look at the mime types of all the things I have in my local store, there's lots of gzip. However, that seems to be:
- manpages, infopages,
- fonts, keymaps,
- entries in prefetched npm deps,
- sources, patches,
- some testfiles.

@delroth I wonder about false negatives caused by compression. (Doesn't python modules distributed as egg files compress native libraries?)

@delroth what string are you searching for?

@danluu Would you consider having to pay fines for lack of driving license, the lack of which was caused by rules that prevent one from getting it if one has unpaid fines, an example of Vimes' boots theory?

@delroth

https://gist.github.com/joseluisq/e7f926d73e02fb9dd6114f4d8be6607d might be helpful (tl;dr awaiting the future just executes it on the same thread; you need to spawn a task with tokio to get any parallelism)

@freemo TIL that the "pair" part meant "prepare" (https://www.etymonline.com/word/repair#etymonline_v_12814)

@equinox

Another reason why this is better than mounting a file on top of a file is that when you bind mount a file, the source of the mount is an inode. So, if the source file gets unlinked (e.g. because someone wants to atomically update it), the mount will continue to point at the file that was unlinked.

Bind-mounting a directory with the source file on the side and bind-mounting a symlink to the source file on top of the target file gets rid of that footgun (because you presumably won't want to update the symlink).

@niconiconi Ah, and yet another thing that is theoretically poorly studied IMO but does actually even appear in practice are data structures that are lock-free with high probability (i.e. with low probability they might even block).

I'm somewhat sour that this is not a better-studied area, because most of my inventiveness when I was working on this area was spent on dealing with edge cases caused by patterns of extreme scheduler unfairness that I never once managed to trigger on actual hardware. (And I would guess that if we had a way to formalize this, I could have reduced this to "particular patterns of scheduler behaviour, that are necessarily low-probability if the scheduler is not allowed to observe your internal state").

@niconiconi

One other area that is interesting and is (or at least was ~8 years ago) badly studied is measuring time in some other way than ~instructions. Back then I couldn't find a measure of complexity that would tell me that e.g. a structure where each thread increments its own memory location is faster than a structure where everyone does fetch_and_add on a shared memory location instead.

@niconiconi What would you be taking the probability over? If you think the scheduler itself is random as opposed to adversarial, then the scheduler will have almost surely bounded unfairness, and there are results that give you lots of IMO neat things when scheduler is boundedly unfair.

If you want to keep the scheduler adversarial (which I don't expect you do because it seems unrealistic), then there's lots of latitude in model definition on when (and if) that adversarial scheduler learns about your RNG's outputs.

Also, lock-free is terribly defined (wait-free and obstruction-free don't share this problem): the way it's commonly defined does not compose, and the way you need to define it so that it composes doesn't admit a neat description that I know of. (Please say so if you want this verbosified.)

@rotopenguin @danluu

Hmm~ either I am very blind to my own bias towards smartness, or the areas of software engineering that have something to do with governmental standard seem to be more about sounding right than upholding verifiable statements. Perhaps it's important that standards in other areas are older, so have went through more amendments?

@isomeme

Look at https://palant.info/2018/03/13/can-chrome-sync-or-firefox-sync-be-trusted-with-sensitive-data by @WPalant (and the linked update from this year).