OOP habits die hard. Having trained my OOP skills through the years, I have applied unconsciously OOP techniques while writing code in functional languages. The quality of the code and test suffered because of it, leading to a very confused design and maintenance problems.

For OOP we have designed good guidelines to produce code that is readable and maintenable, like SOLID, DRY, … On top of it we have Object Calisthenics, for practicing the creation of good OOP Code. Functional Calisthenics have the same aim for the functional paradigm.

In this talk I will explain the rules, with examples in Clojure, on the hope that I can show how they lead to better functional code and to entice you to try them for yourselves.

➜ Watch on YouTube

The REPL is central to the Clojure flow. However some frameworks or targets make us abandon it because of a save-compile-run cycle forced upon us.
We have to stand up for our REPL and code back! We have to hone and cherish it! We have to push it where it has never been before! Join us, join the replistance!
In this talk I’ll cover experiments in pushing the REPL forward.

➜ Watch on YouTube
 

Building a rich single page app is really hard. re-frame, a ClojureScript wrapper over React, together with a beautifully simple flow of immutable derived data, makes this an absolute joy. It also sports a toolchain that is the envy of any developer who’s seen it, but can’t use it.

➜ Watch on YouTube

Onyx is a distribute computation platform that helps crunching data in a hybrid (batch and stream) model. In this talk we explore the „ins-and-outs“ of Onyx and how to use to process data.

➜ Watch on YouTube
 

GraphQL is the worst form of API, except for all those other forms that have been tried from time to time. — Winston Churchill

GraphQL is an emerging standard for describing and querying APIs. In this talk, we’ll explore GraphQL, including its quirks and imperfections, and learn how, despite its copious flaws, it makes building user interfaces far simpler than REST (even with re-frame). GraphQL puts data, and operations on that data, first and foremost, and, like React, is a perfect fit for ClojureScript. If you’re building user interfaces with ClojureScript and React but not GraphQL, you’re doing it the hard way.

➜ Watch on YouTube
 

A recurring problem newcomers have with Clojure is that one must learn everything at once: the host language, and stack traces, and a new editor, and functional programming, and and and…. What if we shielded beginners from the complexity of tooling, stack traces, and programming language theory? What if we got out of their way and let them feel the power of programming for themselves, right away?

Our project, named for educational pioneer Maria Montessori, aims to delay as many of these obstacles as possible so that new coders can get right to playing, building, exploring, and sharing with code.

In this talk, we’ll demo our live „code playground“, explain its pedagogical philosophy, share how it worked with first-time coders at ClojureBridge Berlin, and brainstorm what’s next.

➜ Watch on YouTube
 

Writing unit tests in Clojure is easy, since testing pure functions is trivial. But the more high-level our tests become, the more they have to deal with the state and side-effects of your application. It becomes harder and harder to write proper tests. And worst of all: they are harder and harder to understand and to maintain, greatly diminishing the value of those tests as a documentation of your software.

On the other hand Acceptance Tests can be seen as the most important tests of our systems. They should be easy to read and to reason about. These tests have to clearly communicate the intent of the code under test.

In this talk I want to show how you can use Clojure language features to write acceptance tests, that clearly separate what is tested from how it is tested. These tests will be easy to grasp and to reason about, providing great value as an executable documentation of your systems.

➜ Watch on YouTube
 

Bear traps are those computer programming problems which are really, really tempting to dive into, but you know you just shouldn’t. They’re so common that we have multiple names for them: yak shaving, bikeshedding, bug lights, etc. These problems are especially troublesome because they generate so many solutions; we rarely approach them in organizations because we know they’re productivity cesspools.

In this talk we’ll go over one such problem: logging in Clojure/Java. We’ll cover the hoops, trials, and tribulations that CircleCI had to endure to arrive at a logging solution which… everyone in the engineering team still can’t agree on.

➜ Watch on YouTube
 

Explaining jokes to people is tough and explaining them to a computer is even tougher. Join in the adventure as I live code a fully compliant spec for humour. Hilarity may ensue. Bring beer.

The topic of static types in the Clojure community is often contentious, but why is that? Is it simply a matter of taste? Poor experience with other statically
typed languages? Or is there a deeper, underlying reason? If Clojure is such a powerful functional programming language, can we not have the choice?

And, what even is a type system anyway?

This talk will explore the Simply Typed Lambda Calculus, and it’s application in a „Hindley-Milner“ based type system with „full-program“ type inference. How it
can be mapped onto Clojure’s syntax, and how it can be used to „type-check“ a subset of Clojure code.

We’ll discuss how expressive static type systems compare to clojure.spec, and how they can be used as a tool to complement Clojure’s REPL driven workflow, not just to hinder the programmer. Finally we’ll discover strategies for mixing typed and untyped code.

➜ Watch on YouTube
 

Let’s take a look at the intersection of nature, basic AI and human-computer interaction. Can we be programming artists, using the browser as canvas and ClojureScript as our paint brush?

➜ Watch on YouTube
 

Originally specified in 1958, Lisp became the favored programming language for artificial intelligence (AI) research.

Clojure is a dialect of Lisp. AI is booming today.
So what is the situation about AI and clojure?
Let’s look into history, current moment and …future?

➜ Watch on YouTube
 

Random generation of structured data is becoming a big thing in Clojure: think spec, test.check, etc. In this talk I will explain, in a maths-light livecode-heavy way, what makes a good random generator. I will livecode a simple DSL and a very fast random generator for tree-shaped structures in Clojure(Script). I will use a powerful technique known as Boltzmann sampling. Sounds hard? You’ll see … it’s beautifully simple and incredibly efficient!

➜ Watch on YouTube
 

Clojure is a great language for just about everything. So, naturally, we want to teach it to others. How should we do this? Unfortunately, as natural as Clojure and its focus on functional programming feel to us, it is not easy to teach well. Moreover, Clojure itself is not the best tool for teaching – the language was designed for professional developers, as are its IDEs. So what to do when we want to enable a fellow developer to hack in your project, as a professional trainer, or to teach students? This talk will report on the insights gained by the Program by Design and DeinProgramm projects, the tools and materials they have produced, and how to apply them in your teaching. Three points will be important – effective teaching requires a didactic strategy built on systematic programming construction, languages that support that strategy, and tools and languages that have been adapted to the needs of beginners. With that in place, your students will be up to speed in Clojure in no time!

➜ Watch on YouTube
 

Once you’ve got a couple of Clojure katas under your belt you start to wonder how to structure an entire application. Where does the logic go? Where do you respond to HTTP requests? Where to connect to the database and how to pass the connection to code which needs it? Let’s see what the best practices are and which Clojure libraries can help us.

➜ Watch on YouTube
 

IoT platforms promise to connect thousands of „things“ to applications that enable users to take better decisions and control their daily activities. Building such platforms entails dealing with a set of new challenges, such as storing large amounts of device data and realtime data delivery to connected applications.

In this talk Andrei will cover how they built core parts of Geeny.io, an IoT platform, using Clojure. The talk will focus on how they store and realtime deliver large amounts of things data.

➜ Watch on YouTube
 

One of the most interesting aspects of Clojure and Lisps in general, is their apparent symbiosis with REPLs. Languages of the LISP family are generally
associated with REPLs or REPL-driven development. Just by themselves however, REPLs are rather extraordinary playgrounds for experimenting with code. If one were to have a vague idea about an implementation, a typical immediate reaction would be to „“try it in the REPL““.
Sadly however, they suffer from certain limitations that reduce their usability when one desires to use them with more structurally complex code. Multi-line code is an example of one such complexity.

The goal of this talk is to shortly present „“Omnia““, a new REPL that is explicitly tailored both for supporting structurally complex code, but also for enhancing the general idea of „“experimentation““.

➜ Watch on YouTube
 

There is already support for Clojure in multiple hosts (JVM, CLR and JS), each of these have their own uses cases, benefits and tradeoffs. This talk will be about what Clojure on the Erlang VM has to offer, where does it shine and where it is lacking, using the JVM as the main point of comparison.

➜ Watch on YouTube
 

How often do you print something to the console? Your application does not behave as expected, so some piece of data has an incorrect value, but which one is it? Debugging is hard, but luckily, we can build tools to make it easier. The key is to present the application data in a clear and browsable form. We want coding to be more enjoyable so that we spend less time on fixing bugs and more on building things.
With re-frame trace, you can have a look inside of your application’s data. Information about events, subscriptions and renderings are being displayed while interacting with the application and it is possible to inspect the current app-state.

➜ Watch on YouTube
 

Let’s face it, lack of self-care is a problem in the tech industry. We wear exhaustion like a badge of honor, promote unrealistic expectations about loyalty and often times we neglect our body, heart and mind’s most basic needs. In this talk, we’ll introduce the scope of the issue and explain how you can start building your own self-care toolkit.

➜ Watch on YouTube