Some initial questions on the Kindelia WhiteBook

[lancejpollard]

I have a TON left to read throughout all of your team's projects, lots left to learn, but wanted to ask some questions up front of things which still don't resonate with me or make sense at a detailed level to me yet. Sorry for all the questions, hopefully these can be used to extend the docs!

Turing-complete blockchains, such as Ethereum, allow users to deploy decentralized applications (DApps), but recurrent security exploits undermine their proposals.

• What is special about DApps on a turing-complete blockchain? Why should I care basically?
• Where to learn more about DApp theory?

Formal verification techniques can be used to ensure a DApp is exploit-free.

• How much work does it take to write all the formal verification to make sure the DApp is exploit-free?
• Is it realistic?
• Do you have to do it again for every new app, or one person does it generically once and it works for every app?

global state as reversible runtime heaps

• What does that look like?

Arbitrary apps could be easily created as Ethereum contracts, without launching a new network.

• What is the basic rundown of a "contract" in this context? Where to learn more?
• Can you explain what it means to launch a new network in more detail? What/how do the contracts simplify?

millionaire smart-contract exploits

• What is that?

Regarding security, formal verification techniques allow developers to deploy contracts with zero bugs on their first version, which is invaluable, since they can't be patched or reversed.

• What does "since they can't be patched or reversed" mean in practice / slightly more detail?

[HVM] is a massively parallel runtime capable of evaluating functional programs optimally.

• How does the parallelism work? How is it implemented at a high level?

HVM's solution: make clones cheap.
HVM's runtime has no references. Instead, it features a .clone() primitive that has zero cost, until the cloned value needs to be read. Once it does, instead of being copied whole, it's done layer by layer, on-demand.

• I still don't see the true benefit/value, it is over my head. How/why is this different from just cloning up front? How does this solve the reference problem?
• Why is the better than Rust's powerful borrow-checker?

In the context of garbage collection, since the data is actually copied, there are no shared references, so memory can be freed when values go out of scope. For the same reason, parallelism becomes trivial.

• Can you explain in more depth how "parallelism becomes trivial"? What is the core problem that it solves related to parallelism?

To learn more about HVM's low level implementation and memory layout, check the comments on ../src/runtime/base/memory.rs.

• This link is broken: https://github.com/Kindelia/HVM/blob/master/guide/runtime/memory.rs