After being inspired many years ago by the elegance of Datomic and the simplicity of Firebase, it was time to rebuild all the stacks, but the cost and complexity of getting started with Datomic were just beyond reach. And so began the outrageous journey to building Datomic on top of Firebase.

This workshop is a practical introduction to Datalog and Firetomic. We'll build an application that harnesses the power and unique features of Datalog and one that could also be helpful in your daily life. If you don't know Datalog, Docker or Firebase, don't stress. We'll be going through this step by step together.

If you're keen on joining this workshop it'd be cool if you could download the dependencies and the docker image before the workshop so we don't karate chop the wifi. You can check out the setup details in #firetomic or at https://github.com/alekcz/firetomic-demo. Ping me on Twitter or Slack if you get stuck.

We'll be building a wellness app and you can make it as simple or as complex as you'd like. In the end, we'll deploy your Firetomic application. We won't say your life will then be complete. But we're also not not saying that. See you there!

How do we design programs that can be understood? Abstractions coded with the best of intentions often become opaque, as context is lost or forgotten and the program grows around them.
This talk will use Clojure’s unique capabilities to explore techniques to develop software that we can actually understand, including lessons we can take from projects both inside and outside the Clojure ecosystem.

➜ Watch on YouTube

All I wanted to do was define a few variables with the beloved let function. What could possibly go wrong?
Well does failed: even-number-of-forms? at: [:bindings] spec: :clojure.core.specs.alpha/bindings sounds familiar? Errors in Clojure can be intimidating. In this talk I will not make you an error ninja, but I will give you tools that will help you become one.

➜ Watch on YouTube

When you combine the open world sandbox of Minecraft with Clojure’s interactive programming, magic happens.
In this fun and creative workshop you’ll play Minecraft via the REPL. Build amazing structures, add custom player interactions, or spawn exploding chickens.
If you plan to participate we kindly ask to follow the installation instructions beforehand, so we don't overwhelm the conference wifi. And please join the Clojurians #minecraft channel on Slack.

According to Freshcode's research, the awareness gap is one of the biggest challenges for the Clojure community.
The underestimation of the marketing and product management role, as well as the limited resources to involve big players in the game, are the main things to pay attention to.

Key questions for discussion are how other languages dealt with mentioned problems and how to speed up the Clojure community development using best practices.
This topic covers the following points:

• how other programming languages have become popular and what lessons can we learn from their success stories
• what are the growth points for the Clojure ecosystem
• ideas on what can we do for the Clojure community development in the short and long term

➜ Watch on YouTube

What happens when you design for beginner-friendliness?

This talk will explore how continually taking a beginner's perspective can improve your code. It will draw on ideas from user experience design and show how they can be applied to our day-to-day work, and it will examine how systems designed for experts can be fragile, while systems designed for beginners can be more robust.

➜ Watch on YouTube

Our programs and their libraries are becoming more complex every day. Clojure is a great way to curb that complexity, but at some point, it still becomes difficult to reason about the flow of data through the application.

Omni-trace makes it possible to visualize that flow and ask questions about any calls that were made.
In this talk, you will learn how you can use omni-trace to see your code in action, integrate it into your dev routine, and explore unknown libraries. Afterward, you'll never want to start a normal debugger again.

➜ Watch on YouTube

Clerk is an open source programmer's assistant for Clojure that combines the advantages of notebooks like Jupyter, Smalltalk-style Moldable Development, and using one's favorite editor.

This workshop is intended for Clojurians of all levels. Bring your laptop and we'll get together in small groups to help you get started as a newcomer or level up your Clerk game.

Clj-kondo is a linter and static analyzer for Clojure/Script. It has out of the box support for syntactic constructs in Clojure, often defined by macros.
For third party macros similar to Clojure's own, clj-kondo has an easy configuration option: :lint-as. But what about macros that invent their own language?
You can disable linting for those, but what if there was something better. Clj-kondo hooks are a flexible way to teach clj-kondo's static analyzer about any macro. Not only will clj-kondo understand them and will you get useful linting feedback, you can insert your own checks and linting rules.
As a library author you can export your hooks so every library user can profit. In this workshop we will learn how to write our own hooks using real-world examples.
Only a basic understanding of Clojure is required to get hooked!
If you like to participate please read the prerequisites and join the Clojurians #clj-kondo channel on Slack.

"Amazing" – Michiel Borkent

"Those keywords look terrifying" – Eugene Pakhomov

"It's fun!" – Ben Sless

"Some say it's a joke, I say it's beautiful!" – Adam Helins

"You are all bad people" – Alex Miller

What started as a joke turned into an exploration of macros and obfuscation of Clojure, and ended in a much bigger joke.
Learn how the Remorse library turns Clojure into Morse code that is still valid Clojure.
Discover how ClojureScript Macros really work, and how a Morse code library written in Morse code needs namespaces compiled with 2 different compilers at the same time.
(-··_·_··-· _··-·_··-_-· :-.-._.-.._---_.---_..-_.-._._-..)

➜ Watch on YouTube

Testing is an integral part of software engineering understood as "programming integrated over time". In my talk I will explain why.

More than 20 years after Kent Beck first published JUnit, developer-centric software testing remains controversial. While most will admit that test automation is useful, agreement ends there. Some have warned of test-induced damage inflicted on software design. Others go so far as to argue that unit testing is mostly waste.

Testing is hard. Unfortunately, because testing culture emerged in the heyday of Object-Oriented Programming, the existing literature focuses on Java or C#. Arguably Functional Programming avoids some of OOP's testability pitfalls, but it doesn't invalidate reasons for unit testing – far from it. Yet unit testing Clojure remains a minefield of tradeoffs. This talk is my attempt at making sense of this sprawling, confusing debate by drawing a conceptual map and discussing common traps and mistakes.

➜ Watch on YouTube

Learn about the project and how you can contribute. We'll be handing out tasks for free.
ClojureScript programmers: come to add features or give the UI a makeover.
Clojure programmers: expand your mind and the backend.
Database programmers: wrangle EDN for fun and profit.
Please join the Clojurians #repl-acement channel on Slack for more details.

This year, :clojureD coincides exactly with the 9-year anniversary (well, minus 17 days...) of Rich Hickey's first blog post on the core.async library. At the time, Rich already hinted at the potential for "automated correctness analyses" but also stated that "no work has been done on that front for core.async as yet". To celebrate almost a decade of channels in Clojure, let's take another swing at this!

In this talk, I'll present the Discourje project. In a nutshell, the project allows Clojure programmers to specify communication patterns for core.async usage (as a kind of textual sequence diagrams), after which a run-time monitor can automatically verify channel traffic for compliance. The main correctness guarantee is safety: puts/takes that are forbidden by the spec never take effect (an exception is thrown instead). The project has mathematical foundations and originates from research on type systems in Computer Science, but that's all outside the scope of this talk.

➜ Watch on YouTube