abp

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

a simple git branching model (written in 2013)

This is a very simple git workflow. It (and variants) is in use by many people. I settled on it after using it very effectively at Athena. GitHub does something similar; Zach Holman mentioned it in this talk.

Update: Woah, thanks for all the attention. Didn't expect this simple rant to get popular.

Object-orientation

There are many articles and discussion threads on the web regarding the nature of Object-oriented (OO) programming. Most of them come at the question from a Programming Language Theory (PLT) perspective, attempting to assert a formal definition of OO programming and objects. I'm not going to do that here. Instead, I'm going to write about objects from an implementation perspective, approaching the subject first from below and then from above.

	(ns om-data.core
	(:require [om.core :as om :include-macros true]
	[om.dom :as dom :include-macros true]
	[datascript :as d]))

	(enable-console-print!)

	(def schema {})
	(def conn (d/create-conn schema))

	var dom = React.DOM;

	var App = React.createClass({
	getInitialState: function() {
	return { todos: [] };
	},

	addTodo: function() {
	this.setState(update(this.state) {
	todos.push({ value: 'hello' });

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

	(defn not-membero
	[x l]
	(conde [(emptyo l)]
	[(fresh [head tail]
	(conso head tail l)
	(!= head x)

	;; Reimplementation of Java's (.split Pattern) to be zero-allocation, similar
	;; to JDK 8 splitAsStream
	;; Discards trailing ""
	;; respects `clojure.core.reduced`

	(defn split-string
	[^CharSequence s ^java.util.regex.Pattern re]
	(reify clojure.core.protocols/CollReduce
	(coll-reduce [_ f init]
	(let [m (re-matcher re s)

	(ns async-examples.load-balancer
	(:require [clojure.core.async :refer :all]))


	;; Let's assume we have a DB, and it holds the following pairs of name/ages

	(def db-store
	{:john 42
	:amy 33
	:jill 3

	(require [clojure.core.async
	:refer [chan dropping-buffer thread <!! >!! >!]])

	(defmacro try! [ch & body]
	`(let [ch# ~ch]
	(try ~@body (catch Throwable t#
	(when ch# (>! ch# t#))))))

	(defmacro try!! [ch & body]
	`(let [ch# ~ch]

	(defn take-until
	([pred-sentinel in] (take-until pred-sentinel in (chan)))
	([pred-sentinel in out]
	(go (loop []
	(if-let [v (<! in)]
	(do
	(>! out v)
	(if-not (pred-sentinel v)
	(recur)
	(close! out)))