We will have two tracks in parallel. To get updates about the schedule, check our official twitter account.

Time Gallery Loft
09:00 Registration
09:50 Conference Opening  
10:00 Welcome & Introduction  
10:30 Andrew Mcveigh: "Speculative Development: Leveraging clojure.spec to write correct, beautifully documented APIs" Philipp Meier: "On automatic generation of user interfaces"
11:15 Zach Oakes: "Writing Clojure at Runtime with Nightlight" Franka Schmidt: "Adventures in homoiconicity "
12:00 Christophe Grand: "Lost in transduction" Bozhidar Batsov: "The Elements of Style in Programming"
12:30 Lunch Break Lunch Break
13:15 Falko Riemenschneider: "Making design decisions in React-based ClojureScript web applications" Christian Weilbach: "Let's replicate state together"
14:00 Yannick Scherer: "Powerful Data Access in Clojure" Hans Hübner: "Identity in a World of Values"
14:45 Tom Hall: "The Symmetries of Things" Dave Liepmann: "Implementing the k-means jump method"
15:15 Coffee Break Coffee Break
15:45 Jan Stępień: "Testing with mutants" Daniel Škarda: "Debugging Clojure Code"
16:30 Damiano Rühl: "From zero to app in six weeks" Lisa Passing: "Making video games and learning Clojure"
17:15 Ruediger Gad: "Packet Capturing with the JVM and Clojure - Yes we can!" Dmitry Groshev: "How broken are our secrets? A foray into modern symmetric crypto and its state on JVM and in Clojure"
  Lightning Talks  
17:50 Zach Oakes: "Making Games at Runtime with ClojureScript"  
18:00 Michael Pershyn: "My 7 Surprises in Clojure"  
18:10 Sanel Zukan: "Monroe - Emacs client for Clojure REPL"  
18:20 Bozhidar Batsov: "Clojure: The Rough Edges"  
18:30 Michael Jerger: "DdaPallet - DevOps with Clojure"  
18:45 Get-Together at Hackendahl Destille!

Speculative Development: Leveraging clojure.spec to write correct, beautifully documented APIs

by Andrew Mcveigh

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.

About Andrew Mcveigh

Andrew is a software developer at uSwitch, working mostly in Clojure. He’s interested in experimenting with functional programming languages and writing interpreters for scheme-like languages.

The Elements of Style in Programming

by Bozhidar Batsov

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.

About Bozhidar Batsov

Bozhidar is the maintainer of CIDER and the editor of the community Clojure style guide. Most people would probably describe him as an Emacs zealot (and they would be right). He’s also quite fond of the Lisp family of languages, functional programming in general and Clojure in particular.

Believe it or not, Bozhidar has hobbies and interests outside the realm of computers, but we won’t bore with those here.

Let’s replicate state together

by Christian Weilbach

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.

About Christian Weilbach

Christian Weilbach is a professional programmer and master student in distributed systems and machine learning. He is deeply fascinated with artificial intelligence and neuroscience and is pursuing a master at the cross-roads of distributed machine learning. Since his studies of critical theory and philosophy he also pursues the challenge to materialize and communicate philosophical and political thoughts in form of information systems. Most importantly he has collaborated on Votorola (Java), an open drafting system and modelled economic planning on top of it. But to really follow up on that technically, he had to radically break with object oriented programming and turn to a pragmatic, but not too pragmatic, language built for distributed state management: Clojure :).

Lost in transduction

by Christophe Grand

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…

About Christophe Grand

Long-time Clojure enthusiast, independent software consultant/engineer, trainer. Co-author of Clojure Programming.

From zero to app in six weeks

by Damiano Rühl

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.

About Damiano Rühl

Born and raised in Berlin, Damiano has been working with Clojure professionally for over 2 years at Red Pineapple Media. Previously a front-end developer he finds ClojureScript for building user facing products especially interesting.

Debugging Clojure Code

by Daniel Škarda

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.

About Daniel Škarda

Dan is a software consultant and freelancer. Five years ago Clojure reignited his joy of programming. He organises Prague Lambda Meetup, Prague’s functional programming community. When Dan is not programming, he is learning and debugging his own mind.

Implementing the k-means jump method

by Dave Liepmann

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.

About Dave Liepmann

Dave is a freelance Clojure contractor based in Berlin.

How broken are our secrets? A foray into modern symmetric crypto and its state on JVM and in Clojure

by Dmitry Groshev

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.

About Dmitry Groshev

Switches programming languages for a living. Struggles hard to be better. Works in MEL Science, trying to make the world a better place, one function at a time. Failed a lot, hopes it will help later. Learner, procrastinator and wide knowledge believer.

Making design decisions in React-based ClojureScript web applications

by Falko Riemenschneider

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.

About Falko Riemenschneider

Falko works as software architect and project manager for doctronic, a Germany based IT company with strong competence and products for online information publishing. After his computer science diploma in 2000 he worked as developer, project manager and architect in numerous Java projects, both on client and on server side. He rediscovered his love for programming after he found out about Clojure in 2012.

Adventures in homoiconicity

by Franka Schmidt

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.

About Franka Schmidt

Franka is a developer currently living in Berlin. In the past two years she’s been helping to send millions of tasks and lists across the internet with the Wunderlist backend team. She also helps organize ClojureBridge Berlin workshop and likes cycling and making vegan food.

Identity in a World of Values

by Hans Hübner

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.

About Hans Hübner

Hans Hübner has been a professional programmer for three decades. After becoming proficient in the then-ubiquitous BASIC, he was an enthusiastic follower of the Object Orientation wave, mostly programming in C++. Perl led him into the dynamic programming language field, where he eventually picked up Common Lisp and applied it in a multitude of industrial projects for clients in various industries. He is now leading a small company developing Lisp and Clojure based applications in the healthcare space.

Testing with mutants

by Jan Stępień

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.

About Jan Stępień

Jan is a consultant at innoQ in Germany, where he works with people and with computers. He enjoys wandering in snowy Alpine wilderness and running around Munich. When the weather is bad he plays Go or dances instead.

Making video games and learning Clojure

by Lisa Passing

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.

About Lisa Passing

Lisa works as a frontend developer at Travis CI during the day. At night she can be found at Cryptoparties, study groups, game jams and meetups in Berlin.

On automatic generation of user interfaces

by Philipp Meier

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.

About Philipp Meier

Self-Employed web developer since the beginning of the web. Migrated from Java/J2EE to clojure in 2012 and not regretted it once. Author of liberator. Father of Four.

Packet Capturing with the JVM and Clojure - Yes we can!

by Ruediger Gad

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.

About Ruediger Gad

Ruediger Gad is a computer science and Open Source Software (OSS) enthusiast who was and still is involved in various OSS projects. He works as senior software engineer at Terma GmbH, Darmstadt, Germany in the field of space ground systems. He received a PhD degree (sobresaliente cum laude - best grade with honors) in Computer Science from the University of Cádiz, Spain and regularly publishes his evaluation and research prototypes as OSS. He spoke at various academic conferences and workshops in scope of the technical program and in keynotes. His research interests include Event-Driven Architecture (EDA), Complex Event Processing (CEP), computer networks, and software development and engineering.

The Symmetries of Things

by Tom Hall

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

About Tom Hall

Mathematician, part-time mountaineer, fine chap.

Powerful Data Access in Clojure

by Yannick Scherer

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.

About Yannick Scherer

Yannick is a Clojure software developer at stylefruits, responsible for a number of distributed backend services. After stumbling upon the language a few years back he was surprised to see that he quite liked it.

And as these boy-meets-language and language-meets-boy stories sometimes go, they fell in love.

Writing Clojure at Runtime with Nightlight

by Zach Oakes

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.

About Zach Oakes

Zach teaches Java and Clojure in Charleston, SC. He is the author of Nightcode, a Clojure IDE for beginners, and various other buggy projects. He hasn’t left the US since he was a baby, and this time it isn’t to avoid the feds.

Clojure: The Rough Edges

by Bozhidar Batsov

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.

About Bozhidar Batsov

Bozhidar is the maintainer of CIDER and the editor of the community Clojure style guide. Most people would probably describe him as an Emacs zealot (and they would be right). He’s also quite fond of the Lisp family of languages, functional programming in general and Clojure in particular.

Believe it or not, Bozhidar has hobbies and interests outside the realm of computers, but we won’t bore with those here.

DdaPallet - DevOps with Clojure

by Michael Jerger

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.

About Michael Jerger

Michael Jerger is the managing director of the meissa GmbH and maintainer of DDA pallet, a system Open Source DevOps system similar to puppet, salt or Ansible. In addition to Java applies his passion now also Clojure - it is simply faster…

My 7 Surprises in Clojure

by Michael Pershyn

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.

About Michael Pershyn

I am passionate software engineer with various rich experiences in software engineering over last 12 years.

Over last 4 years I enjoy building solutions with Storm, Kafka and Hadoop on high scale, using Clojure as my main tool. Initially using C++ as main language, I went through (de)evolution to C# & .NET stack with best OOP practices and patterns, then learned python and build complex systems with it… and then learned Clojure, Scala and functional programming.

I really enjoy solving complex problems, building and simplifying big systems in elegant way, using the appropriate tools to get things right the first time.

Monroe - Emacs client for Clojure REPL

by Sanel Zukan

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.

About Sanel Zukan

I’m a Lisp enthusiasts and have been lucky to use Clojure professionally for last 4 years, ranging from desktop & web applications up to big data, natural language processing and complex financial software.

With background in mathematics and theoretical computer science I enjoy applying theory, solving puzzles and practical problems.

Making Games at Runtime with ClojureScript

by Zach Oakes

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.

About Zach Oakes

Zach teaches Java and Clojure in Charleston, SC. He is the author of Nightcode, a Clojure IDE for beginners, and various other buggy projects. He hasn’t left the US since he was a baby, and this time it isn’t to avoid the feds.

The program from previous years is available for 2016 and 2015 in our archive.