It would be unwise for a bank to publish its exact fraud detection and risk management policies, otherwise they could be easily circumvented. A lot of these policies will be embodied in their internal backend services.

Someone will now inevitably mention “security by obscurity”. But Kerckhoff’s Principle is specifically about cryptosystems which should derive their security solely from the strength of the keys. That way, confidentiality is still ensured even when details about the cryptosystem become known to adversaries.

But non-cryptographic aspects of security benefit from asymmetric knowledge, from grey areas, from increasing risk for adversaries.

You actually get a say in how that money is spent, whereas if you donate to developers directly then they decide …

You get to be involved in a “steering committee” of sorts for that project,

The project itself always decides, unless you fork the project and do your own thing. You can wave a carrot in front of them (if you do X then you get $Y), but the relevant factor is going to be the size of the carrot $Y, not directly the “collective bargaining” via that platform. How would your platform facilitate finding a stronger negotiation position?

this membership organization is incorporated as a non-profit, whereas the software project you’re supporting may not be

It sounds like you may have discovered the “fiscal sponsor” concept. There are a couple of nonprofits already offering such services, such as the Software Freedom Conservancy or OpenCollective. The foundations like Linux Foundation, Apache Foundation, or Eclipse Foundation also come to mind.

However, for all of these the project decides to join a host. Foundations can’t just annex projects.

Synology’s DSM has built-in MFA support, though it also has some features for external identity management. I don’t think Keycloak and so on would be compatible though.

C++ does have the problem that references are not objects, which introduces many subtle issues. For example, you cannot use a type like std::vector<int&>, so that templated code will often have to invoke std::remove_reference<T> and so on. Rust opts for a more consistent data model, but then introduces auto-deref (and the Deref trait) to get about the same usability C++ has with references and operator->. Note that C++ will implicitly chain operator-> calls until a plain pointer is reached, whereas Rust will stop dereferencing once a type with a matching method/field is found. Having deep knowledge of both languages, I’m not convinced that C++ features “straightforward consistency” here…