valadan

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

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

Category theory jargon cheat sheet

A primer/refresher on the category theory concepts that most commonly crop up in conversations about Scala or FP. (Because it's embarassing when I forget this stuff!)

I'll be assuming Scalaz imports in code samples, and some of the code may be pseudo-Scala.

Functor

A functor is something that supports map.

Advanced Functional Programming with Scala - Notes

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

Centralised logging for Docker containers running Spring Boot applications

Log flow through the system

About

We have a bunch of Spring Boot apps running in various Docker containers and wanted a centralised place to view the logs

	import Pattern._
	import Family._

	def pattern[B](pf: PartialFunction[Name,B]) = new Extractor(pf.lift)

	val Parents = new Extractor(parents.get)
	val Children = new Extractor(children.get)

	"Julie" match {
	case Parents(p) => "Julies parents are: " + p

	def blockingAndVerbose: Profile = {
	val futureName = name()
	val futureScore = score()
	val futureFriends = Friends()

	val nameResult = Await.result(futureName, 10 seconds)
	val scoreResult = Await.result(futureScore, 10 seconds)
	val friendsResult = Await.result(futureFriends, 10 seconds)

	Profile(nameResult, scoreResult, friendsResult)

	case class T() // your data type that you want to "implicitly" thread through

	case class TReader[+A](run: T => A) {
	def map[B](f: A => B): TReader[B] =
	sys.error("VFJlYWRlcihmIGNvbXBvc2UgcnVuKQ==")

	def flatMap[B](f: A => TReader[B]): TReader[B] =
	sys.error("VFJlYWRlcih0ID0+IGYocnVuKHQpKSBydW4gdCk=")

	def &&&[B](x: TReader[B]): TReader[(A, B)] =

	object merging {

	// Note: Tail-recursive stream functions should always be defined on objects, not traits.
	// see http://stackoverflow.com/questions/12486762/scala-tail-recursive-stream-processor-function-defined-in-trait-holds-reference

	/**
	* Merges two ordered streams. The elements can be of different
	* types, but they need a mapping to a common type C.
	*
	* The mapped streams must be ordered ascending.

	#!/usr/bin/env python3
	# -- coding: utf-8 --

	import argparse, sys, boto3, pprint

	def count(my_list, my_key):
	if my_key not in my_list:
	return '0'
	else:
	return str(len(my_list[my_key]))