pragma solidity ^0.4.0;
contract RyanCoin {
    address public creator; 
    mapping (address => uint) public balances;
    
    /**
     * - msg is global attribute.
     * - This constructor is 'create' button
     */
    function RyanCoin(){
        creator = msg.sender;
    }
    
    /**
     * - creator use this function to give other people coins
     * - make sure it is the creator running this function
     */
     function setCoin(address receiver, uint amount){
         if(msg.sender != creator) throw;
         balances[receiver] += amount;
     }
     
     /**
      * - other participants use this function to transfer coins
      */
      function transfer(address receiver, uint amount){
          if(amount > balances[msg.sender]) throw;
          balances[msg.sender] -= amount;
          balances[receiver] += amount;
      }
}

"0": "uint256: 5"

"address receiver": "0x14723a09acff6d2a60dcdf7aa4aff308fddc160c",
"uint256 amount": "2"

pragma solidity ^0.4.0;
contract RyanCoin {
    mapping (address => uint) public balances;
    uint constant public PRICE = 2000000000000000000; // 2 ETH as PRICE
    
    function RyanCoin(){
    }
    
    function buyCoin() payable{     // pay ETH to create coin
        require(msg.value > 0 && msg.value % PRICE == 0);
        balances[msg.sender] += (msg.value / PRICE);
    }        
}

pragma solidity ^0.4.0;

// temperature account where store money during transaction

contract Escrow {
    
    address public buyer;
    address public seller;
    address public arbiter;    // settle any dispute
    
    function Escrow(address _buyer, address _seller, address _arbiter){
        buyer = _buyer;
        seller = _seller;
        arbiter = _arbiter;
    }
    
    // we have different stages in this contract
    
    function confirmPayment() payable {
        require (msg.sender == buyer);
    }
}

pragma solidity ^0.4.0;

contract Auction {
    
    string public description;
    address public owner;
    address public maxBidder;
    uint public maxBid;
    uint public autionEnd;
    mapping(address => uint) pendingWithdrawals;
    
    event BidAccepted(address bidder, uint bidAmount);
    event AuctionCompleted(address winner, uint bidAmount);
    
    function Auction(uint durationMinutes, string _description){
        description = _description;
        autionEnd = now + (durationMinutes * 1 minutes); // `now` is global var
        owner = msg.sender;
    }
    
    // rollback function
    function() payable {
        // fire some log, invoke other function
        throw;
    }
    
    function bid() payable {
        require(msg.value > maxBid);
        require(now < autionEnd);
        
        if(maxBidder != 0){
            pendingWithdrawals[maxBidder] += maxBid;
        }
        
        maxBid = msg.value;
        maxBidder =  msg.sender;
        BidAccepted(maxBidder, maxBid);
    }
    
    function end(){
        require(msg.sender == owner);
        require(now >= autionEnd);
        
        pendingWithdrawals[owner] = maxBid;
        AuctionCompleted(maxBidder, maxBid);
    }
    
    function withdraw() returns (bool){
        uint amount = pendingWithdrawals[msg.sender];
        if(amount > 0){
            pendingWithdrawals[msg.sender] = 0;
            if(!msg.sender.send(amount)){
                pendingWithdrawals[msg.sender] = amount;
                return false;
            }
        }
        return true;
    }
}