Here it is! These are the sessions that the Programme Committee has chosen after carefully balancing the Perfection Game feedback and lots (and lots!) of discussion. We are thankful to all and a bit sad we couldn’t accommodate even more sessions but extremely happy with the programme that emerged.

Really looking forward to it!

P.S.: all the sessions are 40 minutes + 5 for Q&A apart from the keynotes that are 50 minutes + 10 for Q&A

Monday 14th

8:00-8:50 Registrations + Coffee
8:50-9:00 Opening
9:00-10:00 Keynote: States and Nomads: Handling Software ComplexityZach Tellman
10:00-10:45 Evolving Life In The BrowserTom Hall
10:45-11:30 Build Your Own Lisp for Great JusticeBodil Stokke
11:30-11:45 Coffee break
11:45-12:30 Liberator – free your data with RFC 2616Philipp Meier
12:30-13:15 Creative MachinesJoseph Wilk
13:15-14:45 Lunch
14:45-15:30 (assert (= (+ quadrocopter motion-detector core.async) :awesomeness))Jarppe Lansio
15:30-16:15 Functional 3D Game DesignJames Reeves
16:15-16:30 Coffee Break
16:30-17:15 Common Clojure SmellsJen Smith

Tuesday 15th

8:30-9:00 Coffee
9:00-10:00 Keynote: Narcissistic DesignStuart Halloway
10:00-10:45 Using Clojure to Serve The Internet of ThingsPaul Bellamy & Martin Trojer
10:45-11:30 Newspaper Massacre
Clifton Cunningham & Jon Pither
11:30-11:45 Coffee break
11:45-12:30 (into reduce transient)Michał Marczyk
12:30-13:15 MegarefsChristophe Grand
13:15-14:45 Lunch
14:45-15:30 Lightning talks:
1) In search of workflow nirvana: Clojure, Emacs, Org, and literate programming
2) Lithium: a small Clojure-inspired Lisp on the bare metal
3) Templating In Clojure
Kai WuDaniel JanusRyan Greenhall
15:30-16:15 Meta-eX: How to live code your own bandSam Aaron
16:15-16:30 Coffee Break
16:30-17:15 Enterprise integration with ClojureFrazer Irving
17:15-18:00 A Perfect Storm for Legacy MigrationRyan Lemmer

Keynote: Narcissistic Design – (go back up)

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.

Of course you should not engage in obvious bad practices. The good news is that you don’t have to. You can follow idiomatic industry practice and stay buzzword compliant with the latest trends, while quietly spreading complexity throughout systems. Better yet, the symptoms will show up not in your own code, but in other code that uses your code, directly or indirectly. You will be a hero as you lead larger and larger teams burning the midnight oil to keep systems alive.

Practice these principles, and your code will have an infectious complexity that guarantees you will always be needed to maintain it.

Use OO, and don’t forget those setter methods!
Prefer APIs over data.
Start with DSLs.
Always connect (and never enqueue).
Create abstractions for information.
Use static typing across subsystem boundaries.
Put language semantics on the wire.
Write lots of unit tests.
Leverage context.
Update information in place.

Evolving Life In The Browser – (go back up)

We have an obscene amount of computing power in our pockets, on our laps and at our desks. With the rise of the web browser as a platform, tooling like clojurescript making it a better place to write complex applications and recently WebRTC letting clients talk directly to each other, the time is right to harness them as a distributed system and do some real science.
We will look at the eerie effectiveness of Genetic Algorithms, why Lisp is a good fit for Genetic Programming and how Artificial Life helps us understand biological evolution, while evolving life in our browsers.
I will describe Enlil (Enlil’s Not Life In Lisp), an alife simulation in Clojure and clojurescript where the lifeforms themselves are Lisp programs competing to survive.
The talk touches on complexity theory, cellular automata, toy universes and should be a lot of fun, bring all your devices and be prepared for them to get warm.

Newspaper Massacre – (go back up)

In March 2013 at the worlds biggest online newspaper, we set about rewriting the public facing website in Clojure.

This is the story.

* We’ll explore the motivations of Clojure vs Node vs Ruby vs what-was-there-before-look-away-it-was-horrible.

* Lightweight architecture built on top of ElasticSearch, Zookeeper & Avout, Mustache, Hiccup, Riemann.

* Event-based data distribution strategy using Datomic, Riac and ElasticSearch

* Testing strategies – A/B regression against the old website, Datomic and Simulant when the ‘B’ goes away

* How we use Enlive in a separate service to manipulate the HTML coming from the front-end to feed it into the CMS

* How we scaled up a team to 10 devs in a relatively short space of time

* Problems that exist in the medium term (what next for the team, Clojure at the Daily Mail?)

* We will touch on Clojurescript vs straightforward Javascript running on Node

Liberator – free your data with RFC 2616 – (go back up)

Liberator is a clojure library to implement a http resource
correctly. I will show that HTTP is more than GET and POST and how
liberator enables a developer to unleash the full power of HTTP:
content-negotation, conditional requests, and so on. Doing so enables the scalability
promises of the RESTful architectural style. Liberator is especially
useful to expose existing data from your application and to enable others to
build stuff with it.

I will also show how the principles of functional programming and declarative programming free the developer from the complicated details of the HTTP protocol. This includes the creation of a DSL for the implementation of liberator’s decision graph, the threading of the context through the steps of the execution and liberators capability to record the single steps and expose the intermediate execution state in the trace ui.

If there is enough time I will give a quick peek into how the graph svg is extracted from liberator’s source code. It will keep this part short and only want to encourage the audience to use this kind id meta-programming and meta-documentation in their own projects.

Functional composition – (go back up)

Music theory is one of the most naturally elegant and functional domains. It’s a perfect fit for Clojure, which is why the Overtone audio environment makes hacking sound so much fun.

Chris will start with the basic building block of sound, the sine wave, and will gradually accumulate abstractions culminating in a canon by Johann Sebastian Bach.

By the end you should agree that anyone who’s a developer is a musician too – even if they don’t know it yet.

(assert (= (+ quadrocopter motion-detector core.async) :awesomeness)) – (go back up)

Do you own an attack helicopter (can be substituted with AR.Drone)? Do you have a hand? Can you move it? Know how to program in Clojure? You’re in luck, because in this presentation Jarppe Lansio from Metosin Ltd shows you how you can combine them to impress your colleagues, terrify your pets and annoy your neighbours. Covered topics include how you can process multiple asynchronous input sources (including a live video) using core.async and use the combined data to control the quadrocopter in real time. All done with live coding Clojure. Live demo, safety not guaranteed, bring your own helmets and safety goggles.

So the key points are:
* multiple realtime input sources
* using core.async
* generating weird AT-commands using clojure Protocols
* processing h.264 video stream
* visualise all the things
* live demo

Creative Machines – (go back up)

Alan Turing set out to find the answer to the question: “Can machines think?”.
Part of his question targeted creativity and the idea could machines write poetry?

Focusing on music using Clojure and Overtone we will explore the question of machine creativity.
We will start our journey down the path of discovering a new generation of AI artists born through code.
We will look into their hearts and brains examining different algorithms/techniques and their effectiveness at exhibiting creativeness.

Can machines be creative?

Functional 3D Game Design – (go back up)

This talk covers how one might approach the problem of designing a 3D game using a functional, data-orientated approach. There will be a brief overview of how 3D games are structured, then a discussion on how suitable caching strategies can be used in place of mutable objects to achieve sufficient performance, and finally a comparison between callbacks vs. reactive programming for event handling.

These concepts will be demonstrated, at least in part, using an in-progress minecraft-like game engine (written in Clojure). I’ll also prepare some backup slides and screenshots in case things go wrong with the engine on the day.

Common Clojure smells – (go back up)

Code smells are indicators and anti-patterns in code that tell you something is wrong: code which may be highly coupled, difficult to change and understand. Code smells in other languages like Java are well understood and documented but for many of us starting to write our first production Lisp, Clojure smells are not that apparent. In this talk, I explain why we should start to think about Clojure smells and describe some of the patterns that might make the list. Warning: may contain depictions of unsightly code and offensive parentheses.

Keynote: States and Nomads: Handling Software Complexity – (go back up)

We routinely make systems that exceed our ability to understand completely. Instead, we explore pieces at a time – small local details or large global abstractions, but rarely both at once.

But software is far from unique in this; we’re surrounded by physical and social systems that are too big for any one person to understand. This talk is an exploration of how other, older disciplines have approached these problems, and what we as software engineers can learn from them.

Using Clojure to Serve The Internet of Things – (go back up)

Many believe that “The Internet of Things” is the largest technology market opportunity “ever”. It promises to revolutionize the relationship between people and their world. You can now get a 32bit computer in a package that less than 2mm square, that connects to the internet and cost less than a dollar!

The future myriad of IoT devices will need to be managed and monitored and will produce vast amounts of data.

This talk will give some example of how Xively uses Clojure to provide the platform, tools and services that simplify and accelerate the creation of compelling connected offerings.

The talk will include a demo where “some kind of device” to connects to the Xively cloud! :)

Build Your Own Lisp for Great Justice – (go back up)

Implementing a toy Lisp interpreter is practically a rite of passage for the budding computer scientist. This hallowed tradition is described in detail in “Lisp in Small Pieces,” the seminal work on the making of Lisps, but everybody loves a tl;dr, so let’s do the 40 minute executive summary.

We’ll charge at high speed through the following topics, with Clojure code to follow along with as we go (because there’s no better language for implementing a Lisp than another Lisp):

* Parsing: turning text files into ASTs
* Fundamental Lisp datatypes
* McCarthy’s elementary functions
* Evaluating Lisp code
* Lambdas and lexical scope
* Your friend, the state monad
* Beyond Lisp: pattern matching and type systems

When we’re done, you’ll be ready to go forth and fill the world with Lisps of all shapes, colours and Greenspun violations for Great Justice. Also, it’ll be good fun.

(into reduce transient) – (go back up)

Clojure’s elegance and the good performance of idiomatic Clojure code rely on a carefully designed set of abstractions. These are all ultimately centred around the core suite of persistent data structures and such concepts as reducibility (for fast processing of large data sets) and isolated use of mutation in implementing outwardly functional APIs (inside the data structures and in exposed functionality such as transients). This talk will investigate the core Clojure abstractions involving its persistent collection types; their individual contributions to the goals of making Clojure code elegant and performant; and finally, the way in which they fit together to produce a coherent whole greater than the sum of its parts. Along the way we will learn how to make a new data structure participate in the core abstractions, both on the JVM and in ClojureScript, using core.rrb-vector as an example.

Megarefs – (go back up)

Megarefs are a new kind of reftype participating in STM transactions while allowing concurrent associative modification. The promise is to not have to decide upfront the granularity of refs: you just put the whole world in a (mega) ref and adjust knobs until you get the concurrency you expect.

This talk details the current implementation and its limitations.

In search of workflow nirvana: Clojure, Emacs, Org, and literate programming – (go back up)

It’s been almost 30 years since Donald Knuth proposed literate programming (LP) as a better way to build software, yet like the venerable Lisp itself, LP has not yet become an industry norm, despite clear and good reasons to deserve it. In this presentation, increasingly complex and larger examples of LP will be shown using the modern tool combination of Emacs, Org mode, org-babel, nREPL, and Clojure/CLJS. Instructions and github files will be setup in advance to encourage audience learning and immediate experimentation.

Lithium: a small Clojure-inspired Lisp on the bare metal – (go back up)

This talk will introduce Lithium, a toy implementation of a Clojure-inspired Lisp for the x86 bare metal, written in Clojure. It’s not practical like Clojure; rather, it’s meant to be an educational tool, to learn about the innards of x86 and implementing Lisp. I’ll talk about how these goals influenced the design and the priorities of Lithium, and which parts of Clojure were easy and which were hard to implement. I will describe my future plans for Lithium.

I’ll also touch a philosophical chord, asking the questions “What really _is_ Clojure? What are the essential parts of the language? What is it that makes Clojure Clojure?” I’ll try to give my own answers to these questions, and explain how they were influenced by Lithium.

Templating In Clojure – (go back up)

Many web development platforms have a clear winner when it comes to templating. Things are less clear cut within Clojure’s eco-system and many are left wondering what to use for templating
Here at uSwitch we have been doing increasingly more web development in Clojure. We will share our templating journey covering: Hiccup, Enlive, Enlive combined with our own haml parser (hamilito) and finally clj-jade (our Clojure wrapper around jade4j).
The goal of this talk is too review the available options, allowing attendees to select the most appropriate approach for their particular situation. The pros and cons of each approach will be outlined alongside commentary of where we feel the sweet spot for each library lies.

Meta-eX: How to build your own Clojure powered band – (go back up)

Meta-eX is currently the only Clojure-powered band in the world. Taking full advantage of Overtone, we code all our gigs hacking raw Clojure into Emacs buffers live on stage. For the past year, we have been actively developing our performance software, Ignite, to drive our live performances. Meta-eX is therefore more than just a band, it’s also a suite of Clojure namespaces. Our approach isn’t to teach computers how to be creative, it’s to harness computational power to enhance and empower the most powerful creative force on earth – our minds.

In this talk we will explore the many design and engineering challenges faced during the development of Ignite. We performance test our software in a new light – through real gig performances. We therefore have very demanding requirements regarding the interactivity, reliability, latency, and ergonomics of the API to support the resolution of decisions and actions required for live performances, all of which will be covered with examples.

The goal of this talk is to stop Meta-eX being the only Clojure-powered band. Expect to come away from the talk with the skills and desire to start jamming with your friends!

Enterprise integration with Clojure – (go back up)

Systems integration, as exemplified by the tech bookshelp mainstay *Enterprise Integration Patterns*, is a well understood problem space, but no clear frontrunner(s) exist in the clojure ecosystem for distributed message driven architectures.

In this talk we will expound upon our own understanding of what enterprise integration work truly entails, exploring the concepts of systems integration, distributed systems orchestration and business rule capture. We will examine classic EIP providers such as Mule ESB and Apache Camel through the lens of the Daily Mail’s experience with these products. And we will challenge the assumptions about systems integration best practice that shape the development landscape.

Throughout this talk we will show side by side comparisons of some popular and some less popular Java and Clojure integration and messaging frameworks (see below), highlighting the strengths and weaknesses of each, as well as showing how to create powerful combinations between them. And we ask the questions: Have we evolved beyond the concepts of enterprise integration as it is understood today?

Projects include:

- Mule ESB
- clj-camel-holygrail
- core.async
- Twitter Storm
- Lamina
- pipejine
- pedestal
- esper
- conduit
- clamq

A Perfect Storm for Legacy Migration – (go back up)

When software gets too complex (risky) to change, we start referring to it as “Legacy”. Enterprise Legacy systems are typically created over a period of years by many hands and grow to become monolithic and deeply coupled, replacing one part means replacing everything. Many businesses embark on the perilous journey of replacing their Legacy systems with “New” systems; as one big risky project.

Imagine instead, if we could evolve new functionality, piece by piece, service by service, to coexist alongside the Legacy functionality.
For this to work, the Legacy system and New Services would need to be synchronized on a real time basis.

This talk is about how we used Clojure, Storm and Redis, to implement a Legacy Bridge: a synchronization service for translating change between a Legacy system and a set of loosely coupled Services.