Stuart Halloway

Narcissistic Design: 10 Steps to Complex Code and Job Security

The software industry changes rapidly, but you can protect yourself
from these changes by creating code that is complicated enough that
only you can maintain it.

Generative Testing

Traditional automated testing approches combine input generation, execution, output capture, and validation inside the bodies of single functions. Generative testing approaches gain expressive power by isolating these steps.

Simulation Testing with Simulant

Simulation allows a rigorous, scalable, and reproducible approach to testing. The separation of concerns, and the use of a versioned, time-aware database, give simulation great power. This talk will introduce simulation testing, walking through a complete example using Simulant, an open-source simulation library.

Clojure in 10 Big Ideas

The key to understanding Clojure is ideas, not language constructs.
In this talk, we will approach Clojure via 10 Big Ideas.

core.async

The goal of core.async is to decouple producers and consumers of
information in software, without dictating specific thread or blocking
semantics, and without introducing callback hell. Also, to do all of this
as a library, portable anywhere you can run a dialect of Clojure.

Queues are a powerful tool for decoupling software
programs. Unfortunately, platforms that have powerful queueing
libraries (e.g. Java) may require blocking threads on the ends of the
queue. And the world's biggest platform (JavaScript in the browser)
doesn't even have queues or threads.

core.async builds upon the work done with Communicating Sequential
Processes,
and provides:

• facilities for independent threads of activity, communicating via
  queue-like channels
• both real threads and shared use of thread
  pools (in any combination), as well as ClojureScript on JS engines

Datomic For The 96 Percent

Traditional SQL databases have great power, via ACID transactions and
via a declarative, logic-based query language (SQL). But SQL
databases encounter two problems on the web:

• SQL databases have a rigid information model, and typically a rigid
  deployment model. This rigidity creates impedance mismatches both with
  development languages and with emerging cloud strategies.

• SQL databases struggle with the extremely high write volumes that
  characterize the top four percent of the web, e.g. the Amazons,
  Facebooks, etc.

Much of the effort of the NoSQL movement has gone to solve the second
problem, the problem of the four percent, under the mantra “web scale”.
Datomic solves the first problem – with a flexible information model
and a deployment model suited to the dynamic web, and to the cloud.

Datomic is for the ninety-six percent.