Why solidity is essential for programming on Ethereum blockchain

pragma solidity ^0.5.0;
contract MessageContract {
    string private storedMessage; // Private variable to store the message
    constructor(string memory initialMessage) public {
        storedMessage = initialMessage; // Initialize the message on contract deployment
    }
    function getMessage() public view returns (string memory) {
        return storedMessage; // Function to retrieve the stored message (read-only)
    }
    function setMessage(string memory newMessage) public {
        storedMessage = newMessage; // Function to update the stored message
    }
}

pragma solidity ^0.5.0;
contract CryptoExchange {
    mapping(address => uint) public userBalances; // Mapping to store user balances
    address public owner; // Public variable to store contract owner's address
    constructor() public {
        owner = msg.sender; // Initialize the owner with the address of the deploying account
    }
    function depositEther() public payable {
        userBalances[msg.sender] += msg.value; // Function to deposit Ether into user's balance
    }
    function withdrawEther(uint amount) public {
        require(userBalances[msg.sender] >= amount, "Insufficient balance"); // Ensure user has enough balance to withdraw
        userBalances[msg.sender] -= amount; // Deduct amount from user's balance
        address(uint160(msg.sender)).transfer(amount); // Transfer Ether to the user's address
    }
    function tradeEther(uint amount) public {
        require(userBalances[msg.sender] >= amount, "Insufficient balance"); // Ensure user has enough balance to trade
        userBalances[msg.sender] -= amount; // Deduct amount from user's balance
        uint tradeAmount = amount * 2; // Simulate a trade by doubling the amount
        userBalances[msg.sender] += tradeAmount; // Credit the user's account with the traded amount
    }
}

pragma solidity ^0.5.0;
contract CustomToken {
    string public tokenName; // Public variable for token name
    string public tokenSymbol; // Public variable for token symbol
    uint8 public tokenDecimals; // Public variable for token decimals
    uint public totalTokenSupply; // Public variable for total token supply
    mapping(address => uint) public tokenBalances; // Mapping to track token balances
    event TokensTransferred(address indexed sender, address indexed recipient, uint amount); // Event to log token transfers
    constructor(string memory _tokenName, string memory _tokenSymbol, uint8 _tokenDecimals, uint _totalTokenSupply) public {
        tokenName = _tokenName; // Initialize token name
        tokenSymbol = _tokenSymbol; // Initialize token symbol
        tokenDecimals = _tokenDecimals; // Initialize token decimals
        totalTokenSupply = _totalTokenSupply; // Initialize total token supply
        tokenBalances[msg.sender] = _totalTokenSupply; // Allocate all tokens to the contract deployer
    }
    function transferTokens(address recipient, uint amount) public returns (bool) {
        require(tokenBalances[msg.sender] >= amount, "Sender has insufficient balance"); // Ensure sender has enough tokens to transfer
        tokenBalances[msg.sender] -= amount; // Deduct tokens from sender's balance
        tokenBalances[recipient] += amount; // Add tokens to recipient's balance
        emit TokensTransferred(msg.sender, recipient, amount); // Emit transfer event
        return true; // Return true if transfer is successful
    }
}

pragma solidity ^0.5.0;
contract SecurePayment {
    address public owner; // Public variable for contract owner
    mapping(address => uint) public balances; // Mapping to track user balances
    constructor() public {
        owner = msg.sender; // Initialize the owner with the address of the deploying account
    }
    function deposit() public payable {
        balances[msg.sender] += msg.value; // Function to deposit Ether into user's balance
    }
    function withdraw(uint amount) public {
        require(balances[msg.sender] >= amount, "Insufficient balance"); // Ensure user has enough balance to withdraw
        balances[msg.sender] -= amount; // Deduct amount from user's balance
        address payable recipient = msg.sender;
        recipient.transfer(amount); // Transfer Ether to the user's address
    }
    function transferOwnership(address newOwner) public {
        require(msg.sender == owner, "Only the owner can transfer ownership"); // Only allow the current owner to transfer ownership
        owner = newOwner; // Transfer ownership to the new address
    }
}