This post raises two common criticisms against proof-of-stake: it's self-referential (and therefore cannot work), and it's subjective (and therefore cannot work). Each of them have a bit of truth to them, but (spoilers) I strongly disagree with the conclusions.

------------

The "proof-of-steak is self-referential (and therefore cannot work)" argument goes like this:

1. Proof-of-Stake chains claim to be secure because there is value at risk.

2. The value at risk are the coins _on chain_, which only have value because the chain is secure.

Therefore, as the "thing" giving the coins value is the coins having value themselves, this is self-referential, and so cannot work.

Two quick responses. First, PoW has the same dynamics, albeit a bit more obfuscated.
1. The PoW chain is secure because there are miners willing to mine on the chain.

2. The miners are willing to mine on the chain because they get paid in coins that have value.

3. The coins have value for a multitude of reasons (duh, speculation), but one seemingly necessary one is that the chain is secure enough to allow transfers (aka, the chain is secure).

So in PoW, we have the same self-referential dynamic.

Second, there's no reason why self-referential systems don't work in the first place. I'd argue that a much more informative way of thinking about PoS/PoW as mechanisms is in a recursive way:
1. Value at time T -> Security at time T
2. Security at time T -> Value at time T + 1
etc.

You can call anything that references itself a "perpetual motion machines." Merge sort references itself - that doesn't make it one.

I would argue the recursive bootstrapping described above is one of the most interesting mechanisms public blockchains have currently (rivaled only by the crazy composability of programs you see on smart contract chains like Ethereum).

---------

The "it's subjective (and therefore cannot work)" argument goes like this.

1. Stake is defined on the chain.

2. Stake determines which chain is the real chain.

3. Thus, if you have two chains that claim to each be the real chain, you cannot tell them apart.

I'll note: this is pretty much true. For most modern PoS protocols that exist today, some form of initial "checkpoint" is needed to sync the chain. You need a blockhash to start from.

However, after you sync your node for the first time using this has, this is no longer the case: as long as you sync your node to the chain more than once a month or so, you never need to do this again. Aka: you only need to get a hash of the chain upon initial sync.

Practically, IMO, this pretty much changes nothing. 99.99999999% of users don't read the source code of the nodes they run (in fact, most people don't run nodes :() - and since node releases are on the order of once a month [1], users can just get the block hashed packaged with the software anyways. In most realistic security models, not much is different.

---------

IMO, the biggest argument against PoS is it's complexity. Making a secure PoS protocol requires a lot more work than a basic PoW one. Managing this complexity appropriately is hard, and takes time + incremental steps if you want to do it well (and not fuck an existing network). That's mostly why Ethereum's PoS has been so delayed. But it's coming soon :). Shout out to the awesome people working on it!

Source: I spent 3 years working on a variant of Casper (Ethereum's PoS protocol) at the Ethereum Foundation.