[parksy]

Turing completeness in layman's terms means you can write programs on it.

Traditionally a computer that most people are familiar with is a single machine, like PC or the device we can hold in our hands. Etherium is a swarm of millions of computers that anyone can add to the swarm.

When people claim Ethereum is turing complete, it means that anyone can launch a program into it, and the "swarm" runs the program. But which node's output is the truth? Without some mechanism in place, a bad actor could claim to have computed an output that serves them greedily.

Ethereum has baked in protocols so that the distributed result of millions of nodes running a program reaches a stasticial consensus.

Being turing complete means that any computable program can run on Ethereum.

So you can imagine writing a program that, say, runs an auction, or performs escrow for contractors, or whatever. You could run doom on it, albeit at an extremely low framerate because you need the swarm to validate each frame.

I hope this explanation helps.

Edit: I swear autocomplete is becoming more forceful over time.

[TeMPOraL]

> When people claim Ethereum is turing complete, it means that anyone can launch a program into it, and the "swarm" runs the program. (...) Ethereum has baked in protocols so that the distributed result of millions of nodes running a program reaches a stasticial consensus.

Usually the reason to run something on more than one computing unit is to achieve additive gains - like getting results faster, or processing more data in the same amount of time. This however sounds like a million computers computing the exact same thing. Why would one want to do that? It's a serious question - I'm having trouble imagining a generic use case.

[dev_throw]

This is to achieve consensus - the N nodes running the smart contract will ideally replace the central authorities that we implicitly trust.

This enables trustless transactions, which gets rid of a lot of business red tape and unlocks productivity.

[SAI_Peregrinus]

Only for a really weird technical definition of "trustless". You have to trust that the smart contract does what's intended, in the way you think it does so. So you need to either trust someone who knows the relevant programming language to audit it, or learn enough to audit it yourself. VS legal contracts, where you have to trust a lawyer to audit the contract but at least have the benefit of laws and bar association ethical rules to constrain the lawyer's behavior. Either way, in practice most people will have to trust someone to safely use any smart contract.

[ZephyrBlu]

The way I understand smart contracts and them being trustless is that they are effectively an escrow.

So yes, each person participating has to do their own due diligence but once the smart contract is live, it is immutable and therefore trustless since it's just code.

[Zambyte]

> This however sounds like a million computers computing the exact same thing. Why would one want to do that?

It is what it sounds like, and it isn't ideal. In order for the Ethereum network to reach an agreement on the result of a computation, multiple nodes need to do the computation to check each other. How do you decide how many nodes need to do the computation for it to be accepted by the network? That's not an easy question to answer. The simplest and safest way is to require 100% of nodes to do the computation. Safely getting that % down from 100 to increase the throughput of the network is a problem actively being worked on.

As for a generic use case, think of Ethereum as something like AWS Lambda that happens to have native support for transacting assets.

[a-nikolaev]

Can you provide an example where a smart contract needs unbounded loops or unbounded recursion? Do you really need Turing completeness to begin with?