【翻译】How To Become A Blockchain Developer: Crash Course! 区块链开发指南！

In this guide, we are going to map out your journey for becoming a Blockchain Developer. To ease things up for you, we are going to divide this guide into various milestones and give you action steps at the end of every section.

在本指南中，咱们将一步步筹划你的区块链开发之旅。为了易于你接受，咱们将分步骤设置若干学习里程碑，而且在每一章节最后告诉你具体作什么。

It goes without saying that we are living in the “era of the blockchain”. The impact that it can have on our future is truly scary and magnanimous. So, how can you get a piece of that “blockchain action”? If you are to become a blockchain developer, then there are certain steps that you need to take.

毫无疑问咱们正处在“区块链时代”。它对咱们将来的冲击真的会很惊人，但也充满机遇。因此，你如何能在其中分到一杯羹？若是你打算成为一名区块链开发者，那本文列出的步骤应该正是你须要的。

Hopefully, at the end of the guide, you will have the tools required to kick-start your journey. If you are serious about becoming a developer then we need to set some expectations for you. Firstly, it is going to take time and you will need to dedicate your time and resources to your education. Secondly, do not expect immediate results, becoming a blockchain developer is not a magic pill.

但愿您在读完本文后，能组建一套装备来助你展开区块链的旅程。若是你认真的想成为一名开发者，这里先给你打个预防针：第一，学习区块链很花时间，你须要投入你的时间和资源来学习。第二，别期望速成，成为区块链开发人员不是一朝一夕的事。

So, having said that, let’s start your journey.

那，说了这么多，让咱们开始吧。

How To Become A Blockchain Developer: Crash Course!

区块链开发指南！

Milestone #1: Understanding The Basics

里程碑 1：基础知识

One of the biggest hurdles with anything as new and revolutionary, such as the blockchain technology, is familiarizing oneself with various concepts integral to the system.

要理解像区块链——这种新的革命性事物——的最大障碍，就是熟悉该系统的各类概念。

If you are a beginner, then there are certain terms that you need to be familiar with:

若是你是初学者，那么如下概念须要你熟知：

• Blockchain: The blockchain is a chain of blocks where each block contains data of value without any central supervision. It is cryptographically secure and immutable.

• 区块链： 区块链是一系列区块组成的链表。每个区块包含着数据，这些数据并不是被某个中央系统监管。数据是加密的而且不可改变。

• Decentralized: Blockchain is said to be decentralized because there is no central authority supervising anything.

• 分散： 区块链是分散的，是由于并无一个中央权威作任何监督。

• Consensus Mechanism: The mechanism by which a decentralized network comes to a consensus on certain matters.

• 协商机制： 该机制是说这个分散的网络能协商讨论一些事情，并最终达成共识。

• Miners: Users who use their computational power to mine for blocks.

• 矿工： 消耗计算能力来发掘区块的人。

It could be advisable to learn more about these terms that are widely used in the crypto-sphere. It is highly recommended that you go through our comprehensive glossary. It is important to learn these basic terms otherwise you will be very lost further on in your education. Now, up next, it is time to educate yourself some more on the technical aspects of the blockchain.

更明智的作法是从密码领域中深刻学习以上术语。强烈建议你过一遍咱们的综合术语表。学习这些基本术语十分重要，否则你会在将来的学习中不知所措（译者注：连老师讲的什么都听不懂）。好，接下来该学习更多关于区块链技术方面的知识了。

If you are interested in the technical aspects of how to create a fin-tech application on top of the Blockchain then you should definitely learn the ins and outs of cryptoeconomics. Most developers are usually well-versed in the “crypto” part of the equation but their knowledge of the “economics” part is extremely lacking.

若是对基于区块链作一些金融科技应用感兴趣，那你必定要学透密码经济学。大部分开发者通晓上文的“密码”，不过对于另外一半“经济学”的知识则十分缺少。

This difference in knowledge is extremely apparent when you study some of these ICOs floating around. It is very obvious to see that the economics side of their ICO’s are not well thought out.

这种知识上的差别形成的影响，在你研究诸如首次币发行这类概念时会很明显。君不见不少数字货币的首次币发行，在经济学方面都没有通过深思熟虑。

So, in light of that, it can be a good idea to read up a bit on economics and have a general idea of it.If you want to learn about cryptoeconomics in general, then you may checkout our article here.

因此，学点经济学，对经济学有个总的概念是个好主意。若是你想简要学习密码经济学，能够看这篇文章。

If you are intrigued by the cryptography specifically and want to know how signatures work and what public key cryptography means, then read this.

若是你对密码学十分感兴趣，并且想了解签名的原理、公钥加密技术的含义，那么读这篇文章。

After that, it is highly recommended that you understand how bitcoin works. Bitcoin is the most widespread, finest and one of the more elegant applications of the blockchain technology. You can even call it the finest example of what the blockchain technology can achieve purely because of the impact that it has had.

以后，十分建议你了解一下比特币是如何运行的。比特币是最好、最普遍、最优雅的区块链应用之一。你甚至能够称之为区块链技术能实现的最好的样例，由于它真的是太有影响力了。

So, it is advisable that you read Satoshi Nakamoto’s whitepaper of bitcoin. You can find it over here. Now that completes the first milestone.

因此，最好去阅读中本聪的比特币白皮书吧。能够在这里读。而后第一个里程碑就结束了。

Let’s check out the action steps that you need to take over here:

做业

• Get acquainted with the various terms and lexicons.
• 熟悉各类术语和词汇
• Read up on the more technical aspects of the blockchain.
• 阅读大量区块链技术方面的文章
• Read the bitcoin whitepaper.
• 阅读比特币白皮书

Milestone #2: Learn How The Process Works

里程碑 2：学习运行机理

It is pretty surprising to see how many budding “developers” have not had any real world first-hand experience with cryptocurrency at all. How can you possibly innovate and improve upon a platform when you have not used it even once?

使人吃惊的是，大量的新手“开发人员”历来没真正的亲身使用过加密货币。若是你连一次都没用过，何谈对其进行创新与改进呢？

It Is strongly recommended that you start getting acquainted with the system today.

强烈建议你今天就开始熟悉这套系统。

Go to Coinbase or any other exchange that you are comfortable with or is accessible in your country and buy some coins. You don’t need to create an extensive portfolio straightaway, just buy a few coins and see how the whole process works.

去 Coinbase 或其余任何你习惯的、能访问的交易网站，买点币。你不须要构建普遍的投资组合，就买几个币感觉下整个流程。

It is extremely straightforward. Since you are not going to be buying a lot of coins then simply use a basic online wallet.

按最简单的来。既然你也不是要买一堆币，那就用的基本的在线钱包就行。

These wallets are the easiest to use among all. The creation is super simple because it’s basically creating your own account on any of the exchange services. Furthermore, you can access this wallet from any server or any device in the world as long as it is connected to the net. Having said that, there is one big problem when it comes to online wallets. Your private key is going to be saved on another server. This is basically like serving up your key to hackers on a silver platter. Do NOT use online wallets to store huge amounts of your money. Store the bare minimum that you need for exchange purposes.

区块链货币钱包是最容易使用的。建立钱包十分简单，由于基本上都是将你的账号创建在交易服务网站上。此外，只要链接上了网络，你就能够从任何服务器或任何设备来访问你的钱包。话虽如此，在线钱包却有一个大问题。你的私钥是被储存在另外一台服务器的，这基本上就是将你的密钥拱手相送给黑客了。不要 使用在线钱包储存大额财产，只储存你须要兑换的最小值便可。

As you create an extensive portfolio, you must learn how to utilize cold wallets to store your money. You can learn how to do so here. Later on, if you create your ICO then you MUST know how wallets and, in particular, multi-sig wallets work.

当你有了一个普遍的投资组合后，你必须学习如何利用冷钱包来储存你的财产。你能够在这里学习如何作。以后，若是你打算作首次币发行，那你必需要懂钱包，特别是多重签名钱包的工做机制。

We are bringing this section to a close here, the tough part starts from the next milestone.

本节就介绍到这里，下个里程碑开始要提升难度了。

You action steps are here:

做业：

• Learn how the exchanges work.
• 学习交易所如何工做的。
• Get acquainted with wallets.
• 熟悉使用钱包。

Milestone #3: Let’s get coding!

里程碑 3：开始编码！

As a blockchain developer, you will face tons of challenges in the back-end. Creating and maintaining a public blockchain is not easy because of a number of reasons.

做为一名区块链开发者，你会在后台开发遇到不少挑战。有各类各样的缘由，使得建立和维护一个公共的区块链系统并不容易。

(Before we continue, a huge shoutout to David Schwartz for his keynote address regarding C++ use in blockchain software development in CPPCON 2016.)

（在咱们继续以前，来看看 2016 年的 CPPCON 中，David Schwartz 在他的关于用 C++ 开发区块链的主题演讲上是怎么说的。）

YouTube视频

• Reason #1: Security
• 缘由 1：安全

Blockchains, as David Schwartz puts it, should be fortresses. Firstly, the code is public and open for all to see. Anyone can look at the code and check for bugs and vulnerabilities. However, unlike other open code resources, the downside of finding vulnerabilities on blockchain code is massive. Any programmer can hack in and get away with potentially millions and millions of dollars. Because of these legitimate security concerns, development on blockchain is usually very slow.

正如 David Schwartz 所说，区块链应当是一座堡垒。首先，代码公开谁都能看。任何人均可以查看代码检查 Bug 和漏洞。然而这并不像其余的开源代码，因找到区块链系统的漏洞，而形成的不利影响每每很严重。任何程序员均可以侵入该系统、掠走数百万美圆而后溜之大吉。正由于这些安全上的考量，使得区块链开发每每很缓慢。

---

• Reason #2: Resource Management
• 缘由 2：资源管理

It is important to keep pace with the network. You cannot fall too far behind and not keep up with all the network demands. You should be well equipped to handle remote and local queries.

跟上网络的发展步伐是很重要的。你不能落后太远，以致于跟不上网络的需求发展。你应当具有处理远程和本地查询的能力。

---

• Reason #3: Performance
• 缘由 3：性能

The blockchain must always perform at its highest possible capabilities, but for that to happen the language chosen must be extremely versatile. The thing is that there are certain tasks in the blockchain which are parallelizable whilst there are some tasks which can’t be done in parallel.

区块链总应当以其最高性能指标来运行，不过为了达到这个目标，用来开发的编程语言必须是很全能的。由于有些区块链的任务要求并行执行，而还有一些任务必须按顺序执行。

A good example of “parallelizable” task is digital signature verification. All that you need for signature verification is the key, transaction and the signature. With just three data you can conduct verifications in a parallelized manner.

关于“并行”任务，数字签名验证就是个好例子。验证一个签名，你须要：密钥、交易还有签名。只要三种数据你就能以并行的方式执行验证操做。

However, not all the functions on a blockchain should be done that way. Think of transaction execution itself. Multiple transactions can’t be executed in parallel; it needs to be done one at a time to avoid errors like double spends. Some languages are good at parallel operations while some are good in non-parallel operations.

然而，并不是全部区块链的功能都应当并行执行。考虑交易执行自己。复数的交易行为不能够被并行执行；他们须要保证在同一时间只能执行一个交易，这样才能避免相似双重扣款这样的错误。有些语言擅长并行操做，另外一些语言擅长非并行操做。

---

• Reason #4: Isolation
• 缘由 4： 隔离状态

What is deterministic behavior?

什么是可肯定的行为？

If A + B = C, then no matter what the circumstances, A+B will always be equal to C. That is called deterministic behavior.

若是 A+B=C，那么不论在任何情形下，A+B 都老是等于 C。这就是可肯定的行为。

Hash functions are deterministic, meaning A’s hash will always be H(A).

哈希函数也是一种可肯定性的行为，这意味着值 A 的哈希结果老是等于 H(A)。

So, in blockchain development, all transaction operations must be deterministic. You cannot have a transaction that behaves one way and then behaves another way the next day. Similarly, you cannot have smart contracts that work in two different ways on two different machines.

因此，在区块链开发中，全部的交易行为都必须是可肯定的。你不能说一个交易今天执行是一个套路，明天执行又是另外一个套路。一样的，一个智能合约不能在两个不一样的机器上有着不一样的运行效果。

The only solution to this is isolation. Basically, you isolate your smart contracts and transactions from non-deterministic elements.

惟一的解决方案就是隔离状态。最起码，你要把智能合约和交易逻辑与其余非肯定的元素隔离开。

There are some languages which fulfill most of these needs. If you are a blockchain developer, then you definitely need to have some basic knowledge of C++ and JavaScript.

有一些编程语言知足了以上大部分需求。若是你是一个区块链开发者，那么你绝对须要对 C++ 和 JavaScript 有基本的知识 。

While C++ may seem a little outdated, the truth is that it wonderfully satisfies all the functionalities that we have described above. In fact, Satoshi Nakamoto wrote the Bitcoin source code in C++.

可能 C++ 看上去有点过期，实际上它很是符合以上咱们描述的功能。中本聪其实就是用 C++ 编写的比特币源代码。

Along with HTML and CSS it is one of the three core technologies in World Wide Web Content Production. Javascript is usually used to create highly interactive web pages.

JavaScript，HTML 和 CSS 同样，是开发万维网产品的三项核心科技。JavaScript 一般用于建立高互动性的 Web 页面。

So, now we will see how to create a very simple blockchain using Javascript.

因此，接下来咱们将看到如何用 JavaScript 来建立一个很是简单的区块链。

Huge shoutout to savjee.be for the content below.

如下内容转载自 savjee.be

How do we make a block? What does a simple block consist of? In our simple cryptocoin that we are going to make (Let’s call it “BlockGeeksCoin”), each block will have the following pieces of information:

如何建立一个区块？一个简单的区块由什么组成？咱们将要开发一种简单的加密货币（就叫“BlockGeeksCoin"吧），其每个区块将包含下列信息：

• Index: To know the block number.
• 索引： 本区块的编号。
• Timestamp: To know the time of creation.
• 时间戳： 本区块的建立时间。
• Data: The data inside the block.
• 数据： 咱们要在区块中储存的数据。
• Previous Hash: The hash of the previous block.
• 前序哈希值： 前序区块的哈希值。
• Hash: The Hash of the current block.
• 哈希值： 本区块的哈希值。

Before we continue. You need to understand certain terms that we are going to use in our program:

在咱们继续以前，你须要理解一些接下来 JavaScript 程序中用到的术语：

• This: The “this” keyword is invoked inside a function and enables you to access the values inside a specific object that calls that particular function.

• This: 你调用了一个对象的一个函数，在该函数中可使用“this"关键字，而后能够经过该关键字访问该对象的各类属性和其余函数。

• Constructor: A constructor is a special function which can help create and initialize an object within a class. Each class is restricted to only one constructor.

• Constructor: constructor （构造函数）是一个特殊的函数，能帮咱们建立且初始化一个类的对象。每个类都要求只能有一个该函数。

Now that that’s done, let’s start making our block.

说完了，开始制做咱们本身的区块吧！

Creating the Block

创造区块

const SHA256 = require("crypto-js/sha256"); 

class Block 
{ 
    constructor(index, timestamp, data, previousHash = '') 
	{ 
		this.index = index; 
		this.previousHash = previousHash; 
		this.timestamp = timestamp; 
		this.data = data; 
		this.hash = this.calculateHash(); 
	} 

	calculateHash() 
	{ 
		return SHA256(this.index + this.previousHash + this.timestamp + JSON.stringify(this.data)).toString(); 
	} 
}

Code Analysis

代码分析

Ok, so this right here is out a block. So, in the first line of the code, we called the crypto-js library because the sha256 hash function is not available in JavaScript.

好，这就是一个区块了。那么代码第一行，咱们引入了 crypto-js 库，由于 JavaScript 并无内置 sha256 哈希函数。

Next, we invoked a constructor inside the class to call for objects which will have certain values. The thing that probably catches your eye is the calculateHash() function. Let’s see what exactly is it doing.

接下来，该类的构造函数里为不少属性进行了赋值。你确定注意到下面的 calculateHash() 函数了，我们来看看它具体干什么的。

In a block, we take all the contents and hash them to get the hash of that particular block. We are using the JSON.stringify function to turn the data of the block into a string to hash it.

在一个区块里，咱们将全部内容汇聚在一块儿，而后对其取哈希值，这就是该区块的哈希值。咱们使用 JSON.stringify 函数来将区块的全部数据转换成字符串，而后取哈希值。

Ok, so we have the block ready and good to go. Now let’s connect the blocks together into a blockchain.

好的，咱们第一个区块已经准备好了。接下来咱们将多个区块连成一条区块链。

Creating the blockchain: Becoming A Blockchain Developer

建立区块链：成为一名区块链开发者！

class Blockchain
{
    //Section 1 Genesis block creation
    // 第一： 生成创世区块
	 constructor() 
	{ 
		this.chain = [this.createGenesisBlock()]; 
	} 
	createGenesisBlock() 
	{
		return new Block(0, "01/01/2017", "Genesis block", "0"); 
	} 

    //section 2 adding new blocks
    //第二：添加新的区块
	getLatestBlock() 
	{ 
		return this.chain[this.chain.length - 1]; 
	} 
	addBlock(newBlock) { 
		newBlock.previousHash = this.getLatestBlock().hash; 
		newBlock.hash = newBlock.calculateHash(); 
		this.chain.push(newBlock); 
	} 

    //section 3 validating the chain
    //第三：验证链条
	isChainValid() 
	{ 
		for (let i = 1; i < this.chain.length; i++)
		{ 
			const currentBlock = this.chain[i]; 
			const previousBlock = this.chain[i - 1]; 
			if (currentBlock.hash !== currentBlock.calculateHash()) { 
				return false; 
			} 
			if (currentBlock.previousHash !== previousBlock.hash) 
			{ 
				return false; 
			} 
		} 
		return true; 
	} 
}

Code Analysis

代码分析

Ok, so a lot of things are going on in the chain above, let’s break it down into sections.

好，上面的链条定义了好些东西，我们来一点一点分析。

---

• Section 1: The Genesis Block
• 第一：创世区块

What is the genesis block?

什么是创世区块？

The genesis block is the first block of the blockchain, and the reason why it is special is that while every bock points to the block previous to it, the genesis block doesn’t point at anything. So, the moment a new chain is created, the genesis block is invoked immediately.

创世区块是一个区块链系统的第一个区块，它的特殊之处在于它不指向任何前序区块。除此以外任何其余的区块都要指向一个特定的前序区块的。因此，当一个新的链条产生时，创世区块也会当即产生。

Also, you can see a “createGenesisBlock()” function wherein we have given the data of the block manually:

另外你看函数“createGenesisBlock()”，咱们给它手动赋值了。

createGenesisBlock() 
{
    return new Block(0, "01/01/2017", "Genesis block", "0"); 
}

---

• Section 2: Adding The Blocks
• 第二：添加区块

Firstly, we will need to know what the last block in the blockchain currently is. For that we use the getLatestBlock() function.

首先，咱们须要知道这个链条目前最后一个区块是什么。因此咱们定义了 getLatestBlock() 函数。

getLatestBlock() 
{ 
    return this.chain[this.chain.length - 1]; 
}

Now that we have determined the latest block, let’s see how we are going to add new blocks.

如今咱们能定位到最后一个区块了，来看看如何添加新区块。

addBlock(newBlock) 
{
    newBlock.previousHash = this.getLatestBlock().hash; 
    newBlock.hash = newBlock.calculateHash(); 
    this.chain.push(newBlock); 
}

So, what is happening here? How are we adding the blocks? How are we checking if the given block is valid or not?

这里都发生了什么？咱们怎么添加区块的？咱们怎么知道添加的区块是否合法？

Remember the contents of a block? A block has the hash of the previous block right?

还记得区块的内容么？一个区块不是有前序区块的哈希值么？

So, what we are going to do here is simple. Compare the previous hash value of the new block with the hash value of the latest block.

因此这里作的其实很简单。比较新区块的前序哈希值和链条最后一个区块的哈希值便可。 （译者注：其实这里的 addBlock 函数并无作验证，它只是自动将新区块的前序哈希设置为链条最后一个区块的哈希值。能够理解为使用该函数添加的区块，都将自动转换为合法的区块。）

Image Courtesy: Lauri Hartikka medium article

图片来源：Lauri Hartikka medium article

If these two values match, then this means that the new block is legit and it gets added to the blockchain.

若是这两个哈希值匹配，那这意味着新区块是合法的，能够被添加到区块链中。

---

• Section 3: Validating the Chain
• 第三： 链条验证

Now, we need to check that nobody has been messing with our blockchain and that everything is stable.

如今咱们须要检查没有人搞乱咱们的区块链系统，保证一切稳定。

We are using the “for” loop to go from the block 1 to the last block. Genesis block is block 0.

咱们使用“for”语句，从第一个区块遍历到最后一个区块。创世区块是第零个。

isChainValid() 
{ 
	for (let i = 1; i < this.chain.length; i++)
	{ 
		const currentBlock = this.chain[i]; 
		const previousBlock = this.chain[i - 1]; 
        //In this part of the code we are defining two terms, current block and previous block.  And now we are simply going to find the hash of these two values.
        //这部分代码定义了两个术语：当前区块和前序区块。接下来只要比较这两个区块的哈希值。
		if (currentBlock.hash !== currentBlock.calculateHash()) { 
			return false; 
		} 
		if (currentBlock.previousHash !== previousBlock.hash) 
		{ 
			return false; 
		} 
	} 
	return true; 
}

If the “previousHash” of the current block is not equal to the “Hash” of the previous block, then this function will return False, else it will return True.

若是当前区块的“前序哈希值”不等于前序区块的“哈希值”，那么函数将返回 false，不然会返回 true

Using the blockchain

使用区块链

Now, we are going to finally use the blockchain to create our BlockGeeksCoin.

如今咱们终于要使用区块链来生产咱们的 BlockGeeksCoin 了。

let BlockGeeksCoin = new Blockchain(); 
BlockGeeksCoin.addBlock(new Block(1, "20/07/2017", { amount: 4 })); 
BlockGeeksCoin.addBlock(new Block(2, "20/07/2017", { amount: 8 }));

And that’s it!

这就好了！

So what happened here?

到底发生了什么？

We created a new cryptocurrency based on the blockchain and named it BlockGeeksCoin. By invoking this new object, I activated the constructor, which in turn created the Genesis block automatically.

咱们建立了一个新的基于区块链的加密货币，称之为 BlockGeeksCoin。经过建立这个新对象，我激活了链条的构造函数，而后自动建立了创世区块。

We simply added two more blocks to it and gave them some data.

而后咱们添加了两个新的区块，赋给了它们一些数据。

It is that simple.

就这么简单。

(Thank you savjee.be for the amazing and simple explanation.)

感谢 savjee.be 提供了如此出色且简明的解释

That’s it for this milestone. Let’s look at the action steps. It is very simple but it definitely isn’t easy:

以上就是这个里程碑的内容了。下面布置做业，很少但也要花些功夫的：

• Get educated in one of the many blockchain friendly languages like C++, Javascript, C#, Go etc.
• 学习一种适合开发区块链的语言，好比 C++, JavaScript, C#, Go 等等。

Milestone #4: Get Educated On Smart Contracts

里程碑 4： 学习智能合约

How do you define a smart contract?

你如何定义一个智能合约？

According to Wikipedia, a smart contract is “a computer protocol intended to facilitate, verify, or enforce the negotiation or performance of a contract”. While it was first proposed by American cryptographer Nick Szabo in 1996, Ethereum is often credited with popularizing the concept and making it mainstream.

根据维基百科的说法，智能合约是“旨在促进、核实或增强合同谈判或履行的计算机协议"。虽然本概念是由美国密码学家 Nick Szabo 于 1996 年第一次提出，但一般认为是 以太坊 以太坊 将此概念推广并成为主流。

You can learn more about smart contracts in our in-depth guide here.

你能够看咱们的深刻指南来学习智能合约更多的知识。

So, what are the desirable properties that we want in our smart contract?

因此咱们但愿一个智能合约具备哪些性质呢？

Anything that runs on a blockchain needs to be immutable and must have the ability to run through multiple nodes without compromising on its integrity. As a result of which, smart contract functionality needs to be three things:

任何运行在一个区块链系统上的东西，都必须是不可变的，数据流过任何节点也不能对数据的完整性有半点妥协。所以，智能合约要有如下三点性质：

• Deterministic.
• 肯定性
• Terminable.
• 可终止
• Isolated.
• 隔离性

---

Feature #1: Deterministic

性质 1：肯定性

A program is deterministic if it gives the same output to a given input every single time. Eg. If 3+1 = 4 then 3+1 will ALWAYS be 4 (assuming the same base). So when a program gives the same output to the same set of inputs in different computers, the program is called deterministic.

一个具备肯定性的程序，只要你给他一样的输入，每次都会输出一样的结果。例如：若是 3+1 = 4 那么 3+1 将总为 4（假设进制不变）。因此若是给予一个程序一样的输入，不论什么时候该程序都会输出一样的结果，那么咱们称该程序具备肯定性。

There are various moments when a program can act in an un-deterministic manner:

不少时候，程序会表现出不肯定性：

• Calling un-deterministic system functions: When a programmer calls an un-deterministic function in their program.
• 调用不肯定系统的函数： 当程序员调用另外一个不肯定性函数的时候。（译者注：例如某些多线程、并发函数）
• Un-deterministic data resources: If a program acquires data during runtime and that data source is un-deterministic then the program becomes un-deterministic. Eg. Suppose a program that acquires the top 10 google searches of a particular query. The list may keep changing.
• 不肯定的数据资源： 若是一个程序在运行时获取一个不肯定的数据资源时，那么这个程序就变成不肯定性程序了。例如：想象一个程序要获取 Google 搜索的前十条数据，这数据确定是不肯定的。
• Dynamic Calls: When a program calls the second program it is called dynamic calling. Since the call target is determined only during execution, it is un-deterministic in nature.
• 动态调用： 当一个程序调用第二个程序时，称之为动态调用。由于被调用对象是在运行时才肯定的，因此实质上是不肯定的。

---

Feature #2: Terminable

性质 2：可终止

In mathematical logic, we have an error called “halting problem”. Basically, it states that there is an inability to know whether or not a given program can execute its function in a time limit. In 1936, Alan Turing deduced, using Cantor’s Diagonal Problem, that there is no way to know whether a given program can finish in a time limit or not.

在数学逻辑中有一种称之为“中止问题”的错误。简单说，该问题指出没法知道给定的程序可否在时限内执行其功能。在 1936 年， 阿兰图灵从康托对角线问题推出，没有办法知道给定的程序可否在时限内完成任务。

This is obviously a problem with smart contracts because, contracts by definition, must be capable of termination within a given time limit. There are some measures taken to ensure that there is a way to externally “kill” the contract and to not enter into an endless loop which will drain resources:

对于智能合约来讲，这毫无疑问是个问题，由于根据定义，合约必须能在有限的时间内终止。有一些方法能够保证能从外部“杀掉”合约，使其免于进入无限循环，耗尽资源：

• Turing Incompleteness: A Turing Incomplete blockchain will have limited functionality and not be capable of making jumps and/or loops. Hence they can’t enter an endless loop.
• 图灵不完备性质： 一个图灵不完备的区块链，只提供有限的功能，不能跳跃或循环。所以这种区块链不会进入无限循环。
• Step and Fee Meter: A program can simply keep track of the number “steps” it has taken, i.e. the number of instructions it has executed, and then terminate once a particular step count has been executed.Another method is the Fee meter. Here the contracts are executed with a pre-paid fee. Every instruction execution requires a particular amount of fee. If the fee spent exceeds the pre-paid fee then the contract is terminated.
• 计步和计费： 一个程序能够记录它消耗的“步数”。好比它执行的指令数，达到特定的步数后就终止。另外一个方法叫计费。该合约使用预付费来执行，每条指令都要消耗特定的费用。若是预付费用完了那么合约结束。
• Timer: Here a pre-determined timer is kept. If the contract execution exceeds the time-limit then it is externally aborted.
• 计时器： 有一个预先设置的计时器，若是合约执行超过了时限，则自动从外部终止。

---

Feature #3: Isolated

性质 3：隔离性

In a blockchain, anyone and everyone can upload a smart contract. However, because of this the contracts may, knowingly and unknowingly contain virus and bugs. If the contract is not isolated, this may hamper the whole system. Hence, it is critical for a contract to be kept isolated in a sandbox to save the entire ecosystem from any negative effects.

在一个区块链中，任何人均可以上传一个智能合约。然而因为这一点，合约可能有意无心的包含着病毒和 Bug。若是一个合约没有隔离性，那可能会影响到整个系统。所以将合约隔离在单独的沙箱中来保护整个生态远离任何负面效应是相当重要的。

Now that we have seen these features, it is important to know how they are executed. Usually the smart contracts are run using one of the two systems:

好咱们看到这些性质了，了解它们如何运行是很重要的。一般智能合约是运行在下面两个系统之一上的：

• Virtual Machines: Ethereum uses this.
• Virtual Machines: 以太坊 使用这个。
• Docker: Fabric uses this.
• Docker: Fabric 使用这个。

Let’s compare these two and determine which makes for a better ecosystem. For simplicity’s sake, we are going to compare Ethereum (Virtual Machine) to Fabric (Docker).

让咱们比较一下这两个，看看哪个能创造一个更好的生态系统。为了简单起见，咱们将比较 以太坊（Virtual Machines）和 Fabric （Docker）。

If you are interested in Ethereum development specifically then it is important that you learn solidity as well.

若是你对 以太坊 开发感兴趣，那么对 solidity 的学习也很重要。

For anyone who wants learn how to make DAPPs (Decentralized Applications) or get into the ICO game, learning Solidity is an absolute must. We already have a detailed guide to it which you can read here. However, here we are going to give you a basic overview. Solidity was developed by Gavin Wood, Christian Reitwiessner, Alex Beregszaszi, Yoichi Hirai and several former Ethereum core contributors to enable writing smart contracts on blockchain platforms such as Ethereum.

对于想要学习如何使用 DAPPs（分散应用程序）或者想参与首次币发行的人，必定要好好研究 Solidity 。咱们已经有详细的指南，能够来这里读。这里咱们给你一个基本的概述。Solidity 是由 Gavin Wood, Christian Reitwiessner, Alex Beregszaszi, Yoichi Hirai 和几位前 以太坊 核心贡献者开发的，用于在相似 以太坊 这样的区块链平台上编写智能合约。

Solidity is a purposefully slimmed down, loosely-typed language with a syntax very similar to ECMAScript (Javascript). There are some key points to remember from the Ethereum Design Rationale document, namely that we are working on a stack-and-memory model with a 32-byte instruction word size, the EVM (Ethereum Virtual Machine) gives us access to the program “stack” which is like a register space where we can also stick memory addresses to make the Program Counter loop/jump (for sequential program control), an expandable temporary “memory” and a more permanent “storage” which is actually written into the permanent blockchain, and most importantly, the EVM requires total determinism within the smart contracts.

Solidity 是一种刻意简化的、弱类型语言，语法很相似 ECMAScript (JavaScript)。还记得一些 以太坊 设计原理文档上的关键点，说咱们工做在一个32字节的指令长度的堆栈内存模型上，EVM（以太坊 Virtual Machine）给咱们提供访问程序的“堆栈”的能力，就像是寄存器空间同样，咱们能够将内存地址贴进去使得程序计数器能够循环、跳转（程序顺序控制）。有一个可扩展的临时“内存”还有更大的永久“储存”也就是实际向区块连永久写入。最重要的是，EVM 要求总决定权在智能合约内。

If you are interested in learning solidity then you can check our in-depth course here.

若是你对学习 Solidity 感兴趣，那能够看这篇深刻教程。

So, let’s see the action steps now:

下面留做业：

• Understand how smart contracts work.
• 搞明白智能合约怎么工做的。
• (Optional for Ethereum developers) Learn Solidity.
• (若是你是 以太坊 开发者) 学习 Solidity。

Milestone #5: Be In The Mix

里程碑 5：融入

One of the most important things that you can do as a budding developer is to constantly stay in the mix.

做为一个新人，最重要的是融入整个区块链开发的世界。

Go and join the Reddit forums, GitHub pages, and StackExchange and connect with other developers and always be on the lookout for any news regarding the technology.

去加入 Reddit 论坛、GitHub 页面，StackExchange 等等地方，多接触其余开发者。始终对新技术保持敏感。

Along with that, it will be helpful for you to know what people look for in blockchain developer. What qualities are companies looking for when they are looking to hire? You can find that information here.

同时，去了解哪些人须要区块链开发人员，哪些特色是公司招聘所关注的。这些都对你会有用处。你能够在这里找到更多相关信息。

This information can be very useful in you fine-tuning your skills enough to appeal to the companies.

这些信息在你完善你的技能来知足公司需求时很是有用。

Conclusion

结论

So, this is a rough roadmap for you and your journey to becoming a blockchain developer. This alone won’t be enough, of course, you will need to show your own initiative and always be in the mix.

那么这就是成为一个区块链开发人员的一个粗略路线图。仅仅读完这篇文章固然是不够的，你须要发挥你的主观能动性，时刻参与其中。

If you are looking for a resource of information on blockchain development then click here.

若是你在找关于区块链开发的资源能够点这里。

We wish you all the best on your journey!

祝您一帆风顺！