I have two questions.

1. After the revolution, how to you prevent the people that were influential during the revolution from seizing power for themselves, becoming the new bourgeoisie. This happened time and time again in practice.

2. Even in the best case scenario, the decisions on what to produce become centralized in the hands of politicians. Political systems that we tried so far don’t work that well in practice. Is this really the best solution?

I started exercising, I quite embarrassingly couldn’t do even a single push-up, I can do 20 now.

My Ender 5 has been lying around for 3 years, maybe I’ll dust it off during the weekend :)

When does the narwhal bacon?

None. I’m kind of surprised most people don’t use lemmy the same way as reddit, I assume nobody just browsed /r/all?

Cataclysm: Dark Days Ahead

It’s a time machine that teleports you to 3am the next day.

Sanmill

Basically nine man’s morris, it’s pretty fun trying to beat progressively harder AI. Each difficulty requires a different (better) strategy. It’s like unlocking levels in a puzzle game.

Play chess.

deleted by creator

deleted by creator

I don’t have 2 mil, how do I get out of this? File for bankruptcy?

deleted by creator

deleted by creator

https://nixos.wiki/wiki/Configuration_Collection

On a phone with spyware installed that wouldn’t do anything. There are probably ways to get rid of it, but how can you be sure?

Nope. Monads enable you to redefine how statements work.

Let’s say you have a program and use an Error[T] data type which can either be Ok {Value: T} or Error:

var a = new Ok {Value = 1};
var b = foo();
return new Ok {Value = (a + b)};

Each statement has the following form:

var a = expr;
rest

You first evaluate the “expr” part and bind/store the result in variable a, and evaluate the “rest” of the program.

You could represent the same thing using an anonymous function you evaluate right away:

(a => rest)(expr);

In a normal statement you just pass the result of “expr” to the function directly. The monad allows you to redefine that part.

You instead write:

bind((a => rest), expr);

Here “bind” redefines how the result of expr is passed to the anonymous function.

If you implement bind as:

B bind(Func[A, B] f, A result_expr) {
   return f(result_expr);
}

Then you get normal statements.

If you implement bind as:

Error[B] bind(Func[A, Error[B]] f, Error[A] result_expr) {
   switch (result_expr) {
       case Ok { Value: var a}:
           return f(a);
       case Error:
           return Error;
   }
}

You get statements with error handling.

So in an above example if the result of foo() is Error, the result of the statement is Error and the rest of the program is not evaluated. Otherwise, if the result of foo() is Ok {Value = 3}, you pass 3 to the rest of the program and you get a final result Ok {Value = 4}.

So the whole idea is that you hide the if Error part by redefining how the statements are interpreted.

You can probably replace it with ImageMagick.

I usually kill them with my phone with the screen turned on (the background needs to be blueish and the room needs to be completely dark). For some reason they don’t see it, they just sit there until they get squashed.

This doesn’t work for tiger mosquitoes.

Turn JavaScript into Bash with these easy steps…