September 1954, composer John Cage writes “45 minutes for a speaker”, a set of rules meant to compose a lecture through chance operations. Using questions like “1. Is there speech or silence?” or “4. If speech, is it old material or new?” Cage composed the speech’s content, noises and gestures.

February 2019, I generate and perform a 20-minute talk, on the fly, using clojure.spec, about clojure.spec.

Monitoring modern real time distributed infrastructure is complex and expensive. In this talk we explore Riemann, specifically, how Riemann’s low latency helped us to get real time metrics from our Distributed Systems.

Large scale real time distributed systems require emitting hundreds of thousands of metrics per seconds for effective monitoring. A significant portions of metrics are either not of any use or we don’t understand them. With the rapid growth in infrastructure, monitoring infrastructure in real time and getting accurate metrics becomes challenging especially when you have an in-house monitoring setup.

Most monitoring systems are pull/poll based where your monitoring system queries the components being monitored. Pull based monitoring systems, where the system keeps changing some x values in every y minutes, are literally dead.

Riemann is a monitoring tool that aggregates events from hosts, servers and applications and can feed them into a stream processing language to be manipulated, summarized or action-ed. Riemann is fast and highly configurable. Most importantly, it is an event-centric push model.

We use Riemann to monitor Distributed Systems. Catching problems in real time requires monitoring tools that have low latency to detect errors faster and immediately see if the fix is working. Riemann provides this along with a transient shared state for systems with many moving parts.

Riemann is written in Clojure and leverages its core concepts. Riemann configs are Clojure code.

We will walk through the concepts of Riemann

• Events
• Streams
• Indexes

We will also go over how to run Riemann in a production environment and how to write Riemann Clojure configs.

We will conclude our talk with the demo for monitoring distributed systems like Apache Zookeeper.

➜ Watch on YouTube

For all the fascination that it induces, Machine Learning (ML) is a rather complex area of computer science.
When translating one of its algorithms to some concrete implementation, the correctness of this implementation becomes crucial.
Clojure, on the other hand, is a simple, but powerful language. In most cases, its simplicity tends to transfer to the problem domain it is applied upon.
I argue that we can use Clojure to more simply implement machine learning algorithms and thus largely guarantee their correctness by means of simplicity.
In this talk I would like to concretely show you how Clojure may simplify the implementation of a particular class of ML algorithms, namely Reinforcement Learning ones, and demonstrate their correctness by using them to teach a game how to solve itself.

➜ Watch on YouTube

Introduction: What is the indie maker movement and why you should try and build your own side projects.
Why Clojure is the perfect language to do this.
Introduction to Coast, a full stack Clojure web framework for indie makers that want to get things done.
Walkthrough an example project of a Saas web app (likely this one: https://github.com/magehash/magehash).
My goal with this talk would be to spread enthusiasm for building fun things with Clojure and show how easy it is to get started.

➜ Watch on YouTube

At the heart of programming lies the task of decomposing problems into subproblems that can be understood and reasoned about independently. In his 2018 book „A Philosophy of Software Design“, John Ousterhout, the author of the Tcl programming language, lays out his approach to module decomposition.

This talk explores ways of applying Ousterhoutian techniques for avoiding complexity to Clojure. How do techniques of problem decomposition apply to the post-OOP world of functional programming?

➜ Watch on YouTube

Creating a software system for a travel tech startup can get quite complex especially when event timing and configurability are primary concerns.

As the domain model is a constant factor of change, we decided to directly represent the data as a graph, eventually implementing our own Graph Store using CouchDB and GraphQL on top of Clojure.

Yet the biggest obstacle to a maintainable and configurable software platform is to find a good representation for the plethora of interwoven business rules and according actions the platform needs to execute. Naturally, this is a good fit for a bunch of Finite State Machines we called the “Workflow Engine”.

Whether it is Datomic, Neo4j, or RDF/SPARQL, many Clojure users have some familiarity with graph databases, but not everyone understands how and why these databases operate as they do.
This can restrict how effective developers may be when creating data models and queries for graph databases, thus limiting their ability to make informed technology choices for data storage.
This talk describes the implementation of a complete graph database written in Clojure and ClojureScript.
We will discuss how various stores address the needs of indexing and storage for graph data.
We will also look at how queries are evaluated, including the important question of query optimizers, both in local storage, and for distributed systems.
These principles will be demonstrated at every stage with Asami: a Datomic-like graph database implementation that can run entirely within an application or in a web page.

While the demonstration code of this talk will come from Asami, it will be compared and contrasted to other graph databases, including Datascript, Datomic, Mulgara and Jena.
 
➜ Watch on YouTube

In this talk, we’ll look at how we migrated critical payment flows out of a monolithic order management system (OMS) to a framework in Clojure that composes event streaming, reliable task scheduling and configuration management in a harmonious way. These actors, in this Actor framework, are capable of processing over 100 million bookings per month. We will walk through why this framework is valuable handling varied asynchronous flows and how it helps keep the OMS simple by exposing well-defined contracts over Kafka. We will also talk about our journey in making the decision to write this framework and our ongoing effort to move large parts of Go-Jek’s Ride Hailing OMS into these smaller actors.

➜ Watch on YouTube

3DF is a stream processing system which feeds off of Datomic’s transaction log and provides clients with the ability to register arbitrary Datalog queries, for which they will then continuously receive any changes to the result set.
It does this efficiently by compiling Datalog queries to differential dataflows.

Using 3DF on top of Datomic provides a powerful, reactive interface to Datomic, making it an even more attractive choice for the real-time web.
It also opens up Datomic to non-JVM runtimes and processes without a peer cache, without sacrificing performance. Finally, it hints at the possibility of significantly speeding up functional UI frameworks like D3 and React, because it allows these systems to skip their own change detection.

This talk will explore the „why?“, „how?“, and „what now?“ of working with a reactive database.

➜ Watch on YouTube

The Big Rewrite is generally considered to be a bad idea. Our experience has been different. We would like to share how Clojure sneaked in through the front(-end) door and why we ultimately decided to go full-stack, from Datomic to ClojureScript.

Nextjournal is an integrated notebook-like platform with a focus on long-term reproducibility. Our team consisted of five language polyglots with only one member having had prior Clojure experience.

Starting out, we chose Elixir for the backend and Elm for the frontend. This talk explores the journey building the platform. Specifically:

• what made us switch the frontend from Elm to JavaScript and ultimately to ClojureScript
• how our desire to leverage immutability accross the stack made us switch the database from Postgres to Datomic and the website from Phoenix to Pedestal
• how we streamlined and simplified our application by rewriting the code executing runner from Elixir to Clojure
• how Clojure’s repl-based live programming workflow tightened our feedback loops and made us more productive
• how tools.deps and figwheel.main improved our workflows after a long journey of trial & error

Attendees will learn about the priorities and tradeoffs in the Elm, Elixir and Clojure communities and their effect on newcomers.

➜ Watch on YouTube

There are now loads of Clojure libraries for composing and playing music out there. Some of them can be a bit intimidating to get started with, but in this talk we are going to explore how you can hook your laptop up to a synthesizer (or use the built-in one in your laptop) and begin experimenting with computer generated compositions without libraries at all! Clojure in itself, along with the JVM environment, contains all the things needed for having your laptop cranking out hard-hitting (or mellow) electronic music in no time!

The objective is not to write out scores of music and feed them into the computer to have them played back. The objective is to combine basic Clojure functions in interesting, novel, and sometimes confusing ways and tweak the output until it becomes awesome music and heavy beats.

This is about keeping things simple and cover everything from the basics. We will touch on such diverse topics as:

• Analog synths, modular synthesizers and the eurorack revolution
• The MIDI protocol in all its glory
• Random functions in Clojure
• The Levenshtein distance metric between strings (super teaser)
• Basic tonal music theory (nothing heavy – I promise!)

Expect loads of wires and lots of noise. Only simple tools will be used – I guarantee it! After this talk you will be ready to host your own Clojure powered techno party!

➜ Watch on YouTube

With Clojure bindings for Apache MXNet, Clojurists now have the power of a modern and well-supported deep learning ecosystem.
We’ll explore applications of deep learning in Clojure, from tricking sand into writing poetry to asking your laptop to churn out fresh works by van Gogh.

➜ Watch on YouTube

Microservices have been the dominant choice of architecture since the great fall of the almighty monolith a few years ago. The premise was simple: Break apart this complexity into smaller, manageable chunks, and the simplicity will set you free.

This dream lives, but it is destroying everything we care for. REST has led to CRUD, CRUD has led to distributed state, and distributed state has led us right back to complexity.

In choosing Clojure, we made a vow to reduce complexity via state. From a micro level, our services are beautiful, simple and easy to understand. But what has happened to the macro level? And most importantly, what can we do about it?

➜ Watch on YouTube

Most LISP people don’t know about the small but highly committed LISP community east of the Iron Curtain, in East Germany (GDR). It’s widely unknown that for example in the 1980s LISPers of the Academy of Sciences of the GDR worked on natural language processing, automatic action planning for robots, expert systems, a full featured Common LISP system including a development environment, or on a highly optimizing LISP compiler which produces code nearly as fast as C for problems typically solved in C. They even began to build a self designed LISP machine to speed up LISP processing using specialized hardware! Already in the second half of the 1970s Herbert Stoyan, at that time working at the Technical University of Dresden, provided a basis for LISP development in East Germany with a LISP interpreter on IBM-like mainframe computers. It was widely used in research, teaching and production. I used this interpreter for my first LISP programs, interactive on a very low level – with punch cards and printed listings.

In my talk I will tell you about this exciting time, which is not least an important part of my own history. Besides history and stories I will share with you some of my very own insights and thoughts of this time about programming in general and LISP in particular. Please enjoy and take some knowledge and insights about some special LISP history with you.

➜ Watch on YouTube

As the amount of data to process grows, so does the time to compute a result. In computationally intensive domains such as numerical optimization, machine learning or image processing, achieving satisfactory performance with Clojure can be a challenging task. It is not uncommon to drop Clojure for the performance critical parts and resort to a language such as Java or C++ which tends to result in computationally more efficient code. With the Generative Expressions library, we can write the performance critical parts in elegant Clojure that runs just as fast.

➜ Watch on YouTube

GraalVM challenges the status quo on the JVM. This newly-released just-in-time compiler brings substantial speed improvements and support for polyglot applications. It also allows us to translate our JVM bytecode into small self-contained native binaries. In this session we’ll explore Graal’s impact on Clojure.

We’ll use GraalVM to build native binaries with simple command-line tools. We’ll discuss the method’s limitations and their impact. Finally, we’ll build complete Clojure web applications weighing a fraction of their traditional JVM incarnations.

➜ Watch on YouTube

Polylith is a software architecture that applies functional thinking at the system scale. It helps us to build simple, maintainable, testable, and scalable backend systems. It’s an architecture that has been inspired by the simplicity and composability of functions. We asked ourselves the question „what would a system look like if we could build it with high-level blocks that share the properties of functions?“. It turned out that the answer looks a lot like LEGO®.

Joakim will give a brief overview of the Polylith architecture with code examples.

➜ Watch on YouTube

With digital processes becoming more complex every year, and the digitalization finally arriving in our companies, workflow engines become more popular in the Java ecosystem. Describing process flows as a graphic model in BPMN (Business Process Model and Notation) makes them readable and enables workflow tools to execute them. When we let these engines keep the state and orchestrate the steps of a process, we gain the possibility to split our software into atomic delegates. We will explore together, how we can integrate a Java BPM engine with Clojure and how both form a love relationship which makes development incredibly fun and rewarding for us.

➜ Watch on YouTube

Dynamic Typing shouldn’t necessarily stop us from encoding type-driven things in Clojure.
Compared to statically-typed environments, dynamic typing might actually help us implement asynchronous computation in a much simpler way.
I would like to show you how one might leverage Clojure’s dynamic typing to build a simple construct for asynchrony, that is conceptually based on free monoids.

➜ Watch on YouTube

For Clojure developers, the Clojure REPL is a powerful, often indispensable, tool. However, here also lies the problem that the powers of the Clojure REPL are only accessible for Clojure developers.

In this talk, I present an overview of cli4clj, a library that aims on simplifying the implementation of easily usable interactive command line interfaces (CLIs). The talk is a quick tour covering the developer and user perspectives to illustrate how cli4clj helps during the implementation and how it eases the use of the resulting interactive CLIs.

cli4clj is built on top of the Clojure REPL and the Java jline2 library. Key features of cli4clj are: simple configuration via maps, persistent history, tab completion for commands and hints for arguments, support for complex Clojure data types, two scrolling modes, and functionality for easing the implementation of automated tests for CLIs.

➜ Watch on YouTube

A blazing whirlwind tour through cljdoc, the community website for Clojure library documentation. A showcase of features for users and library authors alike.

➜ Watch on YouTube

The style of programming without using intermediate variables explicitly is called „pointfree„. Haskell programmers love this style and they do have a point: coming up with variable names is hard. In Clojure, threading macros are a popular way for writing pointfree programs. In this talk we look at ways to combine threading macros to keep our programs pointfree.

➜ Watch on YouTube