jFransham

Achieving warp speed with Rust

Contents:

• Number one optimization tip: don't
• Never optimize blindly
• Don't bother optimizing one-time costs
• Improve your algorithms
• CPU architecture primer
• Keep as much as possible in cache
• Keep as much as possible in registers

edsko

{-# OPTIONS_GHC -Wall -fno-warn-unused-binds #-}
{-# LANGUAGE CPP                 #-}
{-# LANGUAGE FlexibleContexts    #-}
{-# LANGUAGE IncoherentInstances #-}
{-# LANGUAGE RankNTypes          #-}
{-# LANGUAGE ScopedTypeVariables #-}

#if __GLASGOW_HASKELL__ >= 708
{-# LANGUAGE RoleAnnotations     #-}
#endif

UnkindPartition

{-# LANGUAGE
      FlexibleInstances,
      FlexibleContexts,
      UndecidableInstances,
      MultiParamTypeClasses,
      GADTs,
      ConstraintKinds,
      ScopedTypeVariables,
      TypeOperators
  #-}

notogawa

module FoldZipFusion {a b c d} {A : Set a} {B : Set b} {C : Set c} {D : Set d} (_⊕_ : A → B → B) (_⊗_ : C → D → A)where

open import Function
open import Data.List
open import Relation.Binary.PropositionalEquality

_⊛_ : {z : B} → C → (List D → B) → List D → B
_⊛_ {z} x k [] = z
_⊛_ {z} x k (y ∷ ys) = (x ⊗ y) ⊕ k ys

cartazio

PSA :

just use GHC for OSX https://ghcformacosx.github.io

the rest of these directions are preserved for historical purposes

TLDR version, if you have homebrew

xcode-select --install ; brew tap homebrew/versions ;   brew tap homebrew/dupes \

machty

Ember Router Async Facelift

The Ember router is getting number of enhancements that will greatly enhance its power, reliability, predictability, and ability to handle asynchronous loading logic (so many abilities), particularly when used in conjunction with promises, though the API is friendly enough that a deep understanding of promises is not required for the simpler use cases.

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

konn

module possibleworld

sig World {}
sig Atom {}
enum TruthValue { True, False }

sig KripkeFrame {
  worlds : some World,
  accessible: World -> World
}

sebfisch

{-# LANGUAGE TypeFamilies, TypeOperators, FlexibleContexts #-}

module GenericFoldableTraversable where

import Data.Monoid         ( Monoid, mappend, mempty )
import Data.Foldable       ( Foldable, foldMap )

import Control.Applicative ( Applicative, pure, (<*>) )
import Data.Traversable    ( Traversable, traverse )

NicolasT

Require Import Coq.Program.Basics.
Open Local Scope program_scope.

Definition id (A: Type) (e: A): A := e.

Module Type FUNCTOR.
  Set Implicit Arguments.
  Parameter F: forall (A: Type), Type.
  Parameter fmap: forall (A B: Type), (A -> B) -> F A -> F B.