rpip

Blockchain 101

Transactions are bundled into a Block. Blocks are then chained together into a "blockchain".

The way the chain of transactions and linked blocks are verified is what we call consensus algorithms. The consensus algorithm varies based on the incentives for the network operators/participants: Proof of Work, Proof of Stake etc.

Not every transaction has a recipient; in this case, this is a smart contract, which is basically a script deployed on the blockchain. In most cases, every blockchain transaction is a script but the execution/decryption of this script is tied to someone (recipient's) secret key. So for smart contracts, usually there is no recipient.

If you're not familiar with blockchains, I would advise that you don't dig into the technical implementation as it's quite complicated. Think of the datasets as regular databases tables connected by primary keys (in this case, fields). Focus on high-level constructs as below:

rpip

• http://neuralnetworksanddeeplearning.com/

rpip

Type theory

• http://okmij.org/ftp/ML/generalization.html
• http://smallshire.org.uk/sufficientlysmall/2010/04/11/a-hindley-milner-type-inference-implementation-in-python/
• http://okmij.org/ftp/Haskell/AlgorithmsH.html#teval
• https://github.com/tomprimozic/type-systems
• https://www21.in.tum.de/~nipkow/TRaAT/
• http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.65.7733&rep=rep1&type=pdf
• https://github.com/billpmurphy/hask
• http://canonical.org/~kragen/sw/dev3/term-rewriting.scm
• http://dev.stephendiehl.com/fun/006_hindley_milner.html

rpip

defprotocol Arithmetic.Add do
  @moduledoc """
  The Arithmetic.Add protocol is responsible for adding items.
  
  The only function required to be implemented is
  `__add__` which does the addition.
  """
  def __add__(left, right)
end

rpip

#!/usr/bin/env python
# USAGE: ./bin/passwd $password_prefix $dbpath $inventory_hostname -w

import sys, os
import string
import random

from datetime import datetime
from keepass import kpdb
from passlib.hash import sha256_crypt

rpip

x86 / IA-32 registers

• register is 32 bit wide

general registers

1. eax - accumulator
2. ebx - base
3. ecx - counter
4. edx - data
5. esi - source index

rpip

Notes on learning Emacs

basics

C-x f => open file

C-x s => save file

C-x C-w => save to a new file

rpip

Design

The new eDFS architecture is designed with the assumption that a single master system has a single point of failure. In a single-point-of-failure system, the failure of the master node will result in the termination of jobs and the loss of access to the entire system. This will not happen in a cluster where the master node is dynamically elected.

Therefore, each node in the cluster will be a self-containing full copy of eDFS. On startup, the system reads the cluster configuration and sets up the node cluster. All nodes start as followers; one node is elected to be a leader at the start. During normal operation, the leader maintains a heartbeat which allows the followers to detect if the leader fails or becomes partitioned.

rpip

defmodule DefStructPlusPlus do

  @doc """
   Macro for defining structs

   ## Examples

        defmodule Models do
          import DefStructPlusPlus

rpip

Papers, articles, blog posts, talks

• http://efcasado.github.io/riak-core_intro/
• http://basho.com/statebox-an-eventually-consistent-data-model-for-erlang-and-riak/
• http://dancres.github.io/Pages/
• http://www.erlang-factory.com/conference/SFBay2010/speakers/AndyGross
• http://thinkdistributed.io
• http://christophermeiklejohn.com/distributed/sycstems/2013/07/12/readings-in-distributed-systems.html
• http://christophermeiklejohn.com/crdt/2014/07/22/readings-in-crdts.html
• http://www.aosabook.org/en/riak.html