This bug was on the Solana blockchain. Solana has built in support for updating code.

Even on Ethereum, with it's mostly immutable contracts/programs, there is a super common pattern of a tiny shim contract that forwards all calls on to another contract that does all the work. By changing a storage variable which changes the contract the shim points to, you can effectively upgrade the code.

And therein lies my biggest frustration with crypto evangelism. Almost every theoretical benefit that gets trotted out is such a detriment in practice that the ecosystem tosses it aside. While still proclaiming it as a virtue.

I would wager most contracts deployed these days are immutable. Upgradable contracts are frowned upon in the space, moreso every day.

But given that humans are prone to making mistakes, when code is fresh and unproven, proxies are a practical way to go. Once you've ironed out all issues, you blow the fuse so that the contract can't be changed anymore.

> Once you've ironed out all issues

Yeah this is something that famously happens with software development, you just iron out all the issue and then never have to change anything ever again.

> can't be changed anymore

.. which means that when an undiscovered vulnerability is found all the investors are guaranteed to lose their money.

> the ecosystem tosses it aside

This is false. Many of the most heavily used Ethereum contracts, such as Uniswap, are non-upgradeable.

The one to which you can send back the stuff it sent you, and it essentially burns the money?

And that can’t be fixed because it’s immutable?

Correct, but what they can do is hard fork and encourage users to switch to the new version. Users will vote with their feet and choose the version that benefits them most. In a sense it's still upgradable, but only through direct democracy instead of delegated democracy / oligarchy. (and for the record I don't necessarily think that's a good thing for a financial system, but we'll see how it plays out in the next few years)

A common pattern is to deploy a proxy contract, which simply forwards all function calls to an implementation contract, then an upgraded deployment generates a new address, the proxy contract is changed to point to the new address, and all end users only interact with the proxy contract. This is a little bit frowned upon in the community because it's a point of centralisation and control.