Solidity
Solidity est un langage de programmation orienté objet dédié à l'écriture de contrats intelligents. Il est utilisé pour implémenter des smartcontrat sur diverses blockchains, notamment Ethereum. Il a été développé par Christian Reitwiessner, Alex Beregszaszi, Yoichi Hirai et plusieurs anciens contributeurs principaux d'Ethereum pour permettre l'écriture de contrats intelligents sur des plateformes de blockchain telles qu'Ethereum.

Historique 
Solidity a été initialement proposée en  par Gavin Wood ; le langage a ensuite été développé par l'équipe Solidity du projet Ethereum, dirigée par Christian Reitwiessner. 

À l'heure actuelle, Solidity est le principal langage sur Ethereum ainsi que sur d'autres blockchains privées fonctionnant sur des plateformes en concurrence avec Ethereum, telles que Monax et sa blockchain Hyperledger Burrow, qui utilise Tendermint pour le consensus. SWIFT a déployé une preuve de concept à l'aide de Solidity exécuté sur Burrow.
Un chercheur de l'université Cornell a déclaré que Solidity était en partie responsable du piratage de The DAO en 2016. Il a déclaré : « ce n'était en fait pas une faille ou un exploit dans le contrat DAO lui-même : techniquement, la machine virtuelle Ethereum (EVM) fonctionnait comme prévu, mais Solidity introduisait des failles de sécurité dans les contrats qui avaient échappée à la communauté, mais aussi aux concepteurs du langage eux-mêmes. »
En effet, des contraintes propres à l'EVM, telles que l'impossibilité de mettre à jour un contrat intelligent (à moins d'en déployer un nouveau), ou l'absence de virgule flottante intégrée peuvent rendre certaines failles très difficiles à trouver et à corriger.

Description 
Solidity est un langage de programmation de type statique conçu pour développer des contrats intelligents qui s'exécutent sur l'EVM (Ethereum Virtual Machine). Solidity est compilé en bytecode lui-même exécutable sur l'EVM. Grâce à Solidity, les développeurs sont en mesure d'écrire des applications implémentant une logique commerciale s’exécutant de manière autonome au travers des contrats intelligents, laissant une trace de transactions non répudiables et faisant autorité. Écrire des contrats intelligents dans des langages spécifiques aux contrats intelligents tels que Solidity est considéré comme facile (en apparence pour ceux qui ont déjà des compétences en programmation).

Exemple de programme Solidity : 
pragma solidity >=0.5.0 <0.7.0;

contract Coin {
    // The keyword "public" makes variables
    // accessible from other contracts
    address public minter;
    mapping (address => uint) public balances;
    mapping (address => mapping (address => uint256)) public allowed;

    // Events allow clients to react to specific
    // contract changes you declare
    event Transfer (address from, address to, uint amount);
    event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
    event MintingRightTransferred(address indexed oldMinter, address indexed newMinter);

    string public symbol = "WIKI";
    string public name = "WikiArticleToken";
    uint256 public totalSupply;

    // Constructor code is only run when the contract
    // is created
    constructor() public {
        minter = msg.sender;
    }

    // Sends an amount of newly created coins to an address
    // Can only be called by the contract creator
    function mint(address receiver, uint amount) public {
        require(msg.sender == minter);
        require(amount <= 2**256-1); // be aware of high amounts since overflow exist
        balances[receiver] += amount;
        totalSupply += amount;
        emit Transfer(address(0), receiver, amount);
    }

    // Sends an amount of existing coins
    // from any caller to an address
    function transfer(address receiver, uint amount) public {
        require(amount <= balances[msg.sender], "Insufficient balance.");
        balances[msg.sender] -= amount;
        balances[receiver] += amount;
        emit Transfer(msg.sender, receiver, amount);
    }

    function transferFrom(address from, address to, uint256 amount) public returns (bool success) {
        require((allowed[from][msg.sender]||(from == msg.sender)) >= amount, "You aren't allowed to spend this amount");
        require(amount <= balances[from], "Insufficient balance");
        allowed[from][msg.sender] -= amount;
        balances[from] -= amount;
        balances[to] += amount;
        emit Transfer(from, to, amount);
        return true;
    }

    function allowance(address tokenOwner, address spender) public view returns (uint remaining) {
		return allowed[tokenOwner][spender];
    }

    function approve(address spender, uint tokens) public returns (bool success) {
        allowed[msg.sender][spender] = tokens;
        emit Approval(msg.sender, spender, tokens);
        return true;
    }

    function balanceOf(address guy) public view returns (uint256 balance) {
        return balances[guy];
    }

    function transferMinterRight(address _newMinter) public {
        require(msg.sender == minter);
        emit MintingRightTransferred(minter, _newMinter);
        minter = _newMinter;
    }
}

Disponibilité de la plateforme de développement 

 Microsoft Visual Studio
 Code Microsoft Visual Studio
 ConsenSys Enterprise
 Tendermint sur Microsoft Azure
 ErisDB sur AWS
 Environnement web Remix

Plateformes Blockchain 
Solidity est disponible sur: 

 Ethereum 
 Ethereum Classic 
 Tendermint et ErisDB (une version de Tendermint)
 Contrepartie (qui fonctionne sur Bitcoin )
 Tron
 Binance Smart Chain

Voir aussi 
Vyper, un autre langage destiné à la creation de smartcontrat sur la machine virtuelle Ethereum.

Références 

Programmation orientée objet