JJG already explained things well, but I'm going to add a few things, so that maybe you start to understand.
Being bad because of turing complete is bullshit. ETH is turing complete, but smart contracts dont have to, so that argument is dead from the start.
It would indeed even be worse if smart contracts were themselves Turing-complete state machines. But this is not what I'm alluding to. In a Turing-complete language, you cannot *automatically and systematically* test a random given piece of code on ALL OF ITS STATES because that set is potentially infinite.
In other words, if I give you a random piece of byte code (which is an actual contract you're wondering if you should engage with it or not), there's no systematic way to obtain the full state tree from it with a tool. Mind you that you have to use the *byte code* and not the Solidity source code from which it is supposed to be compiled, because in the end it is the byte code that will be running, and all subtleties of side effects of the compilation are too difficult to take into account. A given contract doesn't even have to have Solidity source code: you can always set up the byte code independently.
There's no possibility to obtain *automatically and with certainty* the full state tree of a contract.
And the whole art of lawyers looking at business contracts is to explore the state tree: ALL possible states and outcomes a contract can have. THE VERY PRINCIPLE of an honest contract is that the signing parties are aware of ALL the possible states and outcomes of a contract.
This is entirely different for software in general. Software in general (for instance, scientific software) is often used to obtain outcomes *people didn't know in advance*. Here, Turing-completeness IS a good thing.
But NOT in contracts. In as much as a contract is supposed to be honest, ALL ITS STATES must be obviously understood and known to the signing parties. And that is exactly what Turing complete languages don't allow you to obtain with certainty on a random piece of contract byte code. This is also why there is this stupid gas limit of which all the exploits are not yet starting to occur and for which one can design very, very subtle exploits.
Now, of course you CAN limit yourself to a testable SUBSET of byte code, but that misses the point that you cannot test "a random contract given to you" ; that the nodes cannot do that test, and hence have to apply a gas limit of which nobody knows exactly what leaves this cuts off the state tree/graph of the contract.
On non-turing complete contract systems, you don't need any gas limit, because every node can analyse the contract, and find out how big the state tree is, and what is its longest path.
Cutting away "long paths" with a gas limit can introduce also a lot of exploits. For instance, you might set up a contract such that redeeming ether is only possible for certain addresses, because the calculation is depending on the address and for most addresses, this calculation is too long and will always be cut off by the gas limit ; or you could be more subtle, and have certain contract instructions to be impossible by gas limit if they come from certain addresses. This could even be induced after the contract is running, by giving instructions that can only come from one address, obfuscated by gas limit.
The gas limit is necessary because of Turing completeness, and the fact that a node cannot analyse the tree of just any random contract.
Immutability ? Are you that naive ? Any blockchain can hardfork, eth is not less or more immutable than any other blockchain and no project can guarantee that wont happen.
Don't confuse a technical hardfork and breaking immutability. Even if monero is hardforking over introducing confidential transactions, this is not breaking immutability as compared to the INTEND of the white paper. Bitcoin never broke immutability, but hardforked several times - all this time, the intend of the white paper has been preserved, and all of the history has been preserved.
The only time that one could naively think that this didn't happen, was when a BUG in the node software didn't follow the white paper intend, and allowed for *non valid blocks by intend* to be validated erroneously. When the bug was repaired, the white paper intend was restored, and of course a whole lot of blocks turned out not to be valid: but the point is, they NEVER were valid according to the intend of the white paper. So this was not a break of immutability.
Mind you that node software is NOT a smart contract, but normal software, that implements INTEND. There's nothing wrong with changing that software, as long as one sticks to intend, and as long as one preserves the past in as much as that past was in agreement with the intend of the protocol.
The whole idea of the block chain technology is that the antagonism between the players, their diversity and number is so big, that only consensus can be found over the original white paper intend, and the real history according to that original protocol (as intend).
But you are perfectly right that this can fail. There's no guarantee that this immutability will remain. However, in that case, the block chain failed. It is no more or no less than a 51% attack. People can decide to continue to use the failed chain. This is my big surprise with ETH: it is a failed chain, that has been 51% attacked, but continues to live on.
Any blockchain can be hardforked so if you dont agree with that, dont join blockchain scene / dont invest.
I don't call gambling on block chain tokens "investing". It is gambling, nothing more and nothing less. Investing means helping to set up production capital with economic growth as its consequence and source of reward. Buying bitcoin and hodling, or gambling on altcoins, at no point, helps buying capital goods or services: it only pumps money from greater to lesser fools.
If you're in the gambling business, actually you don't mind in any case what happens, because you're betting on a random generator. If you're in the crypto token gambling business, there doesn't even need to exist any block chain: just tokens on exchanges: IOU on websites.
You are right that the danger of a block chain failing exists. What is amazing, is that the tokens of failed chains continue to be traded. That is, to me, like if one were still trading Apple shares the months after Apple was out of business. But it is not impossible. After all, trading only needs belief.
And a one case scenario doesnt make it rule, people only agreed with it because it didnt really rollback anything besides the dao, it was a special case, dao was LOCKED. If hacker could withdraw it immediately and sell or what not, hf wouldnt have been an option anymore. You are very naive and ill informed.
I know that. But it created a huge moral hazard: first of all, it didn't punish the DAO gamblers as it should have, for having signed up to a smart contract that wasn't what they naively thought it was. So it has allowed the DAO gamblers to profit from the buzz over smart contracts, without confronting them with the actual way smart contracts work (namely, through exploits). It has failed to make people see what it *really* means: "unstoppable code" because one stopped it. So these gamblers, that had invested in a VERY BAD IDEA, have been rewarded with not losing their funds as it should have been. And the guy known as the DAO hacker has been ripped off from his true use of the smart contract.
Because a smart contract is just a piece of byte code, and nothing more. Advertising any *intend* of a smart contract is scamming people. Most smart contracts do that: they say that this contract is doing this or that. That's scamming people. The ONLY thing one should tell you about a smart contract, is its byte code - like the ONLY thing that you (or your lawyer) should read is the actual contract you sign, and not any "explanatory but not engaging documentation" that comes with it. The thing you put your signature on, is the final arbiter. With a smart contract, it is the byte code. That is why the DAO hacker wasn't a thief, or a cracker: he just read the byte code, and saw the state that looked very advantageous to him (and to every participant that would have read the byte code, and nothing but the byte code).
And this is why an analysis of the byte code, and nothing but the byte code, is important, to derive the full state tree. And that is why Turing complete byte code language makes this impossible.
Also, centralized blockchains are more at risk of being hard forked, like bitcoin, 3 people can decide that, and it will be done, if they wanted to. Eth is the most decentralized project out there.
I wonder if those 3 people decide to bring out a new core that strips Satoshi of his holdings, by blocking any transaction of the first 50 000 blocks UTXO, whether that would be adopted.
