In a previous post we looked at the blockchain. I explained the blockchain data structure from the perspective of git. Today I’d like to take a look at iota’s brand new protocol called tangle and explore what makes it different from a blockchain, and why in my opinion it’s such a simple, yet novel idea.

Tangle

When we originally discussed the blockchain I pointed out that it’s essentially a linked list with some very special properties. It seems like the next logical extension we all should’ve been asking ourselves, yet weren’t until now, is why a linked list? What other data structures could we apply this same technique to? This is what the tangle protocol has done.

Rather than storing the transactions on a linked-list, the transactions are stored on a DAG (directed acyclic graph). Often the most simple ideas are the most brilliant. This was the case with the blockchain, and now is the case with it’s extension, the tangle protocol.

(a simple example of a DAG)

So what? why does it matter?

No fees, lower transaction times

Because the transactions are in a DAG, it further decentralizes the transactions. Each node holds one transaction, because of this, they’re now small enough for other users of the protocol to perform validation, and proof of work without needing an ASIC. As we saw in the blockchain post, the users had to rely on the miners to do the proof of work because a large portion of transactions were stored in a block, and there was only 1 branch. Now the work can be parallelized and decentralized. Because this consensus can happen on multiple branches at the same time, this makes transaction time much lower compared to standard blockchain technologies.

Looking at the above picture, it’s as if the blocks have been broken apart and their transactions scattered about in the ever forward moving continuous DAG, and they’re all happening in real time. With the blockchain we viewed time in a block scale, imagine each block being a day, things could only happen at the end or beginning of a day. With tangle, we’re able to inspect transactions on an hour, or even minute scale.

Decentralization

I think it’s hard for anyone in the cryptocurrency community to find anything wrong with the tangle protocol. It’s increasing decentralization in a big way, and that’s something every one can agree on, particularly after the recent bitcoin hard fork, which was due in large part to the centralization of mining power. With tangle we’re giving the hash power back to the users of the protocol.

I’ve also heard during this interview with one of the founders of iota, that the protocol was recently attacked with 300% hash power, and actually got faster and more robust from the attack. This is very important, because as a technologist, my instinct was initially to say “well, it isn’t being mined by special hardware, can it really be that cryptographically secure?” This protocol is still very new, and there is still a lot that needs to be hashed out. For example, one thing I’ve heard asked is: “what is the efficiency of transaction look up?”* since transactions are now in a DAG this certainly raises the complexity associated with finding your transaction in the graph. It is called a tangle after all, and I don’t know about you, but the word tangle doesn’t necessarily bring about ideas of order to mind. However, I’m very excited about this paradigm shift away from the blockchain from a purely scientific standpoint.

After having further discussions with the tech community, I’ve elected to write another post directed at the details of some of the following criticisms of iota. See you then!

NOTE: here are a few videos I found that were pretty good while doing research into this new topic. [1, 2, 3]

*Since writing this post, here’s another criticism I’ve found from Mr. Eric Hop:

“The only drawback with iota is that it’s not safe to send multiple transactions to the same address.”

My response to this was: “This seems like it would be easy for them to remedy, no?”

Here is Eric’s response after an impressive deep dive into the internals of the protocol:

“

So I was wrong in that it is unsafe to send multiple transactions to the same address. It only starts to become unsafe once you have spent some of the IOTA on that address.

Spending from the same address multiple times increases the risk that your address will be compromised, but your seed is still secure.

Addresses are generated by the wallet starting at index zero. It increments the index every time it finds an address already in the tangle. When it finds the first unused address that is the address returned.

That is why it is a good idea to connect a receiving address to the tangle already. So that the wallet will not generate the same address again while nothing has been received on that address.

Why the wallet does not simply keep track of the last index used is beyond me. It then could simply start at the next index when a new receive address is required. If I ever find out the reason for this I will follow up.

I also see no particular good reason other than accidentally being able to receive on an address that was spent from already for not being able to generate addresses offline like with Bitcoin wallets.

The seed should be a unique starting point, from which you could generate addresses one after another, incrementing the index every time.

The only security issue that could arise is when you would use the same seed again on a different offline wallet that would then proceed to generate the same string of addresses, or on an online wallet, that would potentially generate the next address in the sequence, in which case the offline wallet does not know about this fact and will happily generate the same next address…”

This made me sceptical of the Winternitz encryption (it seemed to be the cause of the majority of issues). Eric explained the Winternitz was chosen due to it’s quantum proof qualities.