Chris McDevitt minimal

Schema

I think of Schema as a runtime contracts library (I believe it does coercion and validation, but they seem related to me).

Pros

small barrier to entry, thus immediately useful
- just add a contract/coercion to a function and you're off
can manipulate contracts as regular clojure data
documentation

Clojure Destructuring Tutorial and Cheat Sheet

(Related blog post)

Simply put, destructuring in Clojure is a way extract values from a datastructure and bind them to symbols, without having to explicitly traverse the datstructure. It allows for elegant and concise Clojure code.

Vectors and Sequences

EuroClojure 2014, Krakow

Fergal Byrne, Clortex: Machine Intelligence based on Jeff Hawkins’ HTM Theory

@fergbyrne
HTM = Hierarchical Temporal Memory
Slides

big data

big data is like teenage sex
- noone knows how to do it
- everyone thinks everyone else is doing it

The introduction to Reactive Programming you've been missing

(by @andrestaltz)

This tutorial as a series of videos

If you prefer to watch video tutorials with live-coding, then check out this series I recorded with the same contents as in this article: Egghead.io - Introduction to Reactive Programming.

	-- Playing around with persistent vectors in Purescript
	-- Imitiates the interface from Data.Array, but uses Mori.js persistent
	-- vector implementation e.g. to avoid copy-on-write etc.

	module Data.Vector where
	import Data.Maybe

	-- LOL I have no idea what I'm doing, but reverse engineering from the
	-- JS output, this actually seems to work
	foreign import data Mori :: *

	(comment ; Fun with transducers, v2

	;; Still haven't found a brief + approachable overview of Clojure 1.7's new
	;; transducers in the particular way I would have preferred myself - so here goes:

	;;;; Definitions
	;; Looking at the `reduce` docstring, we can define a 'reducing-fn' as:
	(fn reducing-fn ([]) ([accumulation next-input])) -> new-accumulation
	;; (The `[]` arity is actually optional; it's only used when calling
	;; `reduce` w/o an init-accumulator).

	(ns chords.core
	(:refer-clojure :exclude [==])
	(:require [clojure.core.logic :refer :all]
	[clojure.core.logic.fd :as fd]
	[clojure.core.logic.pldb :as pldb]
	[fipp.edn :refer (pprint) :rename {pprint fipp}]))

	(pldb/db-rel note-name ^:index p)
	(pldb/db-rel octave ^:index p)
	(pldb/db-rel note ^:index p1 ^:index p2)

	;;; Changes:
	;;; - Annotate the parameter of the lambda given to filter. This was the cause of the error.
	;;; - Change the last parameter of lookup-by from Seq to Seqable to allow it to work with vectors.
	;;; - Replace (IFn [a -> b]) with [a -> b]. They're equivalent.

	(t/ann lookup-by (t/All [a b]
	[b [a -> b] (t/Option (t/Seqable a)) -> (t/Option a)]))

	(defn lookup-by
	"Convenience filter. Returns the first item in coll where (= value (lookup-fn item))"

	(doseq [n (all-ns)
	[_ v] (ns-map n)
	:when (and (var? v) (fn? @v))]
	(alter-var-root v (fn [original]
	(fn [& args]
	(try (apply original args)
	(catch Exception _))))))

	(require '[clojure.core.async :as a])

	(def xform (comp (map inc)
	(filter even?)
	(dedupe)
	(flatmap range)
	(partition-all 3)
	(partition-by #(< (apply + %) 7))
	(flatmap flatten)
	(random-sample 1.0)