On this first post in the Development section we will learn how to create our first Ethereum decentralized app.

Firstly, if we go to the official Ethereum page, we can see what is a Smart Contract, it is a distributed application that instead of running in only one server making others to connect to this app, the Smart Contract is running on every single server or node of the Ethereum network.

These apps are working on Ethereum Virtual Machine that can be found on each blockchain node. It is not only sandboxed, but actually completely isolated, which means that code running inside the EVM has no access to network, filesystem, or other processes. Smart contracts even have limited access to other smart contracts.

Contracts live on the blockchain in an Ethereum-specific binary format (EVM bytecode). However, contracts are typically written in an Ethereum high level language, compiled into byte code using an EVM compiler, and finally uploaded on the blockchain using an Ethereum client.

Once our app is deployed in the blockchain, it cannot be stopped or modified unless the implementation of our app says so. It is an autonomous system.

These Dapps programming is available in multiple languages like JavaScrypt and Python. Solidity is currently the most advanced and most extended high level language to build Smart Contracts.

There are also really useful command line tools to work with the Ethereum network, one of the most famous clients is written in Go, is called Geth or go-ethereum.

There is a great variety of projects made by the community currently running on the Ethereum blockchain, have a look at this page to find some of them.

Once the introduction is over, let’s create our first Smart Contract. To do so, We are going to open an online IDE, Browser Solidity, because the contract we are going to create is going to be simple and this tool, that simulates a full Blockchain environment on our browser, is more than enough.

As we commented before, when we deploy a contract to the blockchain, there’s no way of stop it unless it is implemented on its code. So let’s create a simple contract that stores the creator’s address and that has a kill() function that removes the contract and that can only be executed by the mentioned address.

pragma solidity ^0.4.15;

contract CryptoXContract {
address creator;

function CryptoXContract() {
creator = msg.sender;
}

function getCreator() constant returns (address) {
return creator;
}

function kill() {
if (msg.sender == creator) {
suicide(creator);
}
}
}

Once the contract is published on a blockchain address, we can see the methods of the contract on the development environment and as our address is the one that created the contract, we can call the kill function and wait till the transaction is mined and validated to have the contract removed.

On a next post we will learn how to deploy our contracts on the real Ethereum network using Mist instead of using a test environment like Browser Solidity.

If you want to keep up with our latest news please:

Hang out with us in our Slack
Follow Crypto-X on Facebook
Follow Crypto-X on Twitter
Follow Crypto-X on Steemit
Follow Crypto-X on Reddit
Follow Crypto-X on Medium

Donations:

♥ BTC: 14a9FrErT8j3Pp6iJSurXsrNkSqrirV7qe
♥ ETH: 0x5f982128fe96560544feef7edfbf503ab17a134f
♥ LTC: LQPkLe6xYhBxU4knEYP7rACUfj3aevfPtU