DEV Community: Nikolay Angelov

Workshop - Create Decentralized Application

Nikolay Angelov — Sun, 30 Sep 2018 08:33:06 +0000

Introduction

Hello everybody. My name is Nikolay Angelov (http://nikolaytech.com) and I have put together this Workshop in which we will be creating a very simple but powerful Decentralized Application using a few tools.

The general idea for the App will be to store Certificates (Images) in a decentralized way using IPFS and saving the hash of the image inside an Ethereum Smart-Contract. That way we are certain that no one has altered the Certificate and that it hasn’t been changed.

To create our app we will need to install a few tools and I will explain how in this document.

Tool List:

Ganache (https://truffleframework.com/ganache)
InterPlanetary File System - IPFS (https://ipfs.io/)
MetaMask (https://metamask.io/)
JavaScript + js

Installing Ganache

Ganache is a fast and customizable blockchain emulator. It allows you to make calls to the blockchain without the overheads of running an actual Ethereum node.

Transactions are "mined" instantly.
No transaction cost.
Accounts can be recycled, reset and instantiated with a fixed amount of Ether (no need for faucets or mining).
Gas price and mining speed can be modified.
A convenient GUI gives you an overview of your test chain events.

Now it’s time to install Ganache.

Open https://github.com/trufflesuite/ganache/releases/tag/v1.2.2 and select the appropriate version based on the operation system you are using.
For Windows Download the .exe

Now depending on your Windows settings, Windows Defender SmartScreen can warn you that this installation is not safe. Just ignore it and follow the steps to install Ganache:

After clicking on “More Info”, a new screen will appear showing you the installation button.

Then you just need to click next and follow the normal installation instructions and Ganache should be running on your computer.

Now you can allow or forbid Ganache to analyze your data. Make a choice and click continue.

Congratulations! You successfully installed Ganache!

Run your Ganache and you should get a screen with all of your accounts, their coins and some other information.

Let’s leave Ganache for now and install the rest of the things we need.

Using Infura Provider for IPFS

IPFS is a peer-to-peer distributed file system that seeks to connect all computing devices with the same system of files. In some ways, IPFS is similar to the World Wide Web, but IPFS could be seen as a single BitTorrent swarm, exchanging objects within one Git repository. In other words, IPFS provides a high-throughput, content-addressed block storage model, with content-addressed hyperlinks. (Source: Wikipedia)

Installing IPFS might be a hard process for beginners, so I have decided to use the API provided by https://infura.io Note: If you are interested in installing this yourself just talk to me and I will help you.

Installing MetaMask Plugin

MetaMask is a bridge that allows you to visit the distributed web of tomorrow in your browser today. It allows you to run Ethereum dApps right in your browser without running a full Ethereum node.

MetaMask includes a secure identity vault, providing a user interface to manage your identities on different sites and sign blockchain transactions.

Open https://metamask.io/ and get the Plugin for your browser.
Now MetaMask should appear in your browser Extensions. (Upper right Corner)

You might get a screen that tells you to try the new version.

Please go with the old version and select “No thanks, maybe later” as the new version is pain right now.

Now you need to click “Accept to the next few screens until you are prompted to create a password. This is because MetaMask is actually a wallet that has to be secured
Now you have a Wallet, On the next screen will appear your 12 keywords called Mnemonics. You need to store those in a secure place since they will later allow you to access your wallet in case of a breach or stolen/forgotten password. In our case, we don’t really care as we are going to run our own network.
Now we just need to connect MetaMask to our early started Ganache.

It’s an easy task - go on the top left corner of MetaMask and you will see “Main Network” and an Arrow. Click the Arrow.

On the drop-down select “Localhost 8545” which is our Ganache local address.
Now we are connected to our Network and we just need to import a Wallet that has coins. For that, we need to Go to our running Ganache and select the Key Icon (“Show Keys”) right of the first address that we have on the list.
After that just copy the Private Key.
Then we go back to MetaMask to import this Key to our Wallet.

The Import is located on the same row as the Network we selected by on the right side.

Click this and then Select “Import Account”

Paste the Private Key that we copied from Ganache in the box and *Import*
Now we have Money and we can go and start Coding Stuff.

Creating the Smart Contract

To create our Smart Contract we are going to use an online editor called Remix.

On a more advanced level, Remix actually supports running and deploying on contracts but we don’t really need all of its functions for the basics.

Go and open https://remix.ethereum.org and you will see a Text Editor.

On the top left corner there is a “plus” icon with which we can start our first Contract.

Click it and then we need to type the name of our new Contract. Let’s called it CertificatesRegistry

Now it is time to start Coding Here are our first lines of code that basically define the Version of Solidity that we are using and the actual Contract.
We want to store Certificates and keep some Data for them.

First thing is that we are storing the Image for the Certificate on IPFS for that reason we need to keep the Hash of it.

I would suggest keeping the information of when the Certificate was added as well.

Let’s see how this thing look in Solidity Code and add it to our code.

Now we have a structure where we can store the data we need but we want to keep multiple Certificates on our web page, so we should have an Array of Certificates.
So we can store all the Data in the world, but we don’t have a way to Add new Certificates. Maybe it is time for us to create one function that will do that for us.
The last thing we need in our Contract is a way to get all the Certificates that we have. In Solidity you cannot return Arrays, so we need a Function that will give us the Count of Certificates that we have and then we need another one that will be giving the Information for the specific Certificate.
And this is the very basic Contract that we are going to be using.
To use it we need to deploy it in our Ganache local network. How can we do that? Well, that is the reason we use Remix… as Remix does that for us with only a few clicks.
On the right side of the Editor, we can see some more information. There we have a few Buttons. Which are “Compile” “Run” “Analysis” “Testing” “Debugger” and some Settings. We care only for “Run” right now, so just go ahead and select “Run”

After that, we have a few more things. “Environment”, “Account”, “Gas Limit” and so on. Currently, our eyes are on Environment. There we have few options in a drop-down menu which are basically options for us to tell Remix where were went to play and deploy our Contract. We want to use our Ganache so we should select the Third Option “Web3 Provider”

Then we get a screen asking us if we are sure that we want to connect to Ethereum Node. Please select “Ok” and then on the next screen Click “Ok” again without changing anything in the box.

This way we connect Remix to our Ganache and when we do that Remix automatically fills the Accounts with the ones from Ganache, so we actually have money. (Not like MetaMask)

Now we need to Deploy the Contract. That happens from the *Deploy

*

After that in the Deployed Contract Section, we will see information about our Contract.

The most important thing from there is the Address where our Contract is Located, but for now, leave it as it is we will return back in few minutes. (Please DO NOT CLOSE the Remix)

Creating our JavaScript Front-End

Well, we have our Contract and everything set up. Now we need a way to interact with it and upload Certificates. For that reason, we will be creating JavaScript Page.

I have prepared some Code Skeleton as Resource which holds the CSS, HTML and some initial helper functions we might need and there is no need to code them.

Download the Code Skeleton from Certificate-Registry-Skeleton
Un-zip the Zip Archive and there you will find all the Files we need. We even have the Contract if you had a hard time writing it

The main that we are going to Edit is certificates.js

Open the Folder or the js file in Editor of your choice.
Now we need only one last Installation before we get into JavaScript and finish this Workshop and that is our HTTP-server
1. To install HTTP-server you need to open your terminal (Command Prompt) and type the following in there:

npm install –g HTTP-server

After that go to the project directory and run in your terminal (Command Prompt)

HTTP-server

Let’s get back into the JavaScript editor and our certificates.js File. There you can see a few things prepared and there Two Functions that have “TODO” which we actually need to Code.

Because the actual Skeleton is already prepared and we have our HTTP-server running we can open and see the Page first look. (Not everything will Work but we can see what we have)

Let’s go and Check it out. Open http://localhost:8080

Here is our Initial Version. Of course, the Buttons don’t work right now and it is time to make them do stuff. Let’s start with “Submit Certificate”

Before Starting with our “TODO” items we need to set up our Connection to the Contract. That will be happening with Web3 which is provided by the MetaMask, so the first thing we need to do is check if the user has MetaMask installed and if they don’t we need to tell them to install it.
After that, we need to Connect to the Contract. That is the reason we have an Empty Variable on top which is ContractAddress. We need to write our Contract Address and we get that information from our Remix. (Hopefully, you didn’t close it. I did warn you J) Go back to the Remix and in the Deployed Contracts just click the small icon and it will copy the Address of the Contract and then past it to this variable.

Note: The Contract Address will be different for everybody, so don’t copy this from my screen and just do the Steps.

Now the real Connection. For that, we need something called ABI, but I have already prepared it for you in our Config Folder, so we will use it from the Skeleton and this Address that we just wrote. It looks like this.

Basically saying… Hey, Web3 here is this Contract and it is located on that Address.

This way our JavaScript knows how to communicate with the Contract and where to find it.

The first “TODO” that we are going to code is from the first function “uploadCertificate” which is the one interacting and uploading files the IPFS and then adding the information to our Contract.

In the Skeleton, I have already prepared the IPFS and connected it to the Infura Provider.

You can see that from the first two lines.

Now we have left to code the actual upload.

First, we pick the Div element where our File Form is located and we want to check if the User has selected any file before doing If he didn’t select a file we display an Error using the Helper function “showError”.
Now if the User has selected a file it is time for us to upload it to IPFS and get its hash.

We have the Hash of the Certificate and now we can add it to our Smart Contract. This is done with our variable “contract” with which we made a connection to our *Smart Contract.*
With this, we have our Uploading of Certificates functionality ready and we can go on our Page and check it out. Just go again on http://localhost:8080 and try to submit a certificate.

Now when you click Submit, MetaMask will Pop-up and ask you if you want to make a Transaction. This is because we are trying to Record the Information in the Blockchain and MetaMask asks for permission to do that. Just Click “Submit” in MetaMask and the magic will happen.

If you did everything correct you will get this nice Success Message.

All Good. We can upload certificate images to IPFS and can store the information in the Blockchain, but we cannot still view it. Maybe it is time to start Coding our Second “TODO” (Function).
Ok let’s jump and Code our viewGetCertificates

Here we first need to get the number of how many Certificates we have stored. That is because we want to iterate over them on our JavaScript and not inside the Solidity as for loops in Solidity are quite expensive.

Now we have the number of Certificates and we want to get their information one by one and append them to our HTML using jQuery.

With this, we now should have View of Certificates working as well.

Let’s open our page again at http://localhost:8080 and click “View Certificates” to see if our Certificate that we previously uploaded is there.

Now we have a fully working Decentralized App with IPFS which is Decentralized Storage.

You can hit me with any questions or follow me on:

http://nikolaytech.com
https://linkedin.com/in/thedi
Email: nikolay@nikolaytech.com

Winning Next Block Blockchain Hackathon

Nikolay Angelov — Sat, 22 Sep 2018 20:18:41 +0000

Hello, guys :) My Blockchain team and myself participated in one of the biggest Hackathons in Bulgaria lately - Next Block Hackathon, and the professional jury selected our project – we won the first place! I wanted to share the story with you :) So here it goes.

Starting with the Plan

It’s Sunday, a few days before the beginning of the Hackathon. I presented the idea of joining the Hackathon in our team chat. As usual, everyone is sceptical about it, but still, I managed to gather and convince four people to join me and create a team called Riders on the Chain for this challenge with the idea of making a crypto training bot. Yes, that’s right - our first idea was to program a crypto trading bot. Once again, I managed to convince them all, thank God! We held a meeting, had a bunch of ideas throw on the whiteboard but the majority decided to do Car tracking system. To be honest, I didn't agree on that, but well... it was a team decision and the majority won.

The Problem

Have you ever tried buying a second-hand car?

How often have you encountered sellers who are trying to cheat you by changing the odometer data or the car service data in order to sell you a wrecked car for a high price? If you are as lucky as I am, chances are this has happened to you a lot. In our home country of Bulgaria, we tend to say that buying a car is “a matter of luck". However… what if for some odd reason you are an honest car owner who actually has a perfectly serviced car he wants to sell? Chances are, if your warranty period has expired, nobody would trust you about the car info you are providing.

We are living in an economy where car trading has turned into a trustless business, where both sellers and buyers are incentivized to cheat and lie. How about a 180 degrees change to the market?

We asked ourselves: What is next then?

It was already late Monday, we had already registered our team to the Hackathon and it was about time to start preparing since we already knew what we were going to do. We had the Car itself ready (Just a small Arduino car), but still, we lacked planning. Issues like What are we going to do with this car? How are we going to store the Data? and so on occurred. A large debate later, we figured those out and finally started working on the actual project on Thursday.

Preslav Mihaylov and Rosen Krumov started tackling whatever was necessary for the actual Car. They were quick at figuring out the pieces of Hardware for the connection with the Blockchain and got them, as well as all details in terms of Cryptography.

I wish this were the happy end of the story, but sadly…

Hardware Problems all over the place

They started working on the Car prototype and encountered many problems mainly because of our decision to keep the concept of decentralization and keep all processes in the car hardware itself. We started by connecting to our Wifi but then found it hard to make Web3 work at all with the Arduino modules.

This was a concern since the actual Web3 module written in C++ doesn’t compile in C which leads to the rewriting of almost the entire Web3 by our team member Rosen Krumov in pure C (I am so proud of him!).

We saw a truly needed light at the end of the tunnel after several hard days of work in which Preslav and Rosen figured out how the Car will communicate with the Blockchain

The car seems to work, but what is next?

Well on Wednesday it seemed that the Car will actually work, so the rest of the team used after hours time to start working on the project. I started creating the Smart Contract needed to store the data and everything we needed in a decentralized matter, while Ivan Abadzhiev and Simeon Kotashki started working on the actual website and displaying all the Data we had. It looked like those were easy tasks, but…

The day of the Next Block Hackathon

As usual, I was late for the start of the Hackathon at 8:30 but we still managed to register the entire team we instantly started working without paying too much attention to the instructions and presentation – we were eager to code.

What was ready prior to the Hackathon

We only had a Car that we thought was ready, barely anything about the Smart Contract and the actual Web page. It turned out the car wasn’t exactly working, like – barely, so half the team had to focus on the car problems and me – on the Smart Contract

Trusting your Team

If you don’t trust your team in those types of competitions, you’re usually done before even getting started. Knowing my team definitely helps – I have full trust in them, so I stayed focused on improving the Contract that we had without needing to constantly check on what everyone was doing.

This turned out to be a good strategy since everything was going very smooth till 14:00 we had the Car fully working with the Contract and we had a Frond-end that was just a mockup.

We now had 5 hours to create our JavaScript so we started gathering data from the Blockchain and populate it on our Front-end. In our experience, those are easy tasks that we accomplish on a daily basis so we took the time to relax during lunch.

Time to Make it Work

Lunch is over, we went back to our desks and started working.

I didn't have that much work, so I was slacking a bit and networking around the conference and just checked with the team if they need help on anything. It is only around 16:30 that we figured out that we want to store some more data in our Contract and change some of the mechanics, allowing us to can have a moving chart when the Car passes new Mileages. The best choice was to use Events and I needed to code them in our Contract.

This meant that we needed to redeploy things and that was not that easy process, as you needed to recompile the device code and stuff, so every time we did it we needed to be very careful, but everything went smooth.

The Disasters

We had both Smart Contract and Car fully working and we were very pleased until we tried to access our front-end and it didn't load at all. Like really – at all.

We started looking for what was wrong and we were getting very weird errors all over the places without the ability to debug them. I had made minor changes to the Contract and I was sure that it’s working correctly but the team thought the error can only be in the contract, so we spread the effort to try and debug it. Everyone messing with everything didn’t turn out to be the best team decision, quite the opposite - it just made things worse and got me nervous. I decided to go for a more selfish solution and well – I just ignored everyone.

Serbian Music saves the day

Headphones on, high volume and Semsa on (no judgment please, yes – I do like good Serbian music, I’m from Vidin near the Serbian border after all)!

I can see on my side the team going all over the place but I’m still ignoring them – let them work. I need to know why we only get a blank page.

Here we go! And I see a "console.log(test)" input by a team member who omitted to make it as a string, so it was stopping the execution of the entire page…I can still see many errors, but at least the page was loading and now I can start to do a real debug. Now it was the time to find what is really breaking the interaction between the JavaScript Web3 and the Smart Contract. Jumping into that code and reading the error it seemed like the problem was that we only estimate the amount of Gas Limit without specifying it. I changed it but… no. - it didn't fix the problem.

And here I am back at square one... Going around the code and trying to figure out what the hell is going on. Then I got the brilliant idea to check the ABI that we had, so I just went and re-copied the ABI and…. Miracle - it worked!

I have no words to describe the feeling and relief when it actually ran...

Why is ABI wrong if we didn't play with it?

Why the hell was the ABI changed at all? Well, my guess is -- between the multiple commits and pulls that we did, one of our Git clients managed to auto Merge the ABI file and messed it up very hard.

Now you might think to yourself... Wow man, this should have been the first thing that you needed to check but that is not quite true. The error that we were getting was so weird and out of place that it didn't even make sense to check for this.

Now let's go and impress the jury

Nothing could stop us from winning now. Or not exactly…

What happened is that we went to try everything with the Car and the Car was not able to send anything to our Ganache server that was running on a Google Cloud. We became nervous immediately and Rosen and Preslav started working instantly to fix it.

They had spent more than 15-20 minutes trying different things without success when we found out that the actual problem was the internet.

We were using Ivan’s phone as a Hotspot because the public network Next gave us had firewalls. It seemed like me listening to my music with his Hotspot somehow limited his internet connection and that was causing the issue. We switched to a different phone and the Car started working again. Crazy day!

Time to present

Finally, time to present and Preslav was ready with his Pitching. To be sure that everything will work we had a setup with three different phone hotspots holding all the different parts and pieces we needed.

One for the Preslav's laptop, so he can actually show the website
One for the Car connection
One for the Laptop that was connected to the Google Cloud and keeping the Ganache running there

Every point here was critical if any of the phones went crazy we would not be able to present. Luckily that didn't happen.

During the presentation, the people from the jury were looking interested in the project and asked many valuable questions, so we were proud of our presentation.

Other Projects on the table

Let see what the other teams did.

First were the guys from Automaton Network and they wanted to use their Core platform to create a hotel reservation website. They even created a way for them to Reserve rooms on random with random dates and such. It was looking good and we started getting scared.
The second project was about Sales Managment and to help businesses do sales and payments.
The third team presented a Crypto trading bot. They had a website on which you can set up multiple conditions and different rules for the Bot to follow. After that, you could just click one button and the Bot will start trading while following this rules.
The fourth team was from two very young guys. They created a Crypto trading bot, but they had an AI that was learning how to do it. They managed to train their model from losing a lot of money to be able to not lose any or make a small profit. Which was amazing, so congratulation to them!

The concurrence was really great and everyone definitely deserved an award!

Awards

The closing ceremony with the award was going to be during the Afterparty so we had to wait a little longer until we knew if we had impressed the jury more than our biggest concurrent– according to our own feeling – the great team with the Automaton network!

After grabbing a deserved bite, we got to the party right on time for the ceremony.

First was announced the third team which was the Crypto Bot which you could set up your own conditions. That was not that surprising as we were expecting at least one of the bots to be in the Top 3.

Time for the second place where we expected either us or Automaton to win. What followed got us all worried - they announced the second place and the other Crypto trading bot is a winner, which definitely surprised us in well not such a nice way… We knew that both us and Automaton had a big chance for the first place, so the only thing was to just wait a bit and see how it goes.

Now they announce the First place... We all stand up and could barely hold our breath… Yes, it happened! We heard our team name, we were the winners!! We yield like kids and ran to the stage to get our price.

Final Words

I want to Thank the organizers, the participants in the Hackathon and the jury for the great work. This was my very first Hackathon and it was a lot of fun. All of the projects were very good and I hope we all face each other on other Hackathons in the future :)

Of course, I want to thank my entire team for making this happen and the work. Thank you, guys!

The original article in my website: http://nikolaytech.com/winning-the-next-block-blockchain-hackathon

You can follow me on:
http://nikolaytech.com/
https://www.linkedin.com/in/thedi/
https://www.facebook.com/ghkgk

Issues in the Blockchain Ecosystem;

Nikolay Angelov — Sun, 29 Jul 2018 18:20:53 +0000

Let me share with you some of the Issues in the Blockchain Ecosystem that we face today.
In fact, that was my very first Talk that I did in public. It was very challenging as you all know Blockchain isn't an easy topic, but at the same time, it was very rewarding and fun.

Issues in the Blockchain Ecosystem

Everybody in the world is talking about how great the Blockchain is and how it will change the world, but in reality, we are far away from this happening. Beforehand we need to solve many issues that we currently face and it might be a long road.

When we speak about Blockchain we need to know that there are only two operations that we can perform in the Blockchain.

Read Operation

The first operation that we can perform is the Read Operation.
Read operation is very simple to understand as the Blockchain is public and free for everybody.
Currently, this operation is one of the rare parts of the Blockchain that we have no issues with and that is because of the following properties:

Completely free.
No limits on how much you want to read from the Blockchain.
Anyone can do it.
Anyone can verify that the information is correct and not corrupted.

Write Operation

The second operation is a lot more tricky than the previous one and that is the Write Operation.
We can simply say that most of the Scaling problems in the Blockchain are coming from this operation.
This is because of the fact that trying to change the State of data in the Blockchain is very hard and difficult process.

Validations

Many validations are performed when we want to simply change the data state, purely because you need to be sure that the information you are writing is actually the correct one as the Blockchain is immutable.
Here is the first major problem that we face.

How do we get into Consensus of what to be recorded in the Blockchain?

We have all experienced going out with friends and having a hard time agreeing on where we should go, while in real life we can just play a game of Rock-Paper-Scissors and the winner chooses, in Blockchain, you can imagine that this is a very hard process. That is why we have Consensus Algorithms with which we decide what will happen with the data and who will create the next block.

The most Popular Consensus Algorithm is Proof of Work.
In Proof of Work, we give a very hard puzzle to everybody to race and complete, while the winner has the right to create the new Block and receive the rewards for doing so.

The problems of Proof of Work Consensus

Their many problems with Proof of Work such are being very expensive, very slow and the fact that there might be many winners of the Puzzle Solving competition which can create problems (Forks).

Ok, now we had some brief introduction to what Blockchain is and its time to start checking out the problems.

Scalability

When we talk about Blockchain scalability issues we have few metrics with which we can measure the problem. Which are the following:

Transactions Throughput
Transactions Latency
Transactions Fees
Data Storage And I am going to use these metrics to point out some issues.

Transactions Throughput

This is basically the maximum rate at which the system can write transactions to the Blockchain. So we measure Transactions Throughput by the number of transactions per second (tps) that the network can handle. To calculate the transactions per second of Blockchain isn't that hard and that is because of the fact that every block has a size limit and takes a certain amount of time to be created.

In the case of Bitcoin, the block size is measured by actual size and it is 1 MB per block, which puts Bitcoin at an average of 7 tps.
While in Ethereum it is measured by Gas Limit, as there we have Smart Contracts and their computation time is also concerned when creating a new block. The Gas limit of Ethereum is currently (When the Article was written) 7,996,070 and usually, the network produces from 10 to 15 tps.
Of course we have a lot faster networkers then this two, but in reality, they achieve this by sacrificing something else, while Bitcoin and Ethereum are looking for full solution or solutions that only improve the network and have no bad impacts at all.

This is very slow and the business needs, a bigger throughput. For example, many people compare Blockchain Transactions Throughput to what Visa can handle, but I really don't like that comparison, because of the fact that Visa is able to do that with very hight Fees and we don't want that.
That's why I will just shoot and say that we should be aiming for over 100 000 tps in a case that we really want to use Blockchain to change the world.
This might sound really high, but I like the quote from W. Clement Stone which says "Aim for the moon. If you miss, you may hit a star."

Transactions Latency

I already mention that each block takes a certain amount of time to be created and this is basically called Block Time. Which is a necessary evil, as it takes time for every Node in the network to hear about a new block and in case of superfast Block Interval, we will be seeing a lot of Forks.
This Transactions Latency is also connected to the Consensus Algorithm as its the algorithm job to keep the Block Interval at the same pace.
In Bitcoin, we have a new block every 9-10 minutes and in Ethereum we have a new block every 10-15 secs.
This interval is very slow as in reality every single transaction is being executed at Block Creation. This is very important to be known as many people miss understand the measurement thing "Transactions per second" and think that transactions are executed each second when they are not.

This latency is even bigger when the possibility of Forks exists, as most business currently wait for 6 blocks confirmations to accept your transaction and in case of Bitcoin that we will put you at 1 Hour wait.

Transactions Fees

In some cases, transactions fees can be bad and good. The reason behind that is that you decide what fee you are going to give. You are free to choose to give a fee as little as 0.10$ or as much as 50,000$ but giving a higher fee will increase the chance of your transaction being included in the next block.
That's because of the few things we already covered like blocks having a limited size and the Proof of Work being very expensive.
Your fee is basically bribing the Miners (People that solve the Proof of Work puzzle) as they are the one deciding which transaction will get into the block.
The issue is when the network is loaded and there many pending transactions, then the average fees can get pretty nasty and hit over 40$ in Bitcoin which is a lot. While in Ethereum there was a game called Cryptokitties which loaded the network so much that the transactions skyrocket to 4$ when a normal transaction was being processed for 0.10$ previously.

Data Storage

Currently, all of the Blockchain is being stored at every single Node and you can imagine that this is not really good as the information is being duplicated thousands and thousands of time. The information being store everywhere is not the main issue here.

The main issue is the fact that all the Networks do is grow and that's because of their properties of being immutable. That makes it so at some point the Blockchain will be hard to store and will take enormous time to download, which reduces the Decentralization part of the chain by a lot.
For the network to be fully Decentralized everyone on the world should be able to download and connect to the network without any trouble and having chains being over 500 GB makes this harder, which reduces the number of people being able to participate and leads to Centralization.

Data Storage is as well a blocker of many easy solutions to all of the previously mentioned problems. Such solution can be just increasing the Block Size that will lead to bigger transactions throughput and lower fees, but in that way, we will be storing way more data and we will get really fast to 500 GB+, which will be really bad for the health of the network.

Scalability Solution

When we talk about the solutions we aim to find ones that fix everything without creating bad impact at all and such solutions exist and are being developed constantly. Some of them are:

Lightning Network
Raden
Casper
Sharding

I am going to cover each of these scalability solutions in a later article, so if you are curious about them you can stay tuned by following me on my website http://Nikolaytech.com :)