Krasnyanskiy

CvRDTs are as general as they can be

What are you talking about, and why should I care?

Now that we live in the Big Data, Web 3.14159 era, lots of people want to build databases that are too big to fit on a single machine. But there's a problem in the form of the CAP theorem, which states that if your network ever partitions (a machine goes down, or part of the network loses its connection to the rest) then you can keep consistency (all machines return the same answer to

Krasnyanskiy

About Cake Pattern

Below are the sources I took notes and hope to learn about Cake Pattern from.

Videos:

• SF Scala, Peter Potts: Cake Pattern in Practice
• Cake Pattern: The Bakery from the Black Lagoon
• Dead-Simple Dependency Injection

Krasnyanskiy

##Reactive System Design Links

#Articles and Papers

• The Reactive Manifesto: http://www.reactivemanifesto.org/
• https://en.wikipedia.org/wiki/Reactive_programming
• https://en.wikipedia.org/wiki/Functional_reactive_programming
• Design Methods for Reactive Systems book slides: http://booksite.elsevier.com/9781558607552/slides/slides.pdf
• Programming without a callstack Event Driven Architectures By G Hohpe: http://www.eaipatterns.com/docs/EDA.pdf
• On Distributed Memory Systems: http://blog.paralleluniverse.co/2012/07/10/on-distributed-memory/
• Disruptor source code, papers and articles: https://lmax-exchange.github.io/disruptor/

Krasnyanskiy

class A
class A2 extends A
class B

trait M[X]

//
// Upper Type Bound
//
def upperTypeBound[AA <: A](x: AA): A = x

Krasnyanskiy

// Reduction: We can sum all the elements
// with the usual recursive schema
def sum(xs: List[Int]): Int = xs match {
  case Nil     => 0
  case y :: ys => y + sum(ys)  
}

// But this can be abstracted out using 'reduceLeft'
// That will perform these operations LINKING to the left
def sum(xs: List[Int]) = (0 :: xs) reduceLeft ((x, y) = x + y)

Krasnyanskiy

L1 cache reference                  0.5 ns
Branch mispredict                   5 ns
L2 cache reference                  7 ns
Mutex lock/unlock                   25 ns
Main memory reference               100 ns
Compress 1K bytes with Zippy        3,000 ns
Send 2K bytes over 1 Gbps network   20,000 ns
Read 1 MB sequentially from memory  250,000 ns
Round trip within same datacenter   500,000 ns
Disk seek                           10,000,000 ns