For years now, Clojure has found steadily increasing traction and mindshare in web development, data processing, machine learning and other largely business oriented applications. However, after 7+ years of maturing, there’s still only a relatively small group of people exploring the language for more ‘creative’ applications. This talk will aim to change that and by way of various examples of my own work with the language, expose some of Clojure’s (and Clojurescript’s) features, giving us sometimes unique and generally beneficial tools for transforming our creative/explorative production processes, incl. defining domain-specific languages and working with low-level technologies (OpenCL/WebGL).

Furthermore, I will try to also situate Clojure in the bigger picture of a polyglot practice and touch upon the importance of concept transferral, showing how some of Clojure’s ideas are highly useful in other environments too and already have influenced thinking in these other communities.

➜ Watch on YouTube
 

Forty years after McCarthy discovered Lisp, the formal foundations of computing’s first half century, he published a little-known paper with an incomplete vision for the language of the future. Little did he know then that on the other side of the country Okasaki had just published the missing piece to this puzzle.

In this talk we’ll put those pieces together to understand McCarthy’s predictions for the future of computing; explore some of the things this would mean for the next half century of computing and take a look at some of the languages, such as Unison and Ox, which are building this vision of the future today.

➜ Watch on YouTube
 

Dependencies between components are one of the primary drivers of the flexibility of any bigger applications. Clojure provides a number of tools to manage dependencies, some are built-in, some are built on libraries. We’ll look at basic building blocks like higher-order functions, multi-methods and protocols, but also at libraries like Stuart Sierra’s component.

➜ Watch on YouTube
 

Today, most of the apps we build involve the browser and thus need an remoting layer between the ui and the backend. New Technology like Falcor, Relay and Om Next are leading the innovation in this space. Is REST dead? CQRS to the rescue? How should I build my next api?

Our 2 cents is Kekkonen, a fresh new multi-paradigm api library for Clojure.

In this talk, we’ll demonstrate how to build a reactive CQRS api (and api-docs) with Kekkonen for a complex simulated real-life case. We dive into advanced stuff like client side transactional call composition and local state & reasoning. We’ll also demo how Kekkonen integrates with Om Next & Reagent.

Having programmers do data science is terrible, if only everyone else were not even worse. The problem is of course tools. We seem to have settled on either: a bunch of disparate libraries thrown into a more or less agnostic IDE, or some point-and-click wonder which no matter how glossy, never seems to trully fit our domain once we get down to it. The dual lisp tradition of grow-your-own-language and grow-your-own-editor gives me hope there is a third way. This presentation is a meditation on how I approach data problems with Clojure, what I believe the process of doing data science should look like and the tools needed to get there. Some already exists (or can at least be bodged together); others can be made with relative ease (and we are already working on some of these); but a few will take a lot more hammock time.

➜ Watch on YouTube
 

Is Clojure even “a Lisp”? It certainly depends on your very own perspective to decide that, if it even matters to you. Clojure certainly shares a lot with other languages from the Lisp family. This talk will highlight some of the commonalities and differences between Common Lisp and Clojure, helping you decide whether you want to learn one or stick with the other.

➜ Watch on YouTube
 

What if you could transform each user session into a regression test? What if you could check if your code changes will break your users’ behaviors?

That is the promise behind Predictive Testing, to make your codebase learn from your users.

Lot’s of people know about Turing Machines and the Lambda Calculus and that they both can express any computable function, but often don’t really understand what that means. An Unlimited Register Machine is a simple model of a computer, still quite idealised, that is turing equivalent also.

The philosopher Dan Dennett, in his recent book Intuition Pumps and Other Tools For Thinking, devotes a rather large section to URMs titled The Seven Secrets Of Computing Power Revealed. The hope is that by simulating the simplest possible register machine and building up complex algorithms you can understand what it means to compute and how a computer works.

I have been working on a Clojure DSL and Interpreter for a URM, with the goal of writing a small book that draws the straightest line possible towards universality and a proof of the undecidability of the halting problem.

In the this fast-paced talk I treat math(s) and ‘programming’ as equal citizens in terms of explaining the idea and end with a succinct (if somewhat problematic) concrete implementation of a Universal URM (via a neat way of Gödelizing programs, ie turning them into numbers)

➜ Watch on YouTube
 

Evidence Based Medicine concerns itself with making sense of all the clinical data out there, from Randomized Controlled Trials to Electronic Patient Records. Unfortunately, this data is often much more messy than you’d expect, and the academic process is well … academic. In this talk the general problems faced within this field will be outlined, and we’ll dive into how forgotten technology such as Semantic Web offers a nice integration with Clojure’s data-driven approaches. We’ll also touch on how to communicate evidence effectively (“new literacy”) and avoid the same mistakes in current practice by using Lisp s-expressions as a GUI concept.

In the this fast-paced talk I treat math(s) and ‘programming’ as equal citizens in terms of explaining the idea and end with a succinct (if somewhat problematic) concrete implementation of a Universal URM (via a neat way of Gödelizing programs, ie turning them into numbers)

Wunderlist, with millions of active users, continues to grow, bending its realtime sync technology to the limits. This pushed them to rethink and experiment with different architectural approaches. As a result Akka’s Actor System become a key component of theirs realtime architecture. However Actor Systems are not popular in the Clojure Ecosystem. In this talk Andrei will cover what they learned from using Actor Systems, what are their advantages and how to use them in Clojure.

We just released our iOS app built with Clojurescript on top of React Native in the App Store. YOLO tech or solid like a rock!? An experience report on building for iOS with Clojurescript.

Microservices are the new silver bullet. But how do you avoid the added overhead and more complicated deployment in the initial stages of your project?

With a bit of planning and sound development principles you can grow your system starting with a single process using simple functions through namespaces and components all the way to full blown microservices after the architecture stabilizes.

➜ Watch on YouTube
 

“The map is a stark data structure and everywhere it is passed there is much duplication of process.” –@msimoni

Clojure is untyped. But even if you’re a fervent defender of this defining quality of Clojure, you should use types to guide the design of your code. In particular, the PLT project’s “program by design” is a very effective methodology for constructing programs systematically. Coming from Racket, another untyped language, “program by design” can be applied in Clojure to great effect. The talk shows how it’s done.

Unfortunately, the idea of supporting types to organize data came to Clojure as an afterthought. Hence, support for it is less than optimal: The operations for collection types are a mess, and defrecord still views structured objects essentially as maps. Consequently, “program by design” chafes against Clojure’s idea of organizing data.

The talk gives a short introduction into “program by design”, shows how to apply it in Clojure, and exposes where Clojure went wrong on data.

➜ Watch on YouTube
 

Clojure has been the fabric of our systems for over three years now. We’ve been taming its power, learning its quirks, and all in all becoming good old friends with Clojure. But we haven’t lost the urge to explore.

This talk is dedicated to lessons we’ve learned while designing, developing, and deploying to production our very first Erlang project. Erlang, despite its functional goodness, is a whole different world. Built on top of a virtual machine radically different than the JVM and designed to solve a very specific set of problems, it has taught us some valuable lessons about software.

The audience of this talk will learn about differences between Clojure and Erlang, both at the linguistic level as well as, even more importantly, at the level of underlying virtual machines. I’m going to discuss how Erlang challenges our methods of building systems in Clojure. I’ll use our new Erlang-based project as a source of concrete differences.

At the end of the talk attendees will see why the “Let It Crash” philosophy makes so much sense when building on top of rock-solid Erlang foundations.

Your applications are code. Your infrastructure is code. And your pipeline? The thing that builds your artifacts, that runs your tests, that deploys your code into production? You probably still click around in your favorite build server to configure it! There is a better way: Build your own build server in clojure! It has power, flexibility, version control, dependency management, refactorings, tool support and testing! In this talk, I will show you how to do it, why clojure is a great fit and how a large organisation uses it successfully to release working software several times a day.

➜ Watch on YouTube
 

Presentation of a dataflow programming environment in which a reactive graph of ClojureScript cells is exposed via an outliner interface in a web application.