ssedano

new host
set name = "b"
set hardware-address = f0:4d:a2:fd:2d:74
set ip-address = 20:02:ca:fe:00:00:00:00:00:00:00:00:00:00:00:07,20:02:ca:fe:00:00:00:00:00:00:00:00:00:00:00:08
set hardware-type = 1
set statements = "option dhcp6.vendor-opts 6f:70:74:69:6f:6e;"
create

Haskell

yonedaLemma = Iso (flip fmap) ($ id)

copumpkin

module Primes where

open import Level using (_⊔_)
open import Coinduction
open import Function
open import Data.Empty
open import Data.Unit
open import Data.Nat
open import Data.Nat.Properties
open import Data.Nat.Divisibility

earthgecko

#!/bin/bash
# bash generate random alphanumeric string
#

# bash generate random 32 character alphanumeric string (upper and lowercase) and 
NEW_UUID=$(cat /dev/urandom | tr -dc 'a-zA-Z0-9' | fold -w 32 | head -n 1)

# bash generate random 32 character alphanumeric string (lowercase only)
cat /dev/urandom | tr -dc 'a-z0-9' | fold -w 32 | head -n 1

MohamedAlaa

tmux shortcuts & cheatsheet

start new:

tmux

start new with session name:

tmux new -s myname

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

pchiusano

/** GADTs in Scala and their limitations */

/** Background: what is an algebraic data type (ADT) ? 
  * ADT: (possibly) recursive datatype with sums and products
  * In scala - a trait with case classes (case class is product, subtyping is sum) 
  */

/** Motivation: untyped embedded DSL doesn't prevent nonsensical expressions */
sealed trait Expr { 
  def apply(other: Expr) = Ap(this, other)

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