Not too long ago we opened up the discussion about Decentralized applications (DApps), and the difference between them and traditional web applications. We explained how DApps look and feel very much like normal web applications. But the main difference between the two is how they store data. DApps use blockchain as a decentralized database instead of a regular database stored on centralized servers.
This gives decentralized applications the upper hand since data collected through them is stored in a decentralized network. In other words, there is no central collection point, hence no central point of failure.
Before we do that, though, let’s start from the beginning and talk about what it takes to create a normal or traditional app.
Creating an app
Whenever we talk about an application, mobile or web, there is always at least one developer behind it. Developers, or programmers, are the technical wizards that make it possible for us to interact with our digital devices. They create applications using lists of functions that determine what each program does.
For example, a basic calculator application is built to help with basic math, and that is all you can use it for. Your email is used for corresponding with others and nothing more, and so on. Other, more complex applications can have a greater range of functionalities, all dictated by these lists.
Two sides of the same coin
Frontend, as the name suggests, is what a user sees and experiences when interacting with an app. This includes everything from fonts, images, and buttons, to contact forms and menu bars. The frontend is also responsible for accessibility and responsiveness, as we use different-size screens every day. Therefore, it is very important that applications are designed to fit both mobile devices as well as desktops.
Backend development is what enables frontend to interact with the user based on their requests. The backend part includes everything you can’t see as a user, even if you open up the source code in the browser. This includes database and API integration as well as the communication between them and the browser.
Different talents, one team
Having a two-phase development process means you will also need people specialized on each side. As a result, most of the time you will have a team formed from a developer specialized in frontend and a one trained in the backend. Frontend developers are always user-oriented and creative. They are responsible for how the application looks and feels making it life-like, therefore, they need to plan according to the target group preferences.
Backend developers, on the other hand, are technical and analytical. Their role is to provide endpoints to what the frontend developers propose. Consequently, their focus is not on the interface, but on the functionality that needs to be served to the user of the app.
Because of the two very different priorities, a team consisting of frontend and backend developers needs to be in close communication at all times. That is if the developer is not already filling both shoes!
The full stack developer
There is such a thing called a full stack programmer. These are developers who master both backend and frontend skills and work all the way throughout the building process. Think of them as a one-man band. The greatest advantage of having full-stack programmers in your team is that communication between front and backend is easier, and they’re volatile. You may assign a frontend project to one full stacker this time, but next time they may work on a backend task. Nice, isn’t it?
However, the role of the developer is not only dictated by the functionalities they have to set up, but also by the languages they need to use. The very reason why we differentiate the two… well… three, in the first place.
A multilingual universe
We’ve mentioned before that source code is written in what we call programming or markup languages. Much like the physical world, the world of development has many different languages that are, most of the time, specific for either client side (frontend) or server side (backend).
The good news is that programming has evolved greatly over the years, and the developing community continuously works towards simplifying the process. In order to do so, coders create frameworks and libraries that contain code fulfilling specific functionalities.
The difference between a framework and a library is called “inversion of control”. Basically, when using a library, the developer is in control and they call the library. In the case of frameworks, developers have no control, and it is the framework who makes the method call.
This also allows frameworks to contain libraries within themselves, easing the developers’ job even further. Not only that programmers need to learn less than before, but they can combine these tools to create amazing results in both front and backend.
One programming language to rule them all
What does the future hold?
However, blockchain technologies have captured developers’ attention more and more lately. One might say that blockchain has even brought potential competition to web applications through decentralized apps. This is mainly because DApps do not use a centralized or even distributed data storage solution that is prone to cyber attacks. So, in the scenario that DApps do take over the world wide web, how can programmers adapt?
Building applications on the blockchain
Creating a DApp also means either creating your own blockchain or using an existing one to build an application on top. However, creating an application on a blockchain can be troublesome. The technology is new, the extent of using it is vast and somewhat vague, there are no real regulations, the list goes on. But most of all, developers are confused as to what programming language to use to build a DApp.
Satoshi Nakamoto, for example, created Bitcoin using C++, and this programming language has its merits. It is stable, fast, and performs well. But C++ is difficult to learn so, for not-yet-expert programmers, building blockchains using C++ may prove to be a challenge.
There are other options! Ethereum is written using Solidity. This is to help today’s developers combine the skills they already master with blockchain technology. However, before one can build their own blockchain, they must first understand all the components that go into this technology.
This means that, yes, as a developer, you do not have to learn a new language. However, blockchain technologies are complex at first. So building a new blockchain to then create a DApp is going to be tedious and time-consuming. And, as we’ve seen so far, the development community does not do “tedious and time-consuming. They find a better, faster and easier solution instead,
Lisk came to life in 2016 when co-founders Max Kordek and Oliver Beddows, created The Lisk Foundation. The goal behind both the foundation and the platform is to make blockchain more attractive to developers around the world.
In the words of the company, Lisk is meant to make this new technology less intimidating.
“Let’s build a decentralized future together.”
However, Lisk is not the only solution for creating DApps, of course. Ethereum and NEO, to give just two examples, allows developers to do that too, and much like Lisk, they also allow them to use languages they are familiar with. However, Lisk is rather special.
The platform provides an easy-to-use development solution called a Sidechain Development Kit (SDK). This means that when developers decide to create a DApp using Lisk, they are not deploying it on the main chain, but on adjacent sidechains. This allows them to have their own tokens, as well as deploy functional and scalable applications on the Lisk blockchain.
But Lisk is not only scalable because of its unique SDK, Lisk is scalable because of it’s consensus mechanism when the blockchain needs to validate transactions and interaction on the chain.
How Lisk blockchain works
We all remember CryptoKitties, right? This cute little game was one of the first DApps in the world. Basically, it was the Tamagotchi of 2017, only you would buy a little digital kitten and care for it, all on the Ethereum blockchain. The problem with this cute little game was that, much like every cute little thing in the world, it attracts attention.
When CryptoKitties started to gain popularity, the game started to work slower and slower. Because Ethereum blockchain can only support around 15 transactions per second, when enough players were active, the application would simply just crash.
In general, blockchain hasn’t proved itself as a scalable technology, yet. The more active users, the heavier the network gets. Hence the longer it takes to validate transactions on the blockchain. This can also be seen in the Bitcoin crisis of December 2017. Blockchains like Bitcoin work on what we call Proof-of-Work. Basically, whichever computer has the strongest power to mine Bitcoin, the network will assign them the task of mining the next block.
This is troublesome not only because it clogges the network as computers “fight” for the right to mine, but also because it’s not really democratic. Think about it. There are “super mines” in Russia taking all the loot, and the rest of us just sit there and wait for our chance.
The Lisk blockchain, on the other hand, works on the Delegated Proof of Stake (DPoS) consensus which makes Lisk, and technologies similar to it, scalable. Imagine it this way: instead of 10 miners fighting for 1 diamond, you have 10 delegated people mining 10 different diamonds. Everyone gets something in the end and everyone is happy.
Technology is advancing at a more rapid pace than ever, and with progress, developers need to adapt. Luckily, Lisk was created to help ease the transition from a traditional developer to a DApp developer by allowing them to use a language they know and have worked with.
More importantly, if successful, Lisk with help propel blockchain development as more and more contributors will rise from the crowds. Time will tell how large this adoption will be and how fast it will happen.
In the meantime, visit our site and read more about how blockchain technologies can help us save the environment or how it could replace traditional databases.