From JavaScript developer to DApp developer with Lisk

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.

In today’s post, we will take you a bit further than that. We will explain how the modern programmer can evolve from a JavaScript developer to a DApps developer. How? By using an amazing new technology provided by Lisk.

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

web development
https://gph.is/28Z3tKb

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. The lists of instructions are called source code and are written in programming languages. However, programming requires certain skill sets for an application to be both functional and user friendly.

Two sides of the same coin

Blockchain
https://unsplash.com/photos/_SdoUGFBhnI

When building any kind of application, there are always two developing phases:

Frontend

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

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

web application
https://unsplash.com/photos/IJFnMSGY_bM

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

full stack developer
https://unsplash.com/photos/6yjAC0-OwkA

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

creativemultimediainstitute.in/images/pages/computer-programming-language-classes.png

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). For example, a backend developer will be specialized in languages such as PHP, Ruby or Python. A frontend developer, on the other hand, will be trained in HTML, CSS, and JavaScript.

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

programming languages
https://hackernoon.com/12-amazing-javascript-shorthand-techniques-fef16cdbc7fe

Most programming languages are meant to be used only on one part of development or the other. But because of frameworks, there are ways around that. The most popular general-purpose programming language is JavaScript (JS) because it allows both frontend developers to build the application purely in JavaScript and the backend developers to code in JavaScript using NodeJS.

In one of our recent posts, we presented the successful recipe Wiredelta® follows to create amazing products for our partners. We explained there that Wiredelta developers use a combination of JavaScript and JS frameworks to build any type of application. So instead of having vague knowledge in two or more languages, this strategy allows our programmers to train on just one and truly master it. Basically, they become JavaScript developers.

What does the future hold?

blockchain technologies
https://unsplash.com/photos/xsGApcVbojU

As a consequence of the growing popularity of JavaScript, the demand for JS developers increases exponentially. This also resulted in a boom in full stack developers due to the ever-growing number of frameworks they can use to serve both frontend and backend with Javascript.

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

Decentralized applications
https://unsplash.com/photos/U3m4_cKbUfc

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,

Introducing Lisk

Lisk
https://lisk.io/

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

Max Kordek, president and CEO at Lisk

Lisk is a platform that allows developers to create and deploy decentralized applications using JavaScript as a programming language. As we said before, JavaScript is the most popular markup language today. This makes it easy and attractive for a JavaScript developer to “dip their toe” in blockchain-based applications. 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.

Ethereum blockchain
https://www.cryptokitties.co/

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.

Conclusion

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.

Moreover, using the new and exciting SDK technology and the DPOS protocol, Lisk becomes reliable and attractive. Not only is it scalable, but programmers around the globe may be more and more tempted to give it a try with it’s JavaScript adoption.

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 blog and read more about how blockchain technologies can help us save the environment or how it could replace traditional databases.

Recent Comments

Comments are closed.