Evangelos asks, "From page 20, a Bitcoin user downloads the Bitcoin Core client software."
"What if this downloaded software is infected and serves other interests?"
"Who is responsible for distributing software, if we are talking about the totally decentralized system?"
"How can I understand if it will be the original client software?" That is a great question.
Let's look at how [the Bitcoin Core project] delivers secure software to everyone who wants to use it,
or any other version of the Bitcoin client software.
Then let's look at what happens if it is not the correct software.
First of all, Bitcoin is developed under an open source model, a collaborative development process in public.
[Part of] that development is happening on Github, which is a collaborative software coding platform.
Developers from all around the world contribute changes to the Bitcoin code.
Those [changes] are reviewed by thousands of people.
A group of about 150 developers work on this in a very [dedicated] manner
Some of them work full-time on this software. All of them review and offer their opinion on the code.
There are some developers who, through experience and many years of working on this project,
organise all of the changes into the latest version of the software and produce releases.
A release is simply a specific version which includes changes in the code.
These releases have been reviewed, as we said, by many developers from around the world.
When Bitcoin was developed, a new system for building [and distributing] software was [created] called 'Gitian.'
This was an invention by Bitcoin developers, now used for secure software distribution...
across the world and across other platforms, not just for Bitcoin.
Gitian is a [secure source-control oriented software distribution method], whereby software can be built...
independently on multiple different platforms, and the results of the build mechanism are deterministic.
This is called a deterministic build.
The Gitian system simulates the same platform across different computers that build the software...
independently from the source code.
From a specific version of the source code, it produces a binary that can be executed on different platforms.
For example, the 64-bit version of the x86 processors on Windows or Linux.
Those builds have a fingerprints, and what Gitian does is compare the fingerprints from different systems.
It can tell you if you are getting the same executable result as everybody else.
Then it becomes one of the release builds. These are published on websites, such as bitcoincore.org,
where individual users, developers, and miners can download executables.
Of course, you could also download the source code and use Gitian or another build mechanism...
to build the executable [yourself] and see what is produced.
If you know you have the right source code,
then through building on your own computer, you get a trusted executable.
Once you have the executable, you can [create] a fingerprint of that executable and compare that to...
the published fingerprints available on a number of different sites, to confirm that...
you built the same executable as everybody else.
This ensures that when people download either the executable or the source code,
they have a very dependable [distribution] chain...
back to the developers and the highly reviewed code they collaborated on.
Of course, no process is perfect. What happens if your software has been compromised?
If you have software that is compromised, the biggest risk is to your own individual wallet [or node].
If you download a [modified version of the] Bitcoin Core software that has malware in it,
that will endanger your system.
If you haven't checked the fingerprints, if you haven't used a deterministic build,
or if you didn't download from a reputable source, you may have downloaded infected software.
What is most at risk there is your own funds.
If you put money into a wallet on a system that has a virus or some form of malware,
then it is very likely you will lose your money.
That is what the virus [may] target, but it doesn't pose a threat to the rest of the Bitcoin [network].
On the Bitcoin network, no nodes trusts any other node.
It is assumed that other nodes cannot be trusted when your node is communicating on the network.
It doesn't take any data that is sent to it at face value. It doesn't assume that the data is correct.
Every Bitcoin nodes will independently validate all of the transactions and blocks,
and forms its own authoritative opinion as to whether the nodes it connected to are telling it the truth or not.
If it finds nodes that are consistently lying, sending wrong transaction data or invalid blocks,
it disconnects from those nodes and stops talking to them.
Every node has this defensive mechanism, where it doesn't trust any nodes on the network
and validates transactions and blocks, back to the genesis block, from its own [independent] perspective.
As a result, you don't need to trust that other software is doing what it is supposed to do.
You, or rather your node, validates everything itself.
Yes, we [could] have malicious software introduced into Bitcoin, but it [would be] hard to do...
because of this deterministic build process, where you can evaluate a chain of custody that [starts from]...
source code that is widely [available and] reviewed [by the developers], all the way to the executable.
Even if you don't validate, the risk that poses is primarily to your own funds, in your own machine.
No other node on the network will trust you. By default, we don't trust other systems the.
The trustless and decentralized nature of Bitcoin is [based on not trusting] any other nodes on the network.
"How is consensus on new rules and upgrades reached? Who decides what updates to include or reject?"
"Are developers being paid to do that?"
Consensus on new rules and upgrades is reached in stages, and at different parts of the system.
Ultimately, the people who decide which upgrades [will be] implemented are [those] running nodes,
specifically [within] the five constituencies of consensus, or groups of people [participating in] consensus.
These five groups have overlap between them, but broadly speaking they are:
the miners, who choose what software to mine with;
the merchants who choose what software to accept payments with, selling commercial goods and services;
exchanges, who [choose what software to] use for [accepting] deposits and withdrawals of cryptocurrency;
the developers, who write the software but can't force anybody to run that software;
and [those who create or] run wallets, including users, who decide what rules those wallets work with,
Consensus is an emergent phenomena from the agreement of all parties operating under a set of rules.
Those who deviate from the rules are punished through a loss of [reward or network connection].
They lose opportunity. They lose profit.
Bitcoin developers are [being] paid by many companies that are willing to subsidize, fund, or hire [them]...
to work not only on their own projects, but also to work on the core protocol.
There are probably more than four hundred contributors to the Bitcoin Core project.
They are paid by a number of different companies and others are just volunteers.
Also, keep in mind that many of these developers can get a job pretty much anywhere they want,
and be paid very well for that job.
They work wherever they want to work, on the projects they want to work on.
They are very independent; they can't be forced to implement changes that they are not interested in.
In fact, even the companies that pay them [must] let them work on whatever they want.
Otherwise, they would stop working there.
If you ask many of these developers, "Why do you work for this company," they will tell you:
"I work for this company because the smartest people in the world that I know work for this company too."
One of the best rewards for a developer, any creative or artistic person, is to work among the best in their field...
on a daily basis.
They don't do it for money.
"How can a node running one [implementation of the Bitcoin software, such as] Bitcoin Core,
communicate with nodes running [another implementation of the client] software?"
"How does a miner decide which software to use? Is it common for a miner to switch [implementations]?"
That is a great question.
There is a difference between the software, the protocol, and the consensus rules, but all three matter.
You can have one piece of software, [such as] Bitcoin Core, that is a certain implementation,
but uses the common protocol to communicate on the network and follows the common consensus rules.
Bitcoin Core, as the reference client, tends to lead in the interpretation of the protocol and consensus rules.
But nobody [needs to] run Bitcoin Core. You can run a different [implementation].
For example, there is an implementation in NodeJS...
called "bcore," which is fully compatible at the protocol level and in the consensus rules.
There is another implementation called "libbitcoin," [also] fully compatible in the protocol and consensus rules.
By speaking a common language and following the same rules,
these three different clients can communicate on the same network,
arrive at [the same result] as to what has happened, and remain within consensus by following the rules.
A miner can run any one of those [implementations].
[Their choice] depends on their preference for scalability, code quality, maintainability, and security.
"Is it common for a miner to switch to another [implementation]?" Not really.
The reason for that is, Bitcoin Core has demonstrated a high level of quality with very well-tested software,
not only by the developers but of course by everybody else who is running it [for nodes].
[They have] very high standards for code maintenance and security updates.
A miner [can switch] to another [implementation], if they believe that the other implementation will be...
better maintained, deliver better quality and more secure code than the Bitcoin Core project.
So far, that doesn't seem to be happening. Most miners, I think all miners, use Bitcoin Core,
because it has proven to be the most reliable software out there.
You