UnquietTinkerer

Thanks for posting this. It served as a call to action for me, and hopefully it will for others as well.

Oh look, my old friend Checked Exceptions! I knew we would meet again one day :)

In all seriousness, anonymous sum types would be quite nice. It would make it easier to be precise about return values in situations where `Optional` and `Result` are not sufficient.

The problem with checked exceptions (well, one of the problems) is that the full set of error conditions a function might encounter is often _too_ detailed. Encoding them all into the type signature of every function can be a lot of work, and quite brittle to minor internal changes. So most code bases will still need a catch-call error type that gets bubbled up to a generic handler somewhere.

Cute idea. I like that you can click on the creeps to invert their value.

However, I found that the path logic inscrutable and frustrating. The creeps take a random path when they reach some intersections (I think? There was no explanation and no obvious pattern). Success in stage 8 seems to depend entirely on luck. I would expect a game themed around computer logic to be more deterministic.

Wow, that guy is ... extreme. I'm glad you posted the link, but I'd personally take any conclusions he draws with a grain of salt.

This is a good line of questioning. I believe that the difference between the two situations is that the pizza deal is implied to be just for Alice and Bob. If either walks away then the deal is totally sunk, so they both have equal "leverage" over the deal.

When you frame it as an investment question, the implication is that if either person walks away then they can be replaced by a third party who is willing to stake the cash. Since it is easier to replace someone when their stake is lower, the person putting up the $2k has less leverage in this case.

If you explicitly limited the investment to two specific people (imagine a crazy term in a will or something), then I think you'd end up back with a $7k/$5k split.

Off topic for password rotation, but has anyone tried assigning randomly generated passwords to the users rather than letting them choose their own?

People (including me) _hate_ memorizing things and would probably write an assigned password down, but isn't it better to expose passwords to nosy coworkers than to the whole internet, as is so often the case with weak or reused passwords?

Just found this (on reddit). I'd love to know more about what's going on.

It's amusing that the Go app was built in a highly controlled environment, while the kernel was built on some random laptop (and was compromised).

It seems like the attack was highly specialized, so I assume that the PII being handled by this client/victim is pretty valuable?

Try this shell script:

    #! /bin/sh
    # This is a bit hacky: we use the -i flag to force the interpreter into 
    # interactive mode after the initial commands are executed.
    # The "proper" way to do this is probably to set up a PYTHONSTARTUP file
    # and put the initial commands in there.
    exec ipython3 --no-banner --no-confirm-exit -i -c '
    from math import *
    import random
    import sys, os, platform
    print("== IPython %s Calculator REPL ==" % platform.python_version())
    '

Ironically, xonsh itself suffers from a long startup time due to it's use of python. This is my primary (negative) experience with the issue in the linked article, and the reason why I stopped using xonsh.

If we can't quantify "internal experience" then what leads philosophers to believe it exists? What evidence is there that conciousness is distinguished by something other than raw complexity?

I don't understand how lazy loading could help here. The images are all behind hyperlinks, and their display sizes are all hardcoded into the HTML. There is nothing preventing the browser from completing the page layout immediately and backfilling the images as the load.

That is not to say the page is well-designed or pretty - it is hideous. But lazy loading would make it strictly worse by adding js parse+eval latency on top of the loading time for the images.