Learning Solidity for Ethereum

A month ago I just finished a course in developing applications using Solidity on the Ethereum blockchain.

The #blockchain craze really caught my attention on the finance side of things but when I dug deeper there was something interesting to look at with the technology that brought this ideology of having a decentralised information network.

Wrapping my head around the technology itself took a while as it was not what the course was about, so going into this course took some adjustment to my current way of thinking when it came to development. The tutorial started off with some very cumbersome environment setups that almost deterred me from continuing but with recent development updates the materials used during the course became a lot easier to use and following along with the tutorial was a lot smoother at times. Updates to the environment and language were frequent as the Solidity language was still in some early stages and I am surprised it is still so widely adopted.

The language itself I believe feels similar to Java but do not take my word for it as it has been a while since I even looked at the Java language. The syntax felt feeble at times with respect to how they handle data types and expressing iterative logic. But from what I read the code is then compiled into something else before being stored in the VM which I didn't care to get into. Building smart contracts from what I understand is costly so if there is one thing this course has thought me is that you need to ensure your code is as efficient as possible. The more work your code has to do....the more you pay! Writing smart contracts became easier to assemble once you know what you want to do and understand the jargon of Solidity. The compilation and distribution process is something to really make sure you understand and the tools provided do try to help make the process a whole lot simpler.

The front-end aspect of it was almost straightforward given that they developed a javascript library to handle the communications between your UI/UX interface and the Ethereum backend solution hosting your smart contract. But some of the interactions with it as of the date of this article are still to be desired such as proper error messaging. Yet, it was easy to get the hang of coding your front-end especially if you are a Front-end Developer and familiar with how ajax/ web services work. This was probably the easiest part of the course.

Deployment! Jeez! I thought you just code everything and submit it to the network and that was it. Turns out to get your contract backend on the network you have to first setup an environment to host the network chain, downloading the entire block before trying to publish the stuff! I was told in the course there are some 3rd party services that handle it for you but did not try to dive into it. Furthermore, based on my understanding from the course users interact with your DApp using a 3rd party software called a "DApp browser". I'm still trying to wrap my head around this!

The course was a struggle for me in some areas with a lot of do-overs and failed code but managed to trod on and complete the course successfully. The DApp in the course was a simple enough concept to understand what is needed to interact with your smart contract.

There is now a growing market for DApps and Ethereum developers, so it was worth participating in. So if you are interested in the technology and want to acquire some skill set in this new niche market, Solidity/ Ethereum is the widely adopted choice. Try it!

Me on the other hand....There must be a more easier, familiar way to build DApps and smart contracts that can be deployed and managed a lot better. With the kind of growth I am seeing the possibility, hopefully, will soon come.