Getting Up to Speed on Ethereum: Fundamentals, Smart Contracts, DApps, Tokens and the Ecosystem

This article provides a thorough overview of Ethereum for developers, starting with the basic idea of a distributed computer where each node executes bytecode (smart contracts) and stores results on an immutable blockchain.

It explains essential prerequisites such as understanding blockchain, Merkle trees, and having software‑engineering experience, and recommends watching introductory videos or reading the Ethereum white‑paper.

Smart Contracts are described as immutable code plus stored state, with each contract having a unique address. The article details how contracts are executed by every full node, why computation costs gas, and how gas limits prevent infinite loops.

Gas is the unit that measures the cost of executing operations; its price is market‑determined and higher‑priced gas gets prioritized by miners. Reading and writing state differ in cost, and several external articles are referenced for deeper gas analysis.

Distributed Apps (DApps) run on Ethereum by leveraging smart contracts for trust‑critical state while keeping heavy computation off‑chain (e.g., via IPFS or Golem). The piece outlines DApp client development, primarily using JavaScript (with mentions of Go and Rust), and lists popular client tools such as Meteor, Truffle, Embark, and libraries like web3.js.

DApp Browsers like Mist, Status, MetaMask, and Parity provide user‑friendly interfaces to interact with contracts, manage accounts, and switch networks (Mainnet, Ropsten, Kovan, Rinkeby). It also mentions third‑party node providers like Infura.

Ethereum Tokens are introduced as simple mappings of addresses to balances. The article covers basic token contracts, ERC‑20 and ERC‑23 standards (showing the transfer and balanceOf functions), and the motivation behind newer standards.

It differentiates protocol tokens (e.g., REP, GNT) that incentivize use of a protocol from app coins (e.g., SNT) that reward activity within a specific DApp.

Interaction with contracts can be done via command‑line clients (geth, parity) or programmatic libraries ( web3.js , Go abigen , ethereumjs‑testrpc). The article also mentions tools for contract deployment and testing such as Truffle and Embark, and provides links to tutorials.

For package management, ETHPM is introduced as a decentralized registry for reusable contract libraries.

The piece briefly surveys related protocols and projects: Whisper (messaging), DAOs, Aragon (decentralized organization), IPFS/FileCoin, Swarm, and various token‑exchange platforms (0x, Swap, Bancor). It also highlights security resources like ConsenSys’ best‑practice guide, bug‑bounty recommendations, and audit tools.

Programming languages for Ethereum are covered: Solidity (the most common, with an example contract shown below), LLL (a Lisp‑style low‑level language), and Serpent (Python‑like, now deprecated). Example snippets are preserved:

pragma solidity ^0.4.11;
contract BasicToken {
    mapping(address => uint256) balances;
    function transfer(address _to, uint256 _value) returns () {
        balances[msg.sender] = balances[msg.sender] - _value;
        balances[_to] = balances[_to] + _value;
    }
    function balanceOf(address _owner) constant returns (uint256 balance) {
        return balances[_owner];
    }
}

(seq
    (def 'node-bytes 0x00)
    (def 'owner    0x20) ; address
    (def 'set-node-owner    0x5b0fc9c3) ; setOwner(bytes32,address)
    (def 'get-owner (node)
        (sload (+ node owner)))
    // example only, not compile‑able
)

def register(key, value):
    # Key not yet claimed
    if not self.storage[key]:
        self.storage[key] = value
        return(1)
    else:
        return(0)  # Key already claimed

def ask(key):
    return(self.storage[key])

Finally, the article lists community resources, notable companies (ConsenSys, Zeppelin Solutions, Protocol Labs), and suggests ways to join the Ethereum ecosystem.