hellerbarde

Latency numbers every programmer should know

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  =   3 µs
Send 2K bytes over 1 Gbps network ....... 20,000 ns  =  20 µs
SSD random read ........................ 150,000 ns  = 150 µs

Read 1 MB sequentially from memory ..... 250,000 ns = 250 µs

torgeir

Scala macros tutorial, using sbt

The following steps executed in order will;

• create the project file structure
• set the sbt version
• add the gen-idea sbt plugin (if you want to import your project into intellij)
• create an sbt build, that builds the macros project prior to the macrostest project (so the regex macro is usable in the macrostest project)
• create the macros project scala file
• create the macrostest project scala file

macintux

• https://ferd.ca/a-distributed-systems-reading-list.html
• http://the-paper-trail.org/blog/distributed-systems-theory-for-the-distributed-systems-engineer/
• https://github.com/palvaro/CMPS290S-Winter16/blob/master/readings.md
• http://muratbuffalo.blogspot.com/2015/12/my-distributed-systems-seminars-reading.html
• http://christophermeiklejohn.com/distributed/systems/2013/07/12/readings-in-distributed-systems.html
• http://michaelrbernste.in/2013/11/06/distributed-systems-archaeology-works-cited.html
• http://rxin.github.io/db-readings/
• http://research.microsoft.com/en-us/um/people/lamport/pubs/pubs.html
• http://pdos.csail.mit.edu/dsrg/papers/
• http://scalingsystems.com/2011/09/07/reading-list-for-distributed-systems/

squito

def getValMacro(c: Context)(s: c.Expr[Any]) : c.Expr[Any] = {
  import c.universe._
  val q"val $name = $value" = s.tree
  c.Expr(value)
}

def getVal(s: Any) = macro getValMacro

getVal{val x = 17}
error: exception during macro expansion: 

viktorklang

import scala.concurrent.duration._
import scala.concurrent.ExecutionContext
import scala.concurrent.Future
import akka.pattern.after
import akka.actor.Scheduler

/**
 * Given an operation that produces a T, returns a Future containing the result of T, unless an exception is thrown,
 * in which case the operation will be retried after _delay_ time, if there are more possible retries, which is configured through
 * the _retries_ parameter. If the operation does not succeed and there is no retries left, the resulting Future will contain the last failure.

acolyer

Internet Scale Services Checklist

A checklist for designing and developing internet scale services, inspired by James Hamilton's 2007 paper "On Desgining and Deploying Internet-Scale Services."

• http://mvdirona.com/jrh/talksandpapers/jamesrh_lisa.pdf

Basic tenets

• Does the design expect failures to happen regularly and handle them gracefully?
• Have we kept things as simple as possible?

nkpart

{-# LANGUAGE NoMonomorphismRestriction #-}
{-# LANGUAGE TemplateHaskell           #-}
{-# OPTIONS_GHC -fwarn-missing-methods #-}
module Err where

import Control.Lens
import Control.Monad.Error
import Control.Monad.Error.Lens

-- Here is a fairly typical situation, where we have low level errors in certain

eamelink

Recursion and Trampolines in Scala

Recursion is beautiful. As an example, let's consider this perfectly acceptable example of defining the functions even and odd in Scala, whose semantics you can guess:

def even(i: Int): Boolean = i match {
  case 0 => true
  case _ => odd(i - 1)
}

def odd(i: Int): Boolean = i match {

leonardofed

A curated list of AWS resources to prepare for the AWS Certifications

A curated list of awesome AWS resources you need to prepare for the all 5 AWS Certifications. This gist will include: open source repos, blogs & blogposts, ebooks, PDF, whitepapers, video courses, free lecture, slides, sample test and many other resources.

---

jdegoes

Applied Functional Programming with Scala - Notes

Copyright © 2016-2018 Fantasyland Institute of Learning. All rights reserved.

1. Mastering Functions

A function is a mapping from one set, called a domain, to another set, called the codomain. A function associates every element in the domain with exactly one element in the codomain. In Scala, both domain and codomain are types.

val square : Int => Int = x => x * x