Could the "sync" mechanism be provided by iCloud, Dropbox, etc. so long as it's end-to-end encrypted?

Managing a vault server sounds like a pain.

The advantage of a vault server is that it can rate-limit your login attempts based on your master password in a much better way than layering an encrypted password store on generic cloud/synced storage using modern PAKEs.

If many different "states" are used for one big architecture, how are the boundaries between them managed?

Under one state, Terraform will spot issues here during `plan`, but with many states issues will only appear after `apply`.

Not disagreeing, but you might find it interesting to learn about the history of the term "jaywalking"

> Flix looks like Scala, but its type system is based on Hindley-Milner.

Ahh why?! Scala is FP larping as OOP. Great type system, poor syntax.

Does Nostr have any mechanisms to ensure anonymity, or can the relay log everything?

> Does Nostr have any mechanisms to ensure anonymity

Your identity on the network is a public/private key pair. You don't have to associate your real name with your posts, if you don't want to. And you can have multiple key pair identities if you want.

Posts are plain text by default, but encrypted private messages can also be exchanged.

You can choose what relays to post to, and obfuscate your ip address with a vpn or tor if you desire.

> can the relay log everything

Yes, subject to the above mitigations.

Be sure to checkout Koyaanisqatsi if you like experimental films and Philip Glass

Also be sure to check out The Hours.

And Truman Show! Epic soundtrack. Also Jane (documentary on Goodall), which is almost a reworking of the Mishima music.. extremely similar, but I still found it to be vibrant and fresh.

Also if you listen to The Truman Show main theme, you may find that it sounds very similar to The Leftovers main theme. I’m quite certain that Richter must have borrowed elements from it.

Also be sure to checkout Candyman if you like horror films and Philip Glass.

Also be sure to check out "They Came in Through the Bathroom Mirror" if you like Candyman.

( https://chicagoreader.com/news-politics/they-came-in-through... )

But then you are working on half as many things.

After quarter of century as a developer with 1/3rd of this time in pair programming teams I can say that's not true.

Works goes faster when you work with another person even if for the fact it is harder to procrastinate.

And problems are always easier and cheaper to solve the earlier in the process they are caught.

Then there is the simple fact that a well executed coding review will take significant portion of the time it took to make the change. Most coding reviews are really only cheaper because the reviewer is just skimming the code to see for obvious faults. So it is not really apples to apples comparison.

Often working on half as many things and executing them well is a good idea...

Indeed. Feels like vast majority of the TV worth watching is HBO. I value my time so I'd rather have access to a few HBO series / year than an endless sea of A/B dross.

At work I am always hopping between F# and JavaScript and I'm convinced that if more people had this experience they would want the pipe operator in JavaScript.

Unfortunately it's hard to convey the advantages to those who haven't used it. Maybe it's because it's such a simple bit of syntatic-sugar?

The F# syntax is an incredibly simple bit of syntactic sugar.

Just replace this:

    x |> f

With this:

    f(x)

For the join example, you must do this:

    xs
    |> (x => x.join(' '))

It de-sugars to:

    (x => x.join(' '))(xs)

... which of course is simply:

    xs.join(' ')

Sure, I know. What I actually mean is that I don't grok curried functions.

Does join(a)(b) mean join(a, b) or join(b, a)? Does it mean a.join(b) or b.join(a)? And is a or b the delimiter? I don't really feel confident without looking it up or trying it out. I have a similar problem with Haskell's function syntax a -> a -> a.

If the function was called makeJoinerBy(sep)(array), it would be somewhat clearer:

    join = makeJoinerBy(' ')
    result = join(array)