Solidity smart contract was created by Dr. Gavin Wood as a language explicitly for writing smart contracts with features to directly support execution within the decentralized environment of the Ethereum world computer. The resulting attributes are quite general, then it’s ended up getting used for coding smart contracts on several other blockchain platforms. It had been developed by Christian Reitiwessner then also by Alex Beregszaszi, Liana Husikyan, Yoichi Hirai, and a number of other former Ethereum core contributors. Solidity is currently developed and maintained as a self-regulating project on GitHub.
The key product of the project is that the Solidity compiler, sold, which converts programs written within the Solidity language to EVM bytecode. The project likewise achieves the important (ABI) application binary interface standard for Ethereum smart contracts. Each version of the compiler corresponds to and compiles a selected version of the language.
To get started, we’ll download a binary executable of the Solidity smart contract compiler. Then we’ll develop and compile an easy contract.
Selecting a Version of Solidity
Simple Solidity contract follows a versioning model called semantic versioning that needs version numbers structured as three numbers separated by dots: MAJOR.MINOR.PATCH. The “major” number is incremented for major and backward-incompatible changes, the “minor” number is incremented as backward-compatible features are added in between major releases, and therefore the “patch” number is incremented for backward-compatible bug fixes.
Solidity is at version 0.6.4 at this time of writing. The principles for major version 0, which is for the initial development of a project, are different: anything may change at any time. In preparation and practice, Solidity gives the “minor” number as if it were the main version and therefore the “patch” number as if it were the minor version. Therefore, in 0.6.4, 6 is taken into account to be the main version and 4 the minor version. The 0.5 major version release of Solidity is predicted imminently.
Our programs may contain a pragma directive that specifies the minimum and maximum versions of smart contracts that it’s compatible with and maybe won’t compile your contract. Since it is rapidly evolving, it’s often better to put in the newest release.
Download and Install
There are a variety of methods we will use to download and install, either as a binary release or by compiling from ASCII text file. We will find detailed instructions within the documentation. Here’s the way to install the newest binary release of Solidity on an Ubuntu or Debian OS, using the apt package manager:
$ sudo add-apt-repository ppa:ethereum/ethereum
$ sudo apt update
$ sudo apt install solc
Once we’ve solc installed, check the version by running:
$ solc –version
solc, the solidity compiler command-line interface
There are a variety of other ways to put, counting on our OS and requirements, including compiling from the ASCII text file directly. For more information about Solidity smart contract Github examples.
To develop in Solidity, we will use any text editor and solc on the instruction. However, we’d find that some text editors designed for development, like Emacs, Vim, and Atom, offer additional features like syntax highlighting and macros that make Solidity development easier. There also are web-based development environments, like Remix IDE and EthFiddle.
Use the tools that make us productive. Within the end, Solidity programs are just plain text files. While fancy editors and development environments can make things easier, we don’t need anything quite an easy text editor, like nano (Linux or UNIX), TextEdit (macOS), or maybe NotePad (Windows). Simply save your program ASCII text file with a.sol extension and it’ll be recognized by the compiler as a Solidity program.
Writing an easy Solidity Smart Contract Program
Our first attempt seemed like Faucet.sol: A Solidity contract implementing a faucet.
Example 1. Faucet.sol: A Solidity contract implementing a faucet
Link: code/Solidity/Faucet.sol 
Compiling with the Solidity Compiler (solc)
Now, we’ll use the Solidity compiler on the instruction to compile our contract directly. The Solidity compiler solc offers a spread of options, which we will see bypassing the –help argument. We use the –bin and –optimize arguments of solc to supply an optimized binary of our example contract:
$ solc –optimize –bin Faucet.sol
======= Faucet.sol:Faucet =======
The result that solc produces may be a hex-serialized binary which will be submitted to the Ethereum blockchain.
For more information please visit solidity tutorials.