bcherny

Notes on Martin Kleppmann's excellent Designing Data-Intensive Applications.

Chapter 1: Reliable, Scalable, and Maintainable Applications

• Data Systems
  • Dimensions to consider when thinking about data systems: access patterns, performance characteristics, implementations.
  • Modern data systems often blur the lines between databases, caches, streams, etc.
• Reliability
  • Systems should perform the expected function at a given level of performance, and be tolerant to faults and user mistakes
• Fault: One component of a system deviating from its spec. Prefer tolerating faults over preventing them (except for things like security issues). Faults stem from hardware failures, software failures, and human error (in a study, config errors caused most outages).

bcherny

terminal:

npm i --save-dev rollup rollup-watch rollup-plugin-typescript typescript typings
npm i -S react react-dom
./node_modules/.bin/typings install react react-dom --save
mkdir src dist
touch src/index.tsx

bcherny

business:

• A former Google exec on how to make tough decisions quickly
• Inside the deal that made Bill Gates $350,000,000
• Big Company vs. Startup Work and Compensation
• Analyzing 1.1 Billion NYC Taxi and Uber Trips, with a Vengeance
• Anatomy Of a Co-Branded Credit Card
• What People Who Want Innovations From Apple Just Don't Understand
• Employee #1: Apple
• What Got You Here Won't Get You There

bcherny

type None = {
  flatMap<U>(f: (value: null) => Option<U>): None
  getOrElse<U>(def: U): U
  isEmpty(): true
  map<U>(f: (value: null) => U): None
  nonEmpty(): false
  orElse<U>(alternative: Option<U>): Option<U>
}

type Some<T> = {

bcherny

// @see http://www.scala-lang.org/api/2.7.4/scala/Option.html

class Opt<A> {
  value: A | null

  // TODO: use constructor fn instead
  static from<A>(value: A | null): Opt<A> {
    return value == null ? None : Some(value)
  }

bcherny

Work in progress!

A little while ago I started using Typescript with the Angular 1.5 app I'm working on, to help ease the migration path to Angular 2. Here's how I did it. We'll go example by example through migrating real world code living in a large, mostly non-Typescript codebase.

Let's start with a few of the basic angular building blocks, then we'll go through some of the higher level patterns we derived.

Filters

Javascript

bcherny

type Effect<A> = {type: A}

interface IO<A> {}
interface NetworkIO<A> extends IO<A> {}

interface DOMMutation<A> {}
interface DOMAppend<A> extends DOMMutation<A> {}
interface DOMRemove<A> extends DOMMutation<A> {}

function request<A>(url: string): Promise<A> & Effect<NetworkIO<A>> {

bcherny

Let's say you have a Pull Request from myBranch to master with 3 commits, and you want them to appear as a single commit in master.

If you're merging on the command line, this is trivial:

git checkout master
git merge --squash myBranch
git commit

bcherny

graph mutation language (graphml)

             connection
          /              \
         
  Node 1 -----------------> Node 2
         \    edge 1
          \_________________> Node 3
 \ edge 2

bcherny

Implementations

• https://github.com/share/sharedb (by an engineer that worked on Google Docs OT)
• https://github.com/google/ot-crdt-papers
• https://www.codox.io/
• https://github.com/automerge/automerge

Important Concepts

• https://en.wikipedia.org/wiki/Conflict-free_replicated_data_type