I think smart contracts should be part of the main chain if they can be implemented in an efficient way ..
Turing Complete Scripting may be a different thing though ..
Yes that is my point, if a side chain can interop with a fast chain (Bitshares 2.0), the side chain, slower / non priority with (Non very performant smart contracts, turing complete. low priority transactions), this will be great.
This is a bad idea.
1) Smart contracts, debate whether or not it should be Turing complete or decidable as a design consideration.
2) If Bitshares 2.0 is scalable, the smart contracts will be too.
3) Create a market for computation, storage, etc, with a DHT. It doesn't have to be a side chain and makes no sense why you think it would.
So you can sell storage space to the Bitshares 2.x, or sell computation, and if you do it this way you can eventually evolve Bitshares into a decentralized computer.
Ethereum is attempting to do that, and over time Bitshares could evolve down the same road, but for now in my opinion the developers should tread carefully on smart contracts because the design of it is not trivial.
Turing complete seems to not work as well as we thought it would looking at Ethereum, and also the security implications. Ethereum requires you to secure it by isolation, virtual machines, sandboxes, etc. The other way to secure it is by correctness, where every smart contract is a formal proof, and verified. In that case you can do distributed computation safely because you can verify with certainty that the code is correct, with no bug.
Sandboxes and virtual machines sometimes can leak, and they are slow. Additionally random numbers and HPC as far as know cannot be done on virtual machines.
An authenticated data structure (ADS) is a data structure whose operations can be carried out by an untrusted prover, the results of which a verifier can efficiently check as authentic. This is done by having the prover produce a compact proof that the verifier can check along with each query result. ADSs thus support outsourcing data maintenance and processing tasks to untrusted servers without loss of integrity. Past work on ADSs has focused on particular data structures (or limited classes of data structures), one at a time, often with support only for particular operations. This paper presents a generic method, using a simple extension to a ML-like functional programming language we call lambdaAuth with which one can program authenticated operations over any data structure constructed from standard type constructors, including recursive types, sums, and products. The programmer writes the data structure largely as usual; it can then be compiled to code to be run by the prover and verifier. Using a formalization of lambdaAuth we prove that all well-typed lambdaAuth programs result in code that is secure under the standard cryptographic assumption of collision-resistant hash functions. We have implemented our approach as an extension to the OCaml compiler, and have used it to produce authenticated versions of many interesting data structures including binary search trees, red-black trees, skip lists, and more. Performance experiments show that our approach is efficient, giving up little compared to the hand-optimized data structures developed previously.
https://amiller.github.io/lambda-auth/https://amiller.github.io/lambda-auth/paper.htmlhttps://docs.google.com/presentation/d/1Ycqpsm6an-jvQk3SEHB130JlyGiWJEDZ7Zj-eVMe3ss/edit#slide=id.g2a22b5644_00