In this talk we will explore how clojure.spec works under-the-hood, how to use it to specify your APIs, and how it can be extended to do, documentation generation, and declarative data transformations.By interpreting what specs mean and extending clojure.spec, we can render our clojure.spec specifications in other formats such as json-schema, so we can use them for validation in other programming languages, or for documentation purposes.

By specifying our domain models we can go even further and replace deeply-nested data-wrangling functions with declarative spec-to-spec transformation functions that can be generated from two compatible specs.

Finally we will demonstrate our open source library of tools “Speculate”, which enables specs to be translated into other formats (such as json-schema and swagger), and enables compatible spec-to-spec transformations.

➜ Watch on YouTube
 

A talk dedicated to the importance of (good) style in languages in general and programming languages (including Clojure) in particular.

We’ll start by examining some ideas from the timeless book “The Elements of Style” from the perspective of (Clojure) programmers. We’ll continue with an attempt to define the value of applying a consistent style while programming and what good style really stands for. We’ll also discuss the benefits of style guides and the use of automated tools that can help us write idiomatic and easy to understand code.

➜ Watch on YouTube
 

Why are distributed systems still so hard even for “simple” web apps? Why are most systems still built with no formalism in an adhoc fashion around a central strongly consistent system only to later introduce all kinds of slightly or not so slightly inconsistent caches and local states? Why is prototyping of these systems despite these simplifications still so elaborate and integration of new mutable data sources so time consuming?

Don’t be fooled! While distributed architectures have different tradeoffs and you have to decide, there are reasonable defaults which work well even when you cannot draw the boundaries of your system yet. Do you remember the happy times when instead of starting with a central system and building a ton of glue code just to form interfaces (REST, …) to your users in a prototype you could just manage state locally as a native application? Over the last three years I have built and explored replikativ, a system built around a sound eventual consistent formalism (CRDTs). I had to bend Clojure, ClojureScript, core.async, a bunch of IO libraries and myself a lot to integrate it from JVM to the web browser the way I wanted, but am fairly happy with the result so far. The system is used in several prototypes and we plan to use it for small production problems next. I want to give an account of what one can expect from such a system, where Clojure helped development and where it failed and also what can be expected to be built with such systems in the future compared to traditional architectures.

➜ Watch on YouTube
 

Transducers are quirky but awesome. Let’s make them quirkier and more awesome: transducers that also acts as transducing contexts, pair transducers, Spark as a transducing context…

➜ Watch on YouTube
 

One Clojure developer, one PHP developer and one iOS developer… 6 weeks to build an MVP for an iOS app. In this talk I want to introduce Re-Natal with re-frame – a way of architecturing a React Native app with ClojureScript, Matchbox – a wrapper for firebase and go through all the troubles we had being unwitting guinea pigs in relatively uncharted technical territory. It turns out this stack worked great for huge gains in productivity even for developers with no previous ClojureScript experience (and was a lot of fun). My aim after giving this talk is that you should be able to get started making your own React Native app with real-time user interactions out of the box. And of course, glorious fame.

➜ Watch on YouTube
 

We think of ourselves as developers. The creators and artists. However most of the time we are maintainers, inheritors and archaeologists. Adventurers in dark catacombs of legacy code and alchemists playing with explosive mixture of bleeding edge libraries.

Debugging is our bread and butter but also the most neglected conference topic. And there is more to debugging than just debugger and print statements.

In the talk we will discuss different ways to approach debugging in Clojure. What makes Clojure strong in the area of debugging? What tools can we use? How to compose our applications to simplify debugging? What kind of tools should we build in future?

I hope to inspire audience with new techniques and experiments which makes debugging simpler and live easier.

➜ Watch on YouTube
 

Applying information theory to machine learning: we will walk through implementing a novel approach to evaluate k-means clusters, using Clojure, Incanter, and clj-ml.

➜ Watch on YouTube
 

Cryptography is a weird can of worms: it is hard, and yet it is easy. The math behind crypto can be hard, and yet we can build relatively secure software without math background. Security proofs are precise, and yet it is possible to explain a lot using some careful handwaving. It is very easy to use cryptography APIs in most languages, and yet it is too easy to shoot yourself in the foot with them. We need to raise crypto awareness in Clojure community!

In this talk, we will explore common cryptographic pitfalls, refute some widespread assumptions, outline the best approach to date, underscore particularly dangerous parts of it, examine Clojure crypto scene and discuss the near future of symmetric cryptography. Unfortunately, we will also find out that despite its apparent simplicity, symmetric encryption is still an unsolved problem.

➜ Watch on YouTube
 

After the appearance of React in the browser landscape the community built numerous libraries like Om, Om Next, Reagent (used with or without Re-frame), Quiescent, Reacl and perhaps even more to make Reacts blessings available in ClojureScript. Some libraries clearly express their preferences about how a more complete frontend architecture should look like, and encourage us to add core.async, co-located queries, reactive programming or cursors to the mix.

Based on an understanding of the general problems to be solved within a single-page-application this talk will provide some design heuristics on how to make the right choices that add just enough complexity to your frontend.

➜ Watch on YouTube
 

Homoiconicity is a long word our community likes to use heavily. It’s a cool property of the Clojure language: it means that code can be treated as data. We as computer people are used to handling data: we can visualise it, analyse it and even generate it. What does it imply if we can do the same things with our Clojure code, even while the program is running? I will investigate this question with examples from clojure.spec & hopefully help you understand this abstract concept better.

➜ Watch on YouTube
 

Clojure is all about data, but it does not prescribe how data outlives program execution. Files, traditional databases, NoSQL – there are many ways to store and retrieve data. This talk explains some history of application data storage, illustrates some of the options available to the Clojure programmer, and reflects on how “everything is a value” conflicts with the desire to maintain the identity of application entities.

➜ Watch on YouTube
 

Property-based testing is mainstream now (there, I said it). The testing approach popularised by test.check enjoys wide adoption in the Clojure community. This talk is dedicated to another randomised testing technique. Mutation testing introduces subtle bugs to source code of our projects and checks that our tests catch those synthetic problems. Clojure — a homoiconic language with dynamic code reloading — should offer us an excellent foundation for building a mutation testing library. But there’s not a single one out there. Why? Let’s try to answer this question together.

➜ Watch on YouTube
 

Making video games is lots of fun and frustrating at times, and so can learning Clojure be. So why not combine both for maximum effect?

I started making video games a few years ago in JavaScript and Lua as a learning playground and for fun. Later I started learning Clojure on the side after attending a ClojureBridge workshop. When I tried making games in Clojure, sort of convinced that my experience in one would help with the other, I didn’t know what I would get myself into.

This is a talk about my experiences along the way.

➜ Watch on YouTube
 

Some developers love it, some hate it: there is the point where for most application you need some kind of user interface. Be it an admin interface or something that a user will see. In this presentation I will talk about how you can use Clojurescript and react to create web user interface automatically from a data model.

➜ Watch on YouTube
 

In this talk, it will be shown that packet capturing with Clojure works fast, how it is made fast, and that Clojure offers amazing capabilities for processing such high-throughput stream data. Following a bottom-up approach, the covered topics include:

• integration of low-level packet capturing with the JVM via JNI,
• acceleration of packet capturing with the JVM up to the magnitude of 10 GBit/s speed,
• a Domain Specific Language (DSL) for extracting information from raw binary data,
• and a self-adaptive mechanism for automatically adjusting the data processing at run-time. While this talk focuses on packet capturing, the presented topics can also be applied to other application fields.

 
➜ Watch on YouTube

Symmetry is everywhere, from constraining how builders lay brick to guiding physicists as to the nature of reality.

In the short book The Symmetries Of Things the mathematician John Horton Conway, in his uniquely playful style, classifies all the symmetries of the 2D plane.

In this talk you will learn how to identify miracles, wonder-rings and learn the Galloping Gnu Conjecture – and see lots of pretty pictures draw with Quil and a tasty Clojure DSL

➜ Watch on YouTube
 

Your data is distributed. Or not. Your data is interconnected. Or not. Your data is important.

When it comes to data there are a thousand worlds with a thousand shapes. Oftentimes, you can find them split up over a variety of sources and formats – and it is your job to select, filter, and combine them. But you don’t want to think about the order different pieces of information are fetched in. You don’t want to lose yourself in custom variants of your data that require you to add or remove fields from some base document. And you don’t care much for having to manually optimise your data access.

In the wild, we can find multiple exciting ideas and projects. There are the wonderful abstractions of Haxl, or the way GraphQL lets us think about the structure of our information. We can use these ideas to our advantage.

This talk will provide concrete examples on how data access in Clojure can be simplified. We’ll discuss common pain points and user stories before leveraging existing tools to deal with them.

Because your data is important.

➜ Watch on YouTube
 

Traditional editors and IDEs run in their own process and try to understand your code by statically analyzing it. This is in contrast to the Lisp and Smalltalk tradition, where tools often interacted directly with your running program. Nightlight is an editor that attempts to bring that style of development to Clojure by running directly inside your project.

➜ Watch on YouTube
 

Clojure might be one of nicest programming languages ever created, but it’s not perfect. This talk is dedicated to the rough edges and the imperfect bits of the Clojure programming language and its ecosystem.

We’ll go over various topics including, but not limited to:

• confusing/obscure language features
• issues of the standard library
• missing frequently requested features
• tooling issues

Throughout the talk we’ll also entertain some ideas how we can make things better. We’ll wrap on a positive note with a glimpse into Clojure’s (bright) future.

➜ Watch on YouTube

Anyone who has so far dealt with Infrastructure as Code has to deal with a mix of Ruby, Python and go. If you want to get more from the Java world and always wanted to try functional programming, there is now a worthy & fresh alternative: “dda-pallet”. Dda-pallet is OpenSource, written in clojure, running on the proven Java Virtual Machine. dda-pallet provides the whole tool-chain from one hand, is real modular, testable and well prepared for configuration data handling.

➜ Watch on YouTube
 

In my programming experience I used lots of different tools, languages and frameworks. Over last 4 years I use Clojure as my main language to solve problems on a high scale and I have been deeply surprised several times in good and bad ways. This is what I want to share.

➜ Watch on YouTube
 

Monroe is REPL client for Emacs, focused on simplicity and easy distribution, primarily targeting Clojure users. It is designed to be stable, work on large Clojure projects and older Emacs versions – in short, designed to never step on your toes.

This talk is short introduction about the project, goals and benefits over alternatives like CIDER or IDE plugins like Counterclockwise or Cursive.

➜ Watch on YouTube
 

Games are a modern art form, and like other artists, game designers need to experience their work as they create it. This talk will explore the benefits of making games “at runtime”. Through both abstract discussion and concrete demonstration, we will see why ClojureScript is uniquely suited to the task.

➜ Watch on YouTube