What is it about Charles Hoskinson that makes so many people distrust him?

Disclaimer: I'm an ADA bag holder.

I know some people who are hardcore anarcho-{socialist,communist} and don't like the idea of material inegalitarianism (some people owning more money than other people) in the first place, but I'm assuming that's not any of you, b/c you're all invested into some cryptocurrency hoping to make gains and keep them away from Big Brother. In any case, CH advertises himself as a "libertarian anarchist" (basically an anarcho-capitalist), which is where I place all of you, b/c you all like crypto but don't like the government.

The most common criticism that I see of him around here is that, for a guy who "talks" as much as he does, his blockchain isn't active in terms of new features or development. To this, he often responds that his blockchain has met with the highest number of code commits (this can be seen by anyone on Github), but the community response to that is that development should be measured in features and working products rather than lines of code.

To the point of why development on Cardano is slower than on other blockchains, most bag-holders like myself argue that auditing, formal verification, and peer-review, take time, but that seems not to be a sufficient explanation for many of you. My hunch is that many people, especially those not in the tech industry, don't understand why those things are important, so I'll try to do a bit of an explanation:

There's a difference between writing code in a programming language, testing it, and expecting it to do the thing that it's tested to do and formally verifying that it does what it advertises. Most code, e.g., the Ethereum blockchain, is written using the former methodology of:

1. Tell the developers what the code is supposed to do
2. Get the developers to write the code
3. Get the developers to write test-cases (which are also code) to test the code as in (2) to make sure it does what it advertises
4. Release the code to the public

I'm not saying this methodology is wrong, per se, but it's not what Cardano is going for. The point of Cardano is to do research to define mathematically what the algorithm should do in the first place and then implement the algorithm in such a way that (3) in the above is not even necessary. I can explain this point further:

Consider the following code snippets, written in Python and C++ (both common languages for development) respectively:

python greeting = "Hello, Redditor" print(greeting)

```cpp // We need "using namespace std;" if you wanna be formal about it

string greeting("Hello, Redditor"); cout << greeting << endl; ```

In short, the difference between these two snippets of code is that the latter declares the variable greeting as a string explicitly in the code, while the former doesn't specify what type the variable has. Consequently, in the former case, the computer doesn't know what type the variable greeting has until runtime (when the code is actually running), whereas in the latter case, the fact that greeting has type string is known as compile-time (before the code is running itself). The former is thus called "dynamically-typed", whereas the latter is "statically-typed".

Think of static typing as additional information provided to the runtime (the code required to run the code) to help figure out different properties of the variable, e.g., how much memory needs to be allocated for them. Generally speaking, it is desirable to use static types over dynamic types for correctness, i.e., when you want to be clear about what your code does without having to explicitly test every bit of it.

Suppose, for example, that you wanted to use your code to prove a mathematical fact; something like the simple claim "If a is an even number, and we define b = a + 1, then b is an odd number". Case in point, the proof takes the following form: "If a is even, then a = 2k for some integer k. Then, it follows that b = a + 1 = 2k + 1; this suffices to prove that b is odd by definition, being that an odd number is defined as a number of the form 2x + 1 for some integer x."

Using the open-source development tools preferred for Cardano development, you could define static types for odd and even numbers respectively, and then proceed to prove mathematically that the above claim is true. In other words, Cardano development has moved far past correctness-driven static-typing in the flavor of C++ that I described above; we're at a point where we can automate entire mathematical proofs that are formulated by the cryptography researchers.

This is why the Cardano development methodology looks something like the following (note the difference from the status quo methodology described):

1. Write a research paper to prove that whatever you're building mathematically makes sense
2. Get the research paper peer-reviewed so that other researchers look at it and confirm that it does indeed make sense
3. Write out your claim and your proof in code, i.e., in something like the Agda programming language), and make the theorem-prover check your proof to ensure that it is correct
4. Automatically generate Haskell code, which can run on mainstream computers, that completes the requirement of whatever you're building
5. Test and ship the code as above

This process is a obviously more rigorous than that which is underwent by the likes of Ethereum and Solana. Obviously, this slows the development process down, which is a big point of criticism from Cardano's malcontents, but the heightened rigor of development is highly desired for a system that's going to run billions or trillions of dollars' worth of software. In just the last year, $10.5 billion has been lost to DeFi hacks and the like, and we see people posting here about Metamask vulnerabilities and so on all the time; if you'd rather prefer your money to be held on a network following silicon valley's "move fast and break things" methodology, then you can't really complain when your money is lost in the likes of the DAO hack.

Hopefully, it's clear from this why Cardano development is slower than on other chains. You can see the audit of SundaeSwap by Runtime Verification as an example to evidence that this level of rigor is maintained throughout the community (sure, some Ethereum dApps are audited too, but it is most definitely NOT the default).

TL;DR: It's my technical opinion that no blockchain, including Algorand, has as rigorous a development methodology as Cardano (limitations of Algorand include: accounts-based ledger, as opposed to Cardano's e-UTXO construction, as well as hard-coded relays run by Algorand Foundation instead of network decentralization with P2P peer discovery). My argument is that Cardano FUD is largely unfounded and propagated by people who don't understand what formal verification is or why it's valuable, instead just liking to see their bags moon in order to reaffirm their biases.