retronym

object Low {
  def low = "object Low"
  def shoot = "missed!"
}

object High {
  def high = "object High"
  def shoot = "bulls eye!"
}

momania

import akka.amqp.AMQP._
import akka.amqp._
import akka.actor._
import java.util.concurrent.{TimeUnit, CountDownLatch}
import util.Random

object LoadBalancingDemo {

  def main(args: Array[String]) {

tschaub

import java.util.Arrays;
import java.util.List;

import org.mozilla.javascript.Context;
import org.mozilla.javascript.Function;
import org.mozilla.javascript.Scriptable;
import org.mozilla.javascript.commonjs.module.Require;
import org.mozilla.javascript.tools.shell.Global;

viktorklang

trait Enum { //DIY enum type
  import java.util.concurrent.atomic.AtomicReference //Concurrency paranoia

  type EnumVal <: Value //This is a type that needs to be found in the implementing class

  private val _values = new AtomicReference(Vector[EnumVal]()) //Stores our enum values

  //Adds an EnumVal to our storage, uses CCAS to make sure it's thread safe, returns the ordinal
  private final def addEnumVal(newVal: EnumVal): Int = { import _values.{get, compareAndSet => CAS}
    val oldVec = get

vybs

package com.linkedin.dust.renderer;

import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Reader;
import java.io.Writer;

import org.mozilla.javascript.Context;
import org.mozilla.javascript.JavaScriptException;

jboner

Latency Comparison Numbers (~2012)
----------------------------------
L1 cache reference                           0.5 ns
Branch mispredict                            5   ns
L2 cache reference                           7   ns                      14x L1 cache
Mutex lock/unlock                           25   ns
Main memory reference                      100   ns                      20x L2 cache, 200x L1 cache
Compress 1K bytes with Zippy             3,000   ns        3 us
Send 1K bytes over 1 Gbps network       10,000   ns       10 us
Read 4K randomly from SSD*             150,000   ns      150 us          ~1GB/sec SSD

analytically

def rateLimit(action: => String, subject: => String, maxRequests: => Int): Directive0 = {
  mapInnerRoute {
    inner => ctx =>
      val key = action + ":" + subject

      add(redis, key)
      val actionCount = count(redis, key, interval)

      if (actionCount >= maxRequests) {
        logger.warn("Rate limiting user '" + subject + "': exceeded max number of requests (" + maxRequests + ").")

ayosec

package foo.bar

import spray.routing._
import spray.http._
import spray.http.StatusCodes.Forbidden


// See https://developer.mozilla.org/en-US/docs/HTTP/Access_control_CORS

case class Origin(origin: String) extends HttpHeader {

ryanlecompte

import scala.collection.generic.CanBuildFrom
import scala.collection.immutable.MapLike
import scala.collection.mutable

/**
 * Immutable version of the PrefixMap demonstrated in the Scala collections
 * guide here: http://www.scala-lang.org/docu/files/collections-api/collections-impl_6.html
 * 
 * This version also has a smarter remove method (doesn't leave behind dead nodes with empty values)
 */

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?