BlockChain

Contents

Blockchain Coding

Blockchain Coding: The Many different Languages You Need! The blockchain technology is incredibly fascinating. It won’t be far-fetched to think of a future which will be built entirely on it. So, what do you need to learn in order to start developing on the blockchain? Which languages will give you the edge? In this guide, we will go through some of the more major ones.

Problems with developing blockchain software

Before we begin, let’s checkout some of the challenges that a blockchain developer faces. Creating and maintaining a public blockchain is not easy because of a number of reasons.

Reason #1: Security

Blockchains, as David Schwartz puts it, should be fortresses. Firstly, the code is public and open for all to see. Anyone can look over 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.

Reason #2: Resource Management

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

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

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.
  • Hash functions are deterministic, meaning A’s hash will always be 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 in two different machines.

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

Wallet Guide: How to Protect Your BlockChain

A cryptocurrency wallet is a digital wallet that you can use to store, send and receive various cryptocurrencies. The wallet doesn’t exactly “store” your money as a real-world wallet does. Instead, it saves your public and private keys which in turn helps you send and receive money(or blockchain data).

more about Wallet Guide: How to Protect Your BlockChain..

Blockchain Development Languages

we have discussed the main problems that blockchain developers face. Now let’s finally check out some of the languages that the developers can use to code on the blockchain.

Language #1: C++

First and foremost, let’s start with the granddaddy of them all, the evergreen C++. C++ was created by Bjarne Stroustrup as an extension of the C language. The Language was designed to have the flexibility and efficiency of the C but with some major differences. The biggest difference between C and C++ is that while C is process-oriented, C++ is object oriented.

What this means is that, in C++, the data and functions are wrapped into one neat little package called “objects” which means that once an object is created, it can easily be called and reused in other programs, which greatly reduces coding time.

Let’s look at the simplest C++ program in the world. The “Hello World” program:

#include <iostream.h>
main()
{
cout << "Hello World!";
return 0;
}

This code will print: Hello World!

So, why do people still use C++ for coding? Surely there are way more glamorous languages now, why do people still insist on going back to C++? Why is the bitcoin blockchain coded on C++?

Well, as it happens, C++ has certain features that makes it very appealing. (Shout out Peter Wiulle and David Schwartz for the following explanation).

Feature #1: Memory Control

Not only should blockchains be secured fortresses but they should have effective resource management as well. A blockchain is supposed to interact with a lot of untrusted endpoints while still giving quick service to any and all nodes.

This quick and prompt service is critical for the success of a cryptocurrency like bitcoin. Remember, they are all based on the principle of “consensus”, all nodes on the network must accept and reject the exact same blocks, or else there could be a fork in the chain.

In order to satisfy all these demands and perform at the highest level, you need tight and complete control over CPU and memory usage. C++ gives that to its users.

Feature #2: Threading

As we have discussed before, one of the main challenges of the blockchain programming is the integration of tasks that parallelize well and the tasks that don’t parallelize. Most languages specialize in one, however C++’s threading ability is good enough to handle both parallel and non-parallel tasks. A thread is a set of instructions that can be executed simultaneously. Not only does C++ allow fir superb multithreading facilities with effective inter-thread communication, it also optimizes single-thread performance.

Feature #3: Move Semantics

One of the most interesting aspects of C++ is move semantics. Move semantics provides a way for the contents to be moved between objects rather than be copied outright. Let’s checkout the differences between copy semantics and move semantics. (Following data taken from Peter Alexander’s answer in “Stackoverflow”).

Copy Semantics:

assert(b == c);
a = b;
assert(a == b && b == c);

So what is happening here? The value of b goes into a and b remains unchanged at the end of the whole thing.

Now, consider this.

Move Semantics:

assert( b = = c);
move (a,b);
assert (a = =c );

What is happening here?

Can you see the difference between the two blocks of codes?

When we are using the move semantics, the value of “b” need not be the unchanged. That is the difference between copy semantics and move semantics. The biggest advantage of move semantics is that you can get copies of certain data only when you need them, which greatly decreases redundancy in the code and gives a huge performance boost. So as you can see, this efficient memory management and high performance are both desirable for the blockchain.

Feature #4: Compile Time Polymorphism

What is polymorphism?

Remember when we called C++ an “object oriented programming (OOP) language”? Polymorphism happens to be an OOP property. Using polymorphism, you use a particular feature in more than one ways. In C++ polymorphism can be used in two ways:

  • Compile time polymorphism.
  • Run time polymorphism.

Over here, we will only be focusing on compile time polymorphism. There are two ways that C++ implements compile time polymorphism:

  • Function Overloading.
  • Operator Overloading.


Function Overloading:

Function overloading is when you have many functions of the same name but with different parameter intake.

Consider this program:

#include <bits/stdc++.h>
using namespace std;

class A
{
void func (int x)  //first instance of the function takes only one integer value
{
cout<<x<<endl;
}

void func (double x) //second instance of the function takes only one double value
{
cout<<x<<endl;
}

void func (int x, int y) //third instance of the function takes two integer values
{
cout<<x=y<<endl;
}

}

int main()

{
A obj1 //making one object of the class A
//now we are going to call the functions
obj1.func(2);
obj1.func(2.65);
obj1.func(2,5);
return 0;
}

Now when you run this function the output will be:

  • 2
  • 2.65
  • 7

So, as you can see, the same function func() was used in 3 different ways.

Operator Overloading:

In C++ the same operator can have more than one meaning.

  • Eg. “+” can be used both for mathematical addition and for concatenation.
  • Concatenation basically means taking two strings and combining them as one.
  • So 3+4 = 7.

AND

  • Block+geeks = Blockgeeks.
  • The same operator, did two different functions, this is operator overloading.

The Compile time polymorphism helps a lot in blockchain development. It helps in putting responsibilities separately in various functions and, in turn, boosting the performance of the whole system.

Feature #5: Code Isolation

C++ has namespace features which can be imported from one program to another. Namespace helps in avoiding name collisions. Also, since C++ has classes, it can act as boundaries between various APIs and help in making clear separation.

A class in C++ is a user defined type or data structure declared with keyword class that has data and functions as its members. You can access the functions declared in the class by declaring objects of that particular class.

Feature #6: Maturity

The language is both mature and regularly updated. There are at least 3 solid compilers, as David Schwartz says, and the new features are aimed at solving real issues. Debuggers and analytical tools of all kinds are available for everything from performance profiling to automatic detection of issues of all kinds. This means the language is constantly growing to incorporate newer and better features.

Because of the above features, Satoshi Nakamoto chose C++ to be the base language of the bitcoin source code.






Language #2: Javascript

Up next we have Javascript.

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 webpages. So, now we will see how to create a very simple blockchain using Javascript. Huge shoutout to savjee.be for the content in this section.

Suppose, we want to create a simple blockchain in Javascript. Before we do so, there are certain things that we need to address.


What is a blockchain and how exactly does it work…code-wise?

A blockchain is basically a chain of blocks which contain data. It is basically a glorified linked list. However, what makes it so special? A blockchain is immutable. Meaning, once a data goes inside a block, it can never be changed. How does a blockchain attain immutability? It is because of a simple but ingenious mechanism called “hashing”. Checkout the diagram below:

image1.png

Image Courtesy: Lauri Hartikka medium article

Each block is connected to the previous block via a hash pointer which contains the hash of the previous block. So, how does this make the chain immutable?

One of the most fascinating properties of cryptographic hash functions is that if you even change the input by a little bit, it can greatly affect the output hash. Eg. Check this out:

coding.png

Just changing the first “T” from upper to lower case drastically changed the output hash so much.

So, how does this affect the blockchain?

Each block is connected to the previous one via the hash pointer. So, if someone were to tamper the data in a block, it would change the hash drastically and as a result, end up affecting the whole chain (as all the blocks are linked). This would freeze up the chain which is an impossibility and hence the blocks remain unchanged.

So, 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:


  • 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:

  • 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.


  • 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.

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 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.

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.

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 string to hash it.

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


Creating the blockchain

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 to 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 because 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()
{
return new Block(0, 01/01/2017, Genesis block, 0);
}

Now that we have built the genesis block, let’s build the rest of the chain.

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() 
{ 
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 previousHash value of the new block with the hash value of the latest block.

image3.png

Image Courtesy: 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 (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.

Using the blockchain

Now, we are going to finally use the blockchain to create our 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.

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.)

Language #3: Python

Guido van Rossum, a Dutch programmer, created Python back in 1991. Python is based on a simple philosophy: Simplicity and Minimalism. One of the more notable ways that they incorporated simplicity into their language is by using white spaces to signify code blocks instead of curly brackets or keywords. Let’s see what this means.


Let’s checkout a simple “hello world” program.

print(Hello, world!’)

Yup, that’s it!

Compare that to the C++ “hello world” program.

See how less complicated it is in comparison? How about we do something a little more complicated? Let’s say we are adding two numbers and printing the result.

num1 = 1.5

num2 = 6.3

sum = float(num1) + float(num2)

print(The sum of {0} and {1} is {2}.format(num1, num2, sum))

And that’s it.

The output of this program will be:

The sum of 1.5 and 6.3 is 7.8 So, let’s up the ante. How are we going to program an entire blockchain using Python? The following data and code is taken from Gerald Nash’s article in Medium.

Creating the block

Firstly, let’s make our block:

import hashlib as hasher

class Block:
  def __init__(self, index, timestamp, data, previous_hash):
    self.index = index
    self.timestamp = timestamp
    self.data = data
    self.previous_hash = previous_hash
    self.hash = self.hash_block()
  
  def hash_block(self):
    sha = hasher.sha256()
    sha.update(str(self.index) + 
               str(self.timestamp) + 
               str(self.data) + 
               str(self.previous_hash))
    return sha.hexdigest()

Code Analysis

We are starting off by importing the hash library to use the SHA 256 hash finctions (quite like Javascript).

Just like before, the block has the same value:

  • Index.
  • Timestamp.
  • Data.
  • Previous hash.
  • Hash.

Once against, we are filling up the hash values via a function, same as before.

Creating the genesis block

Now, let’s create the Genesis block: import datetime as date

def create_genesis_block():

return Block(0, date.datetime.now(), Genesis Block, 0)

Code Analysis

We have imported datetime to put in the timestamp.

We simply generated the genesis block and manually given it some data to work with. The previous hash value is “0” because it is pointing to no other block.

Creating the rest of the blocks

Now let’s define how the subsequent blocks will be created.

def next_block(last_block):
  this_index = last_block.index + 1
  this_timestamp = date.datetime.now()
  this_data = "Hey! I'm block " + str(this_index)
  this_hash = last_block.hash
  return Block(this_index, this_timestamp, this_data, this_hash)

Code Analysis

So, how are we going to be determining the values of each and every piece of data inside each and every block?

The block index is simple the index of the last block + 1.

The timestamp is the current date and time.

The data of the block is a simple message: “Hey! I’m block <index number>”.

Hash we are calculating using the function we definted earlier.

And ultimately, we are returning all these values to the block.

Creating the blockchain

Finally, let’s create the blockchain.

blockchain = [create_genesis_block()]
previous_block = blockchain[0]

num_of_blocks_to_add = 15

for i in range(0, num_of_blocks_to_add):
  block_to_add = next_block(previous_block)
  blockchain.append(block_to_add)
  previous_block = block_to_add
  # Tell everyone about it!
  print "Block #{} has been added to the blockchain!".format(block_to_add.index)
  print "Hash: {}n".format(block_to_add.hash)

Code Analysis

Firstly, we create the genesis block and give its value to “previous_block”.

Then we determine how many blocks to add, in this example we are going with 15.

So we are running a loop that goes till 15 and adds each and every block to the blockchain. At the end of the look we are printing which number block has been added to the blockchain via showing their index number. Plus, we are printing the Hash as well.

This is what the output will look like:

image2.png

Image Courtesy: Gerald Nash Medium Article

Obviously in both this and the javascript you could add more complicated features like Proof Of Work. If you want to learn how to implement that then it is highly recommended to go through Gerald Nash’s article. But for now, you at least know how to create a simple blockchain in Python.

Language #4: Solidity

Finally, we come to 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 on 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.

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 within 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.

So, before we continue, let’s checkout a basic Solidity contract example. (Codes taken from github).

Let’s run a simple while loop in solidity:

contract BasicIterator 
{ 
address creator; // reserve one "address"-type spot 
uint8[10] integers; // reserve a chunk of storage for 10 8-bit unsigned integers in an array 
function BasicIterator() 
{ 
creator = msg.sender;
uint8 x = 0; 

//Section 1: Assigning values
while(x < integers.length) { 
integers[x] = x;  
x++; 
} } 

function getSum() constant returns (uint) { 
uint8 sum = 0; 
uint8 x = 0; 

//Section 2: Adding the integers in an array.
while(x < integers.length) { 
sum = sum + integers[x];
 x++; 
} 
return sum; 
} 

// Section 3: Killing the contract
function kill() 
{ 
if (msg.sender == creator) 
{ 
suicide(creator); 

}
}
}


So, let’s analyse.

Section 1: Assigning Values

In the first step we are filling up an array called “integers” which takes in 10 8-bit unsigned integers. The way we are doing it is via a while loop. Let’s look at what is happening inside the while loop.

while(x < integers.length) {
integers[x] = x;
x++;
}


Remember, we have already assigned a value of “0” to the integer x. The while loop goes from 0 to integers.length. Integers.length is a function which returns the max capacity of the array. So, if we decided that an array will have 10 integers, arrayname.length will return a value of 10. In the loop above, the value of x goes from 0 – 9 (<10) and assigns the value of itself to the integers array as well. So, at the end of the loop, integers will have the following value:

0,1,2,3,4,5,6,7,8,9.

Section 2: Adding the array content

Inside the getSum() function we are going to add up the contents of the array itself. The way are going to do it is by repeating the same while loop as above and using the variable “sum” to add the contents of the array.

Section 3: Killing the contract

This function kills the contract and sends the remaining funds in the contract back to the contract creator.

When asked about what was the inspiration and motivation behind creating solidity, Dr. Gavin Woods said this:

“It [Solidity] was meant to be a sophisticated tool for developing contracts that could ultimately give both developers and users good information on what the code did. To help this along, I devised NatSpec, a contract-friendly documentation format, and made that a first-class citizen in Solidity. I also proposed a formal proofing language subset (not yet implemented) in order to maximise the kinds of correctness guarantees that could be made.

I introduced events as a first class citizen into the Solidity language in order to provide a nice abstraction for LOGs similar in form to function calls. Inspiration for that came from the Qt meta-object system’s “signals”.

One later feature that Christian R. and I figured out together was function modifiers; that allows attributes placed as part of a function signature to make some modifications to the apparent function body. Being a very declarative means of expression, it’s an idiom that falls nicely into the contract-oriented programming space.”

it’s an idiom that falls nicely into the contract-oriented programming space.

Blockchain Coding: Conclusion

In this article we have only covered 4 languages for blockchain coding that are used in developing in and around the blockchain. In reality there are many many more languages that you can potentially use (Java, Go). If you are a programmer, then the possibilities for you are truly endless. As the world becomes more and more decentralized and blockchain becomes more and more mainstream, the future for you is definitely limitless.


The top enterprise blockchain platforms

Basis of selecting the Blockchain platforms

Choosing a Enterprise Blockchain framework is even more tricky, since you will have to be careful about a variety of factors before, during and after implementation.

From our experience these are some of the factors that you should look out for when choosing your Enterprise Blockchain framework:

  • License; what is the framework licensed under? Is it completely free to use? or does it comes with a package attached to it?
  • Community; is the community large enough around the framework? How vibrant is the community?
  • Support model; is the framework receiving any support from a large corporation? this will help predict the longevity of a framework.
  • Activity; how often is the framework receiving patches and feature updates?
  • Roadmap; is the framework having a roadmap that you can predict in the future?
  • Ease of use; the last thing you want to do is to get stuck in a complex mesh of new technology that is yet to see large-scale adoption.
  • Pricing – Free, Paid Pricing tier information
  • GitHub repo – Names of the GitHub repo for the SDKs
  • Popularity – How popular is the platform based on its GitHub stats (stars, forks etc.)

Frameworks

Ethereum

In 2014 Ethereum founders Vitalik Buterin, Gavin Wood and Jeffrey Wilcke began work on a next-generation blockchain and had the ambition to implement a general, fully trust less smart contract platform.

Ethereum is an open blockchain platform that lets anyone build and use decentralized applications that run on blockchain technology. Like Bitcoin no one controls or owns Ethereum. It is an open-source project build by many people around the world. Ethereum is adaptable and flexible unlike the Bitcoin protocol.​

Key Takeaways

* Popularity & Activity : High, Actively followed in GitHub
* Type of network : Public, Smart Contract based
* Pricing : Ether for transaction and computational services
* Supported Languages : Python, Go , C++
* GitHub Repo : 
** pyethereum (Python)
** gpethereum (GoLang)
** cpp-ethereum (C++)


Hyperledger(Sawtooth Lake)

The Hyperledger is an open source collaborative effort created to advance cross-industry Blockchain technologies. It is a global collaboration including industry leaders in fields of finance, banking, Internet of Things, supply chains, manufacturing and technology.

Hyperledger has many project under it, as submitted by the member companies. Check out their projects page for more details. ​Sawtooth Lake is one of the major project under Hyperledger that is submitted by Intel and supports a modular Blockchain suite.


Key Takeaways

* Popularity : High and actively updated in GitHub
* Type of network : Both Private and Public
* Pricing : Open Source
* Supported Languages : Python (For Sawtooth Lake)
* GitHub Repo : sawtooth-core (Python)

Multichain

Multichain is a platform for the creation and deployment of private Blockchains (permissioned Blockchains) either within or between organizations. It aims to overcome a key obstacle to the deployment of blockchain technology in the institutional financial sector. By providing privacy and control within a private peer-to-peer network it is an enhanced version of the Bitcoin core software for private financial transactions.

Key Takeaways

* Popularity : Medium but actively updated in GitHub
* Type of network : Private, Permissioned
* Pricing : Free, Open Source
* Supported Languages : Python,  C#, JavaScript , PHP, Ruby
* GitHub Repo : 
**             savior (Python)
**             c# MultichainLib (C#)
**             Multichain-Node (JavaScript)
**             libphp-multichain (PHP)
**             multichain-client (Ruby)

HydraChain

HydraChain is a joint development effort of brainbot technologies and the Ethereum project. According to their website, HydraChain is an extension of the Ethereum platform which supports the creation of scalable blockchain based applications that comply with organizational and regulatory requirements.

Key Takeaways

* Popularity : Low but actively updated in GitHub
* Type of network : Private / Permissioned
* Pricing : Open Source
* Supported Languages : 
**                      Python
**                      GitHub Repo
**                      hydrachain (Python)


Open Chain

Openchain is developed by Coinprism, the company behind the colored coins standard Open Assets.

Openchain claims to be well suited for organizations wishing to issue and manage digital assets​. It takes a different approach than the standard Bitcoin approach on implementing Blockchain. Thereby, it follows a partitioned consensus system in which every Openchain instance only has one authority for validating transactions, depending on the assets being exchanged. This, in turn, leads to a client-server (centralized) architecture which they claim to be more efficient and reliable than a peer-to-peer architecture.

Key Takeaways

* Popularity : Medium but actively updated in GitHub
* Type of network : Private
* Pricing : Open Source
* Supported Languages : 
**                      Javascript
**                      GitHub Repo
**                      openchain-js (Javascript)

IBM Bluemix Blockchain

IBM has also released its Blockchain platform which is available as part of the Bluemix service catalog. It is also built on top of the HyperLedger project and offers additional security and infrastructure facilities for enterprises.

Key Takeaways

* Popularity : Medium but actively updated in GitHub
* Type of network : Private/ Permissioned
* Pricing : Limited free plan with paid upgrade to enterprise plan 
* Supported Languages : Go, Javascript
* GitHub Repo : 
**             learn-chaincode (Go)
**             ibm-blockchain-js (Javascript)


Chain

Chain is yet another Blockchain platform that claims to be well suited for financial applications

It is based on "Chain Core" which is an enterprise software product that implements the Chain Protocol. An open-source developer edition is also available freely.

Key Takeaways

* Popularity : Medium but actively updated in GitHub
* Type of network : Permissioned
* Pricing : Enterprise Licensing
* Supported Languages : Java, Ruby, Node.JS
* GitHub Repo : 
**              sdk-Java (Java)
**              sdk-Ruby (Ruby)
**              sdk-Nodejs (Node.JS/Javascript)


IOTA

IOTA is the new kid in the block. It is yet another implementation of Blockchain, currently in beta. It deviates from the standard Blockchain. It is based on a concept of blockless distributed ledger called Tangle. It promises to be a key enabler for machine economy and supports infinitesimally small nanopayments without any fees.


Key Takeaways

* Popularity : Low but actively updated in GitHub
* Type of network : Public, Permissioned
* Pricing : Based on IOTA Token, Pricing not clear as yet
* Supported Languages : Python , C, Javascript
* GitHub Repo : 
**              iota.lib.py (Java)
**              ccurl (C)
**              iota.lib.js (Javascript)

Enterprise%20Blockchain%20Platforms.jpg

Best Blockchain Certification, Training & Course

A global team of 50+ Blockchain experts have compiled this list of Best Blockchain Certification, Training, Course, Classes & Tutorial available online for 2018. These resources will help you Learn Blockchain from scratch, and are suitable for beginners, intermediate learners as well as experts.


Blockchain Certification from State University of New York (Coursera)

Divided into 4 courses, this specialization covers Basics, Smart Contracts, Decentralized Applications(Dapps) and Platforms. Taught by Bina Ramamurthy, the course has been designed by State University of New York (SUNY) and University of Buffalo which have cumulative decades of teaching experience and millions of alumni members across the globe. Learning in this programs goes from understanding how to design, deploy and execute a smart contract to developing decentralized applications and develop a broad understanding of the entire ecosystem. The comprehensive program spans 16 weeks with you having to invest around 3-4 hours each week.

Key USPs

  • Very detailed program covering all aspects of the subject
  • If you are looking to learn different aspects at one place, this might be the best bet
  • Comes with the backing of State University of New York and University of Buffalo, and is available on leading e-learning platform Coursera
  • Includes projects to help you practice and apply the skills you learn
  • Knowledge of any high level programming language is enough to get started with this program
  • You can opt for a free 7 day trial of this course before deciding to pay for it

Duration : 16 weeks / 4 hours per week Rating : 4.6 out of 5

click here to see more details from State University of New York

IBM Blockchain Certification for Developers (Coursera)

This highly reputed certification program available on Coursera comes with experienced IBM blockchain developers teaching you concepts and strategies on building blockchain business networks. An ideal choice for software developers who are new to blockchain, this course is taught by Ant Cole and Dave Gorman from IBM. The fact that this training just requires 6 weeks of study with only 2 hours to be dedicated every week makes it an ideal weekend course for those with a full time commitment elsewhere. More than 40,000 professionals globally have already enrolled in this program.

Key USPs

  • Learn about fabric development & architecture
  • Get to know how to transform your business
  • You will earn a Certificate on successful completion of the course.
  • Deep dive into Hyperledger Composer, understand the underlying structures, and use it for a real project
  • Learn in a community environment with thousands of other learners so you can discuss, debate and master concepts better
  • High course rating and good reviews


Duration : 6 weeks of study, 2 hours per week Rating : 4.4 out of 5

click here to see more details from IBM

Blockchain Technology Certification from UC Berkeley (edX)

This special program is created by faculty from UC Berkeley’s premier Computer Science department and will provide you with the ideal foundation required to comprehend Bitcoin and blockchain technology. Available on edX, this course is taught by Rustie Lin and Mengyi (Gloria) Wang, University of California, Berkeley. Among other things, this course will cover distributed systems and alternative consensus mechanisms, fundamental applications of bitcoin technology as well as implementation (including JP Morgan’s Quorum, Ripple, Tendermint, and HyperLedger).


Key USPs

  • Comes from the prestigious UC Berkeley college
  • Covers all fundamentals of the subject
  • Is good for both beginners as well as those at intermediate level
  • Studying is very easy on the edX platform
  • It is up to date with current market trends

Duration : 6 weeks, 3 to 5 hours per week Rating : 4.6 out of 5

click here to see more details from Berkeley

Blockchain Certification for Business – Hyperledger Technologies (edX)

This certification by The Linux Foundation available on edX will you learn how to start building blockchain applications with Hyperledger frameworks. You will learn how information is generated, stored, and shared, and also understand how to evaluate whether a solution is suitable for your business or not. Taught by experts in the domain including Navroop Sahdev, FinTech and Entrepreneur and Nathalie Salami Attorney.


Key USPs

  • This course is suitable for both nontechnical and technical audiences
  • You will learn to identify suitable blockchain uses for your business requirements
  • You will be guided through implementation
  • An eight week course, with a commitment of 3-4 hours per week making it ideal for weekend study as well

Duration : 8 weeks, 3 to 4 hours per week Rating : 4.6 out of 5


click here to see more detail about Hyperledger Technologies

Blockchain Training : Ethereum & Solidity : Developer’s Guide (Udemy)

Stephen Grider is a champion online instructor having taught more than 200,000 students on udemy alone! With a background of working for top corporations in the bay area, he now focuses his energy on training young (and old) minds to get better at all aspects of web development. He is one of the highest rated trainers and all his courses are extremely valuable and knowledgeable. In this program he will teach you how to use Ethereum, Solidity and Smart Contracts to build applications based on the blockchain. We have no doubt in calling this the best Blockchain course.


Key USPs

  • Comprehensive course spanning 24 hours including 10 articles, all with lifetime access
  • Trainer help you work on real projects with Ethereum
  • Learn to design, test and implement secure Smart Contracts
  • Learn to use the latest version of Ethereum development tools
  • Learn in depth the capability and scope of Solidity
  • This program is hosted on Udemy and is available at special pricing for our readers.

Duration : 24 hours Rating : 4.7 out of 5

click here to see Udemy course

Blockchain and Bitcoin Fundamentals (Udemy)

This is one of the best course on the subject, created by George Levy and it will help you demystify the key elements of the technology while making you understand how it works. This is one quick program that will take under 3 hours to get over.


Key USPs

  • High rating of 4.7 out of 5
  • Learn all about the fundamentals
  • Role of how Bitcoin miners, How Block Hashes work
  • Learn all about DAOs and DACs
  • A crisp course that has already been taken up by more than 30,000 students worldwide
  • Sending and Receiving Bitcoins

Duration : 2.5 hours Rating : 4.7 out of 5

click here to see Udemy course

Blockchain Developer Tutorial with Ethereum and Solidity (Udemy)

First lets talk about the trainers. Sebastien Arbogast, is a fullstack software developer, consultant, speaker and an entrepreneur. Along with Said Eloudrhiri, he has been working towards getting more developers involved in blockchain and developing better tools for its development. Said has been working in IT for 25+ years and a is a proficient developer, software architect, team leader as well as agile coach. With 2 CVs like that you know you are in very safe hands in this course. Together, this duo will help you develop your first decentralized application from scratch on the Ethereum.


Key USPs –

  • Learn how to develop a distributed application, how to unit test them and create a user interface for them
  • Learn how to use the Truffle build and testing framework
  • The tutorial goes from the very basics to advanced levels
  • Learn about the fundamental of the solidity smart contract language
  • Get lifetime access to 15 hours of online content + 3 articles and 49 supplemental resources

Duration : 15 hours Rating : 4.6 out of 5

click here to see Udemy course

Free Blockchain Course for Beginners (LinkedIn Learning)

Learn all about the implication of decentralized, encrypted data storage along with understanding the concepts of mining, cryptography, distribution and smart contracts. This free course is available on LinkedIn Learning (previously Lynda.com) and is created by Dr. Jonathan Reichental, an expert in the domain. Ideal for beginners, people with some knowledge of the technology can sign up too.


Key USPs

  • Thousands have already attended this class and have given positive feedback
  • Crisp course to help you learn Blockchain beyond the basics in a short time
  • Includes part about generating and trading cryptocurrency as well
  • Course is practically free since first month on LinkedIn Learning is free
  • The trainer is renowned in this domain and is an international speaker as well

Duration : 1 hour 30 minutes Rating : 4.5 out of 5


click here to see LindkedIn course

Blockchain Developer Training : Ethereum Blockchain Developer: Solidity

Created by Ravinder Deol and Thomas Wiesner, two renowned experts in this domain, this training is all about building projects using Solidity programming. Before you enroll for this course, you should have a basic understanding of either Web Development, JavaScript, Ajax-Requests, AngularJS or other related platforms. Doesn’t mean you need to be an expert in the same. Basic knowledge will be good to go.


Key USPs

  • Types of blockchain and potential uses of the same
  • What are Smart Contracts
  • Using MetaMask plugin
  • Real time action using Solidity
  • Learn all about Decentralisation as you work with the technology
  • Learn how to use Web3 with different projects

Duration : 6.5 hours Rating : 4.2 out of 5

click here to see Udemy course

Ethereum Developer Masterclass

Thomas and Ravinder are back with a development project training. This 10 hour course helps you become adept at the programming languages used to create projects. Most importantly, you will get to create real time projects with the trainers through this program. You should be familiar with Git, HTML, JavaScript and Bootstrap incase you decide to sign up.


Key USPs

  • Develop using Latest Solidity, Web3js, Truffle, TestRPC and MetaMask
  • Basic development knowledge will also do, don’t need to be an expert in the domain
  • Thomas and Ravinder have been involved with Blockchain since 2012 and come with multi disciplinary experience with them

Duration : 10 hours Rating : 4.4 out of 5

click here to see Udemy course

The Basics of Blockchain

This is only for those wanting to get an overview and introduction. A quick 1.5 hour video training takes you through the fundamentals you need to understand this technology.


Key USPs

  • You will be able to pen down a piece regarding use cases and industry potential
  • Help your business or your clients get ready for the emerging decentralized economy
  • Created by 5 experts on the subject – Tom Serres, Bettina Warburg, John Fitch, Collin Cusce, Tate Ryan-Mosley
  • 6,000 + people have already attended the training

Rating : 4.2 out of 5

click here to see Udemy course

Bitcoin and Cryptocurrency Technologies – Princeton University

Princeton University brings you this Bitcoin & Cryptocurrency Certification Course taught by Arvind Narayanan, Assistant Professor at the University. Spread across 11 weeks, this is ideal for those who want to take it a little slow and understand all about crypto in detail from an academic point of view.


Key USPs

  • Learn how Bitcoin achieves decentralization
  • Learn How to Store, Use and Mine Bitcoins
  • Get a Certification from Princeton
  • Instructor discusses in detail about the future of Bitcoin , Altcoin and Cryptocurrencies in general


Rating : 4.7 out of 5

click here to see Princeton University course

Blockchain Developer Training - Getting Started with Ethereum Solidity Development

Sebastien Arbogast is a full stack software developer, consultant and trainer with over 12 years of experience. He teams up with Said Eloudrhiri who’s been working in IT for the last 25 years! With a CV like that, you know you are in the safest of hands. They both have decided to share their knowledge on this subject to help you learn and grow in the field of blockchain and ethereum development using Solidity.


Key USPs

– Learn to develop a distributed application – Understand how to write smart contracts and creating a user interface for them – Learn how to use Metamask – You will also learn Truffle building and testing framework – Deploying a decentralized app to various Ethereum instances (testrpc, private chain, test chain, main net) – Participant Mohit Shah feels “The course was complete and really good with all the explanations. I had know experience or idea about solidity but this course helped me to really get started with Ethereum DAPP development.”


Rating : 4.6 out of 5

click here to see Udemy course


Resources

https://blockgeeks.com/guides/what-is-blockchain-technology/

https://www.computerworld.com/article/3258848/blockchain/the-blockchain-market-is-hot-heres-how-to-learn-the-skills-for-it.html

https://medium.com/hyperlegendary/6-blockchain-frameworks-to-build-enterprise-blockchain-how-to-choose-them-2b7d50ba275c

https://radiostud.io/eight-blockchain-platforms-comparison/

https://www.horsesforsources.com/top-5-blockchain-platforms_031618

https://dzone.com/articles/best-3-enterprise-blockchain-platforms-for-rapid-p