Libraries are reusable contracts, they're not inherited

Solidity is the most popular programming language for building Ethereum dApps

Solidity compiles to bytecode that runs on the EVM -- Ethereum Virtual Machine

Solidity accepts multiple inheritance

Solidity accepts most of the primitive types except float number

Solidity accepts if/else and for/while statements

ABI (Application Binary Interface) is a JSON file that contains all the information (functions/params/return values) to interact with the smart contract

Smart contracts are immutable -- changes are not possible

An Ethereum Blockhain node implements the Ethereum Protocol and connects to other nodes -- it gives you access to the blockchain

TestRPC library simulates the Ethereum Network and is used to unit test smart contracts since mining is simulated and takes almost no time

MetaMask is a plugin for Chrome, can sign transactions and doesn't download the blockchain -- it's not a full node nor a light client

A transaction, when processed and validated by miners, go to the blockchain. It updates the state and costs ETH (gas)

Calls are local, read-only and free

Transactions cost ETH (gas to miners), it's a write operation, it changes the state of the blockchain

Transactions between Contracts are mined in the same block and returned all together

The Genesis block can be configured in a file named genesis.json or config.json

We can save the MNEMONIC pass phrase given by testrpc to always generate the same accounts: testrpc -m 'MNEMONIC'

Access to the blockchain is a normal REST interface that uses JSON

Web3.js is a JS library that makes it easier to interact with the Ethereum Blockchain

Ethereum Wallet is a dApp in pure HTML/JS that uses Web3.js to manage our accounts

geth is the the command line interface for running a full ethereum node implemented in Go

MIST is a 'browser' that uses Web3.js to interact with geth node

For Linux/MacOs we need to tell MIST where our private geth.ipc file is located

Remix is a web IDE for smart contract development

Truffle is a Smart Contract development framework that makes testing and deployment easy. It uses Mocha and Chai and works with Promises

ERC20 Tokens is a standard pattern for tokens in the Ethereum Network

ERC20 is a set of functions used as interface

An ICO is nothing else than deploying a smart contract

ICO - Initial Coin Offering is usually just a Smart Contract offering tokens

Truffle works with EthPM which is a Package Manager only for Ethereum, similar to NPM

address.transfer() is preferrable over address.send() since it delegates gas, exceptions and rolls back in case of any issue

You can only throw an exception in Solidity, there's no message and no catch block

assert() and require() are better ways of throwing exceptions

In case of failure, assert() consumes all the gas whereas require() returns all gas

Everything is public on the blockchain, even local and private variables

Random numbers depend on miners, be careful

Be careful with loops since it can consume all the gas available

Maximum call-stack in the Ethereum network is 1024

msg.sender vs tx.origin -- never use tx.origin for authorization to avoid unauthorized access

Restrict the amount of Ether or tokens -- just in case

mappings in Solidity are like hash tables

The value of a mapping can be of any type, except of a mapping

The key of a mapping can be anything except: mapping, dynamic array, contract, enum and struct

mapping(keyType => valueType) name

mapping: all values are initialized by default, it doesn't have a length, it's not possible to retrieve list of values or keys

Struct is like a Java class, but you don't need to use the new keyword to instantiate it

msg.sender is a global variable and its type is 'address'

In order to compare strings, they must be converted to bytes. A commonly used version of equals() is available on the internet

truffle test: uses Mocha, you need to required the contract as a JS object, all calls return promises, transactions don't need to be mined