puffnfresh

(def users [{:name "Brian" :age 22} {:name "Ben" :age 19}])

;; Takes a "path", returns a function that takes an "object" and
;; returns a "costate"
(defn lens [p]
  (fn [o]
    {:get (get-in o p)
     :set #(assoc-in o p %1)}))

(def myAgeLens (lens [0 :age]))

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

swannodette

;; based on core.logic 0.8-alpha2 or core.logic master branch

(ns sudoku
  (:refer-clojure :exclude [==])
  (:use clojure.core.logic))

(defn get-square [rows x y]
  (for [x (range x (+ x 3))
        y (range y (+ y 3))]
    (get-in rows [x y])))

frenchy64

; y has upper bound x, z has upper bound (Seqable y)
typed.core=> (ann foo (All [x [y :< x] [z :< (Seqable y)]] 
                           [x y z -> Any]))
[typed.core/foo (All [x [y :< x] [z :< (clojure.lang.Seqable y)]] (Fn [x y z -> Any]))]
typed.core=> (declare foo)
#'typed.core/foo

;cf = check-form
typed.core=> (cf (foo 2 2 [2]))
Any

jasonrudolph

About

This gist is a collection of my rough notes from Strange Loop 2012.

@jasonrudolph on Twitter | @jasonrudolph on GitHub

Did I Mention That They're Rough?

hugoduncan

No implementation of method: :lb of protocol: #'clojure.core.logic/IInterval found for class: clojure.lang.Keyword
java.lang.IllegalArgumentException

Restarts:
 0: [CONTINUE] Pass exception to program
 1: [ABORT] Abort request.
 2: [IGNORE] Do not enter debugger for this exception type
 3: [IGNORE-MSG] Do not enter debugger for this exception message
 4: [IGNORE-CATCH] Do not enter debugger for exceptions with catch location clojure.lang.LazySeq.*
 5: [IGNORE-LOC] Do not enter debugger for exceptions with throw location clojure.core.*

w01fe

(deftype FinalizeReporter [x]
  Object
  (finalize [this] (println "Finalizing" x))
  clojure.lang.IDeref
  (deref [this] x))

(defn leaker [n]
  (with-open [_ (reify java.io.Closeable (close [this]))]
    (let [s (map #(FinalizeReporter. %) (take 10 (iterate inc 0)))]
      (when (> n -1)

willurd

Each of these commands will run an ad hoc http static server in your current (or specified) directory, available at http://localhost:8000. Use this power wisely.

Discussion on reddit.

Python 2.x

$ python -m SimpleHTTPServer 8000

samn

#_(
Let's say you have a threadpool doing work that requires access to some shared resource.  
And this resource needs to be refreshed at times.  E.g. an OAuth bearer token that can expire or be revoked.

If this resource were expensive to refresh, or subject to rate limiting (OAuth tokens are often both) 
then it's desirable to refresh as little as possible.  
It's undesirable, however, to mix complicated synchronization code for updating the resource in 
with the business logic consuming it.

Enter the lock less monster, a lock free method for coordinating updates to a shared reference.  

swannodette

(ns async-test.throttle.core
   (:require [cljs.core.async :refer [chan close!o sliding-buffer]]
            [clojure.string :as string])
  (:require-macros
    [cljs.core.async.macros :as m :refer [go alts!]]))

(def c (chan (sliding-buffer 1)))
(def loc-div (.getElementById js/document "location"))

(.addEventListener js/window "mousemove"