The Clojure community is filled with really smart people, with great ideas writing very few tutorials and less documentation. At times it can be quite intimidating and discouraging. This talk is about how you can build your skill and confidence as a Clojure developer. As well as my journey from Pixie to Hylang and eventually Clojure.

We’ll unpack how build your own path to Clojure confidence as well as some of the things I’ve learnt in my journey from being a lousy, lazy lisper to coding confidently to writing Clojure for the financial sector. It’s gonna be a goodie. All skill levels welcome. See you there!

➜ Watch on YouTube

Artificial intelligence is an old hat, a hype, a buzzword. But for actual use it is (almost) not comparable to traditionally developed software systems. The validation and debugging of machine learning is still in its infancy. In his lecture, Dr. Christian Betz will give a brief overview of the field of AI, explain the properties of different approaches to AI and show how to secure and test AI systems.

➜ Watch on YouTube

Ever had a problem where the solution seems to have too many ifs, it’s hard to understand, everyone is afraid to touch the code and fixing bugs only seem to introduce more bugs? What if you could write the same code, no matter the paradigm (imperative, OOP, functional) in a manner where the code is easier to understand/debug and extend/change?

I will be introducing functional pipelines, which some of us Clojure (or F#/Haskel) developers use every day, but are less known in the OOP world such as in Java/C#, where we could use the Either monad (I won’t talk about monads) where it can return either a SuccesResponse or an ErrorResponse. I will be introducing with code, 6 manners of solving the same problem from which 3 are using pipelines and I will be leading the audience to conclude for themselves whether using pipelines improves the code or not.

➜ Watch on YouTube

Nature is the sum of a large amount of complex ecosystems, where different species coexist in a fragile equilibrium.
In this talk, we will simulate our very own ecosystem with Clojure, and explore emerging patterns under simple sets of rules.
We will have the chance of creating our own little creatures and observe them thrive, compete and evolve, as they struggle for their own existence.

➜ Watch on YouTube

A former colleague of mine once said, „Ah, I don’t need Simula to write object oriented code, I can do that in any language“.
I’d like to paraphrase that and say, „Ah, I don’t need JavaScript to write messy code, I can do that in any language“.

Writing quality software is hard, and even though Clojure is the best language I’ve used, it still doesn’t stop you from shooting yourself in the foot, it doesn’t stop you from writing messy code, and it most certainly lets you create all the bugs you’ll ever need, and then some.

In this talk, I’ll use Ardoqs code base, along with other bits and pieces of Clojure code I’ve worked with (and written) to highlight principles that are important when writing software. I’ll demonstrate by example how the code at hand violates the principles, and offer clear refactorings which will make the the code easier to test, read, and reason about.

The audience will walk away from this talk with tools that they can apply to their own codebases, be it in Clojure or other languages.

➜ Watch on YouTube

The command-line shell is an essential part of a developer toolbox. Many of our production systems depend on it. Shell scripts are used to tie together deployments and orchestrate cloud systems. However, shells accumulated lots of incidental complexity. There are many dark corners that surprise even seasoned programmers.

Unix philosophy suggests writing scripts by composing smaller programs and piping plain text between them. In functional programming we compose functions and work with proper data structures, which is much more powerful.

In this talk I will explore how a shell combining best of Bash and Clojure could look like. I will introduce Closh, a unix shell written in Clojure. You will learn how to leverage expressive and well designed language like Clojure on the command-line and combine it with existing programs.

➜ Watch on YouTube

Maps (the geographic kind) help us make sense of the world around us. They don’t just help us navigate an area, they can help us visualize patterns of a physical place. They can also be emotional. Maps can make us feel nostalgic for a place we’ve lived or visited and can trigger memories.

After I moved to Berlin from the US last year, I challenged myself to make a series maps of my old home using Clojure to help me remember the place I lived. In this talk, I’ll share some of the maps I made and explain the different processes to make them and challenges I encountered. We’ll go over the open source tools used, new geographic file types, and different ways to present geographic data in 2D and 3D.

➜ Watch on YouTube

Expressing feelings is hard. Understanding what’s happening inside of us is somewhat nebulous. And sometimes, all of that gets in the way of our focus and the things we want to do. So how can we bring ourselves fully alive with the tools that we know and love? Can we actually use code to our rescue and give space to our inner world through that?
Turns out, yes, we can! And in this little audiovisual performance we’ll try to represent the whole inner spectrum of feelings, colours and shapes through vibrations and flashy lights. In other words, we’ll make sounds and show some moving pictures and we’d love to take you on this journey with us. One where the body is master, where sensory input guides the experience, and we can let ourselves free to fully experience what is not possible to convey through words and language.
And we’d like you to relax, tune into your curiosity, your feelings, and maybe dance a little 🙂

➜ Watch on YouTube

Prolog is this weird old language that established the paradigm of logic programming. Once heralded as the solution to all AI problems, it is now considered a niche language. Luckily, many languages have adopted ideas from Prolog, such as Clojure with core.logic. In this talk, I would like to introduce Prolog’s programming model and showcase some programming domains in which it allows for very concise, elegant programs.

➜ Watch on YouTube

Wow – how did the world manage to fall in love with the idea of nested maps and lists?
Well, they have, so now it needs a language that can so easily process it. Enter JSONScript! (or to give it its proper name: Clojure).

I’ll tell the story about how I used to complain about JSON but changed my mind. I’ll explain about JSON Schema, what it is and what it can do (with a demonstration of my new JSON Schema validator/processor, jinx).

I’ll also demo jinx’s role in a brand new web library that I’m building on Metosin’s reitit: Apex. Apex turns OpenAPI documents into running web endpoints with reitit, with full OpenAPI and HTTP compliance.

➜ Watch on YouTube

In 2015, the ClojureScript compiler underwent a big change with the outcome of being able to compile itself. But how is it possible for a compiler to compile itself? How can a compiler be written in the same language that it compiles?

In this talk we will look into the concept of compiler bootstrapping, how it was done for the ClojureScript compiler and what we have to gain from a self-hosting compiler.

➜ Watch on YouTube

What if you could avoid confusing bash syntax and replace it with a Clojure snippet here and there?
What if executing a Clojure script could be as fast as executing a bash script?
What if you could use Clojure expressions in a configuration file?
What if you could evaluate a Clojure expression in the browser, even in an advanced compiled CLJS app?
Meet Babashka and the Small Clojure Interpreter.

➜ Watch on YouTube

Can youth voter registration predict the outcome of the US presidential election? And can integrating R with Clojure help us do data science in a more elegant, maintainable, and even fun way? I’ll start by briefly sharing my motivations for exploring the impact of youth voter registration in America and my hopes for improving democratic participation. Next, I will present ongoing research into election prediction using statistical techniques such as multi-level regression and poststratification in R. After that, I’ll show how R can be integrated into Clojure using the Clojuress library to write simpler and more legible code. I’ll finish up by showing how I can leverage the rich JVM and JS ecosystems to serve my model as an API and build a Clojurescript frontend to visualize the upshot of my analysis. I hope to convince the audience that Clojure is an excellent platform for data science, especially when integrated with tools from the popular R language.

➜ Watch on YouTube

The language that gives programmers the most leverage is a dynamic language. But (pardon the clickbait) that language is not Lisp but English prose. Effective use of written English is an indispensable tool in the programmer’s toolbox. And yet, software developers — many of us speak English as a second language — focus too little on improving their technical writing.

Leslie Lamport famously quipped that writing is nature’s way of letting you know how sloppy your thinking is. This talk makes the case for the importance of this often-neglected skill. I report how the engineering team at Pitch encourages planning and knowledge sharing through written Request for Comments documents. Effective writing is hard and takes work, but there are many ways of getting better at it. I go over specific tools and techniques that I find helpful.

➜ Watch on YouTube

As software people, CI/CD tooling is something that most of us are using in both of our professional and personal projects. But how many of us think that its actually simple? That it’s actually easy to configure something to actually work the way we’d want and not fight with it? How many of us have gotten nightmares at the mention of doing infrastructure and thought its the „Ops“ people sitting out of our sights are better off dealing with it?

Bob was born out of equal parts of frustration with the existing tools, sympathy towards developers and infra people alike and with the aim of bridging the huge divide between developers and infrastructure people. Fully built in Clojure and embodying the UNIX philosophy, almost Emacs like external extensibility and simplicity of Clojure, Bob tries to be least in our way and tries to be inclusive of our needs and is a CI/CD platform than just a tool, enabling us to build the CI we want, not be hammering away at an existing stubborn thing and more importantly making it much more approachable and inclusive to newbies.

➜ Watch on YouTube

Malli is a new Clojure/Script library for elegant data-driven data modelling. It is born from the real world needs of dynamic, distributed and multi-tenant systems: Schemas to describe the data should be first-class data. They should drive the runtime value transformations, web forms, rules and processes. Configuration should be explicit – no magic, macros or mutability. We should be able to infer, create and modify the models at runtime, persist and load them back from database and share over the wire, for both Clojure and ClojureScript. Like JSON Schema, but for EDN & Clojure/Script.

In this talk, I’ll walk through the core concepts, features and the lessons learned on creating Malli. I’ll also demonstrate some cool new things we can do with literal data schemas and compare it to prior art, including clojure.spec, plumatic schema and JSON Schema.

➜ Watch on YouTube

New to Clojure? Want to explore and see its power? In this talk, we will learn how to build games with Clojure and why it is a good way to learn Clojure.

We will first look at the play-clj library built on top of libGDX for game development. This will give you a nice development environment where you can focus on writing game logic and have fun using the language. Also game development gives you an opportunity to apply your Data Structure and Algorithms knowledge which is a great way to learn any programming language. We will see how Clojure REPL allows us to modify the game state during runtime which is not possible otherwise.

Next we will move to the web and use ClojureScript with Figwheel to make game for the browser. Of Course if you want to make multiplayer games, you need a server. Now we are getting into web development and we basically want to implement a chat server. We will look at the Clojure concurrency model and the packages available in the Clojure community to help us build our server.

The best part of using Clojure(Script) stack is that you can share the same code for the game logic between the client and the server. This is useful if you want to make unhackable games where you don’t rely on the client to get the game state instead the client just communicates the player actions to the server and the server independently computes the game state.

I will give a quick demo of the play-clj as there is a great talk out there by its creator itself. But we will walkthrough a full stack web app.

➜ Watch on YouTube