In this talk, Chris will use a combination of the two kinds of keyboard to explain scales, tuning systems and some differences between traditional and algorithmic musical performance.

https://github.com/ctford/leipzig

https://github.com/ctford/dueling-keyboards

We'll pay special attention to the myriad of features introduced in the upcoming CIDER 0.10 (which should be out by the time of the talk) and our plans to support both nREPL and the new Clojure 1.8 socket REPL at the same time. We'll also examine the possibility of adding refactoring support directly into CIDER.

Check out CIDER Project here: https://github.com/clojure-emacs/cider

But the most complicated part of our systems often suffer with the weakest tools. In this talk we'll look at a modular, scalable architecture for frontend apps - one that uses the design insights of functional programming and the solid foundation of Clojure to stay sane in the murky realm of the browser.

Ernestas Lisauskas - Garden: CSS in Clojure and ClojureScript

David Humphreys - Testing times in Clojurescript

Dave Snowdon - Seeing With Clojure

For newer team members, and those who haven't worked on a given piece of code for a while, it's sometimes difficult to understand the structures flowing through the functions. In Clojure, associative structures are often gradually built up as they are passed between functions, and it's difficult to know what they might contain at any point without tracing them through these functions.

Mark will describe the team's experiences of using tests, Prismatic Schema, and core.typed in an attempt to alleviate this problem.

The talk serves as a REPL-friendly introduction to the concepts of recursion schemes, covering catamorphisms, anamorphisms and hylomorphisms. It also shows how some common algorithms are, in fact, special cases of hylomorphisms.

The talk will not involve types.

First they will explore how to write a phone book app with the help of Compojure. After that they will have a look at how to use Yada to address the same problem, and discuss how Yada differs from the Compojure solution and what the advantages/disadvantages are of the two solutions.

Duct 1 is designed to prevent complexity later in a project's life, by being zealous about simplicity earlier on. This talk will go over the central ideas and design of Duct, and how to use it to build an example application.

Forty years later McCarthy published another paper with his incomplete vision for a language for 2015. Little did he know then that on the other side of the country Okasaki had just published the missing piece to his puzzle. In this talk we’ll complete the puzzle he left for us and find out if McCarthy really did end up inspiring the guiding lights for an entire century of computing history.

After doing so we’ll explore what these ideas would mean for computing. We’ll look at some projects, such as Unison, EClj, Oxcart and Kiss, which are building on this vision. Understand why Haskell is a mutable language. Explore how it will change our interactions with computers; how development, experimentation and deployment will change forever and finally how it ends up having a killer feature we wished we never needed.

The talk will go over some of the problems that we faced and that drove us to this architecture, and how Clojure enabled us to rapidly change and evaluate different approaches.

Glen Mailer - Are you afraid of dependencies?

Alejandro Gómez - Cats & Monads

Frankie Sardo - Reevaluating Pedestal

In this talk, Hans will present some real-work experience with using Datomic in two different scenarios from the perspective of a programmer.

This talk will explore challenges encountered while developing with Clojure, and the process of designing and refining a lightweight, testable basis for rapid iteration and prototyping. Through rigorous adherence to modularity, without losing sight of the system as a whole, I will demonstrate how we can rapidly build a network of modules from simple functions.

From this early release we will take a look at possible future directions for asystant, including further visualisation, monitoring and verification.

https://github.com/monteithpj/asystant

In this talk we will share the reasons for this choice, the benefits from our previous architecture as well as an overview of all the components of our platform: stream processor, API server, and a real time analytics web application.

This talk will also look at how Clojure might fit into a learner's programming education, and how to maximise the outcomes so that workshop attendees become active members of their local Clojure programming community.

This talk will explore how Funding Circle is moving its existing Ruby stack into the brave new world of Clojure and Kafka. William will talk both about process - how do you shift a large development team to another language? - and technology, explaining why Clojure was their weapon of choice.