Guys this post took a lot to put together. It'd be really nice if you could leave a tip to support my work. Thanks,and to the moon!

I sure am excited about this!

I know that my last post was about why we needed altcoins in circulation.(check that out here)

So here we are making altcoins!

In this article, I'll list the things you'll need to create your own token. Then I'll list a source code gotten from Tokenfactory

You will have to edit this code to fit your needs.

Next,you'll test the token on Testnet.(you'll need metamask for this part. Install it through that link if you haven't already).

Then you'll launch your token and submit requests to exchanges if you want to get it listed.

And I'll explain everything in the simplest of English along the way!

Ps: I tested this method,but completely forgot to take screenshots on the way. So I will try to explain everything as simply as possible, while I go ahead and create another dummy coin just for pictorial purposes. Please bear with me.

Alright! Let's get started!

So first,you'll need to define what your token will be. There are four criteria you need to consider:

1. The tokens name

2. The tokens symbol

3. The tokens decimal places

4. The tokens number in circulation

The number of decimal places I sthe smallest unit the token can have. Like 0.00001 or 0.001 or something like that. Remember,the smaller the number of decimal places,the more valuable the token is in the long run!

Also,you'll want to copy Bitcoin's model by making the token limited in number,but that's entirely up to you.

Next,copy and paste this code into Notepad or a text editor you like.

This code is courtesy of Tokenfactory. All rights reserved.

pragma solidity ^0.4.4;

contract Token {

    /// @return total amount of tokens
    function totalSupply() constant returns (uint256 supply) {}

    /// @param _owner The address from which the balance will be retrieved
    /// @return The balance
    function balanceOf(address _owner) constant returns (uint256 balance) {}

    /// @notice send `_value` token to `_to` from `msg.sender`
    /// @param _to The address of the recipient
    /// @param _value The amount of token to be transferred
    /// @return Whether the transfer was successful or not
    function transfer(address _to, uint256 _value) returns (bool success) {}

    /// @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from`
    /// @param _from The address of the sender
    /// @param _to The address of the recipient
    /// @param _value The amount of token to be transferred
    /// @return Whether the transfer was successful or not
    function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {}

    /// @notice `msg.sender` approves `_addr` to spend `_value` tokens
    /// @param _spender The address of the account able to transfer the tokens
    /// @param _value The amount of wei to be approved for transfer
    /// @return Whether the approval was successful or not
    function approve(address _spender, uint256 _value) returns (bool success) {}

    /// @param _owner The address of the account owning tokens
    /// @param _spender The address of the account able to transfer the tokens
    /// @return Amount of remaining tokens allowed to spent
    function allowance(address _owner, address _spender) constant returns (uint256 remaining) {}

    event Transfer(address indexed _from, address indexed _to, uint256 _value);
    event Approval(address indexed _owner, address indexed _spender, uint256 _value);
    
}



contract StandardToken is Token {

    function transfer(address _to, uint256 _value) returns (bool success) {
        //Default assumes totalSupply can't be over max (2^256 - 1).
        //If your token leaves out totalSupply and can issue more tokens as time goes on, you need to check if it doesn't wrap.
        //Replace the if with this one instead.
        //if (balances[msg.sender] >= _value && balances[_to] + _value > balances[_to]) {
        if (balances[msg.sender] >= _value && _value > 0) {
            balances[msg.sender] -= _value;
            balances[_to] += _value;
            Transfer(msg.sender, _to, _value);
            return true;
        } else { return false; }
    }

    function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
        //same as above. Replace this line with the following if you want to protect against wrapping uints.
        //if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && balances[_to] + _value > balances[_to]) {
        if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && _value > 0) {
            balances[_to] += _value;
            balances[_from] -= _value;
            allowed[_from][msg.sender] -= _value;
            Transfer(_from, _to, _value);
            return true;
        } else { return false; }
    }

    function balanceOf(address _owner) constant returns (uint256 balance) {
        return balances[_owner];
    }

    function approve(address _spender, uint256 _value) returns (bool success) {
        allowed[msg.sender][_spender] = _value;
        Approval(msg.sender, _spender, _value);
        return true;
    }

    function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
      return allowed[_owner][_spender];
    }

    mapping (address => uint256) balances;
    mapping (address => mapping (address => uint256)) allowed;
    uint256 public totalSupply;
}


//name this contract whatever you'd like
contract ERC20Token is StandardToken {

    function () {
        //if ether is sent to this address, send it back.
        throw;
    }

    /* Public variables of the token */

    /*
    NOTE:
    The following variables are OPTIONAL vanities. One does not have to include them.
    They allow one to customise the token contract & in no way influences the core functionality.
    Some wallets/interfaces might not even bother to look at this information.
    */
    string public name;                   //fancy name: eg Simon Bucks
    uint8 public decimals;                //How many decimals to show. ie. There could 1000 base units with 3 decimals. Meaning 0.980 SBX = 980 base units. It's like comparing 1 wei to 1 ether.
    string public symbol;                 //An identifier: eg SBX
    string public version = 'H1.0';       //human 0.1 standard. Just an arbitrary versioning scheme.

//
// CHANGE THESE VALUES FOR YOUR TOKEN
//

//make sure this function name matches the contract name above. So if you're token is called TutorialToken, make sure the //contract name above is also TutorialToken instead of ERC20Token

    function ERC20Token(
        ) {
        balances[msg.sender] = NUMBER_OF_TOKENS_HERE;               // Give the creator all initial tokens (100000 for example)
        totalSupply = NUMBER_OF_TOKENS_HERE;                        // Update total supply (100000 for example)
        name = "NAME OF YOUR TOKEN HERE";                                   // Set the name for display purposes
        decimals = 0;                            // Amount of decimals for display purposes
        symbol = "SYM";                               // Set the symbol for display purposes
    }

    /* Approves and then calls the receiving contract */
    function approveAndCall(address _spender, uint256 _value, bytes _extraData) returns (bool success) {
        allowed[msg.sender][_spender] = _value;
        Approval(msg.sender, _spender, _value);

        //call the receiveApproval function on the contract you want to be notified. This crafts the function signature manually so one doesn't have to include a contract in here just for this.
        //receiveApproval(address _from, uint256 _value, address _tokenContract, bytes _extraData)
        //it is assumed that when does this that the call *should* succeed, otherwise one would use vanilla approve instead.
        if(!_spender.call(bytes4(bytes32(sha3("receiveApproval(address,uint256,address,bytes)"))), msg.sender, _value, this, _extraData)) { throw; }
        return true;
    }
}


Now,replace everything that says "CHANGE THESE VARIABLES FOR YOUR TOKEN" to your own values.
Note that the number of decimal places you put correlates with your supply number.

Next,we test the token on Testnet.
Remember,  you'll need MetaMask if you don't have it already.

Once you've installed MetaMask, make sure you're logged in and you've set up the Ropsten test network.

Now you'll have to head over to the Solidity Remix Compiler.  It allows you to publish apps and tokens straight to the Ethereum Blockchain.

Copy and paste the code you modified previously into it's workspace.

Next,you go to the settings pane and select the latest release compiler version. Make sure you do not select the nightly build version,as this may ruin your hard work up to this point.

Also,uncheck 'Enable Optimization'.

Keep note of the Solidity version in use,as we'll need that later for our token.

Now,go back to the contract tab and hit 'create' under the name of the token you've started creating already.

What happens next is that MetaMask will send a popup asking you to pay for the transaction.

But recall that we're in the Ropsten net test network. So you won't be paying real ether.

So click submit,and it'll say 'contract pending' or something similar.

When it's ready,click on the date and it'll bring up your transaction in EtherScan.

Nice! We have just created our token and verified it on the Ethereum Blockchain!

Now to verify your token on an exchange will make this post unsightly and longer than it should be. So I'll just post that later today. Follow me if you want to see that,and stay tuned guys!

I'd really love to know if you tried this out and if you had any problems. Also, I'd love to see your tokens too! Comment down below for suggestions to the post or how your experience went.

Thanks for reading!

Guys this post took a lot to put together. It'd be really nice if you could leave a tip to support my work. Thanks,and to the moon!