Schedule


We will have two tracks in parallel. You can check out the amazing speakers and topics right here:

Time Big Hall (Ingeborg-Meisel Saal) H1 (Lecture Hall)
09:00 Registration  
09:50 Conference Opening  
10:00 Karsten Schmidt: "Keynote: Creative Clojure" -
10:45    
11:00 Hans Hübner: "Is Clojure an acceptable Lisp?" Andrei Ursan: "Concurrency’s Next Frontier: Actor Systems in Clojure"
11:30    
11:45 Marcin Bilski: "Growing Clojure systems. From functions to microservices." Jan Stępień: "Erlang in The Land of Lisp"
12:15    
12:30 Florian Sellmayr: "Build Pipelines as Code – Build your own build server with a few lines of Clojure" Tommi Reiman and Juho Teperi : "Wieldy remote apis with Kekkonen"
     
13:00 Lunch Break Lunch Break
     
13:45 Tom Hall: "Unlimited Register Machines, Gödelization and Universality" Joel Kuiper: "Evidence Based Medicine and Clojure"
14:15    
14:30 Simon Belak: "Doing data science with Clojure: the ugly, the sad, the joyful" Jelle Akkerman: "Experience report: Clojure on iOS with React Native"
15:00    
15:15 Michael Sperber: "Type Your Data!" Sebastian Bensusan: "Predictive testing: when your codebase learns from your users"
15:45 Coffee Break Coffee Break
16:15 Holger Schauer: "Dependency management in Clojure" Matt Huebert: "A Dataflow Tree"
16:45    
17:00 Michiel Trimpe: "Conversational Computing: How Okasaki proved McCarthy right once again" Lightning Talks
   
18:30 Evening Get-Together at Eschenbräu brewery!

Keynote: Creative Clojure

by Karsten Schmidt

For years now, Clojure has found steadily increasing traction and mindshare in web development, data processing, machine learning and other largely business oriented applications. However, after 7+ years of maturing, there’s still only a relatively small group of people exploring the language for more ‘creative’ applications. This talk will aim to change that and by way of various examples of my own work with the language, expose some of Clojure’s (and Clojurescript’s) features, giving us sometimes unique and generally beneficial tools for transforming our creative/explorative production processes, incl. defining domain-specific languages and working with low-level technologies (OpenCL/WebGL).

Furthermore, I will try to also situate Clojure in the bigger picture of a polyglot practice and touch upon the importance of concept transferral, showing how some of Clojure’s ideas are highly useful in other environments too and already have influenced thinking in these other communities.

About Karsten Schmidt

Karsten is a London based computational designer and researcher merging code, design, art & craft skills. Originally from East Germany and starting in the deep end of the early 8-bit demo scene, for the past 27+ years he’s been adopting a completely trans-disciplinary way of working and has been involved in a wide range of creative disciplines. With his practice PostSpectacular, he’s been actively exploring current possibilities at the intersection of software development, design, art and education and has been applying this mixture hands-on to a variety of fields: from ARM assembly & embedded programming to architecture, branding, generative design, data visualization, digital fabrication, games, interactive installations, motion graphics & music.

Karsten has been using Clojure daily since 2011, after working with Java for 15 years. Since 2009 he’s been teaching creative coding workshops internationally at various universities, incl. ETH Zurich, CIID Copenhagen, UID Umeå, Bezalel Academy Jerusalem, HEAD Geneva, UCP Porto. When not creating, he regularly travels the world consulting, lecturing and teaching workshops about coding, open source and employing code as creative tool. He is a prolific contributor (and founder) of several large open source projects, was an early contributor to the Processing.org project and books about programming and digital design.

His work has been featured and exhibited internationally, including MoMA & Whitney New York, London Design Museum, London Science Museum, Barbican Centre. His work is part of the Victoria & Albert Museum’s permanent collection.


Conversational Computing: How Okasaki proved McCarthy right once again

by Michiel Trimpe

Forty years after McCarthy discovered Lisp, the formal foundations of computing’s first half century, he published a little-known paper with an incomplete vision for the language of the future. Little did he know then that on the other side of the country Okasaki had just published the missing piece to this puzzle.

In this talk we’ll put those pieces together to understand McCarthy’s predictions for the future of computing; explore some of the things this would mean for the next half century of computing and take a look at some of the languages, such as Unison and Ox, which are building this vision of the future today.

About Michiel Trimpe

Michiel has been building virtual interactions for several years as the technical founder of Interactly. He was once given near-impossible requirements and worked on them until he realized it would take a purely functional lisp to make it happen. Ever since Rich got tantalizingly close to scratching that itch he’s been a proud Clojure evangelist working to turn those once impossible requirements into an everyday reality.


Dependency management in Clojure

by Holger Schauer

Dependencies between components are one of the primary drivers of the flexibility of any bigger applications. Clojure provides a number of tools to manage dependencies, some are built-in, some are built on libraries. We’ll look at basic building blocks like higher-order functions, multi-methods and protocols, but also at libraries like Stuart Sierra’s component.

About Holger Schauer

Holger is usually busy managing agile projects, drawing architecture diagrams or discussing requirements and solutions. Having worked in a variety of programming languages, he keeps coming back to Lisp languages that he has been using since the nineties.


Wieldy remote apis with Kekkonen

by Tommi Reiman and Juho Teperi

Today, most of the apps we build involve the browser and thus need an remoting layer between the ui and the backend. New Technology like Falcor, Relay and Om Next are leading the innovation in this space. Is REST dead? CQRS to the rescue? How should I build my next api?

Our 2 cents is Kekkonen, a fresh new multi-paradigm api library for Clojure.

In this talk, we’ll demonstrate how to build a reactive CQRS api (and api-docs) with Kekkonen for a complex simulated real-life case. We dive into advanced stuff like client side transactional call composition and local state & reasoning. We’ll also demo how Kekkonen integrates with Om Next & Reagent.

About Tommi Reiman and Juho Teperi

Tommi Reiman is a programmer and co-founder at Metosin. Into fp, lean and Open Source.

Juho Teperi Juho Teperi is a programmer at Metosin and an active Open Source contributor. Juho is writing his Master’s Thesis about CQRS and Event Streaming on Clojure.


Doing data science with Clojure: the ugly, the sad, the joyful

by Simon Belak

Having programmers do data science is terrible, if only everyone else were not even worse. The problem is of course tools. We seem to have settled on either: a bunch of disparate libraries thrown into a more or less agnostic IDE, or some point-and-click wonder which no matter how glossy, never seems to trully fit our domain once we get down to it. The dual lisp tradition of grow-your-own-language and grow-your-own-editor gives me hope there is a third way. This presentation is a meditation on how I approach data problems with Clojure, what I believe the process of doing data science should look like and the tools needed to get there. Some already exists (or can at least be bodged together); others can be made with relative ease (and we are already working on some of these); but a few will take a lot more hammock time.

About Simon Belak

Built my first computer out of Lego bricks and learned to program soon after. The combination of lisp and machine learning has put me on the path of always striving to make myself redundant if not outright obsolete. Currently working hard to become unneeded at goopti.com where I am turning the company toward being data-driven through and through; setting up our analytics infrastructure (end goal: provide any answer stemming from data in 2 min or less); and building our predictive-real time-risk hedging-superduper pricing engine.


Is Clojure an acceptable Lisp?

by Hans Hübner

Is Clojure even “a Lisp”? It certainly depends on your very own perspective to decide that, if it even matters to you. Clojure certainly shares a lot with other languages from the Lisp family. This talk will highlight some of the commonalities and differences between Common Lisp and Clojure, helping you decide whether you want to learn one or stick with the other.

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.


Predictive testing: when your codebase learns from your users

by Sebastian Bensusan

What if you could transform each user session into a regression test? What if you could check if your code changes will break your users’ behaviors?

That is the promise behind Predictive Testing, to make your codebase learn from your users.

About Sebastian Bensusan

Open Source contributor and independent Clojure(Script) programmer working out of Stockholm. In a very recent past life I was working with mechatronics, curly braces, and bits, I now enjoy s-expressions.


Unlimited Register Machines, Gödelization and Universality

by Tom Hall

Lot’s of people know about Turing Machines and the Lambda Calculus and that they both can express any computable function, but often don’t really understand what that means. An Unlimited Register Machine is a simple model of a computer, still quite idealised, that is turing equivalent also.

The philosopher Dan Dennett, in his recent book Intuition Pumps and Other Tools For Thinking, devotes a rather large section to URMs titled The Seven Secrets Of Computing Power Revealed. The hope is that by simulating the simplest possible register machine and building up complex algorithms you can understand what it means to compute and how a computer works.

I have been working on a Clojure DSL and Interpreter for a URM, with the goal of writing a small book that draws the straightest line possible towards universality and a proof of the undecidability of the halting problem.

In the this fast-paced talk I treat math(s) and ‘programming’ as equal citizens in terms of explaining the idea and end with a succinct (if somewhat problematic) concrete implementation of a Universal URM (via a neat way of Gödelizing programs, ie turning them into numbers)

About Tom Hall

Doing a mixture of Dev and Ops that might be called DevOps, mathematician, theatre fan, occasional mountaineer, part time runner, thoroughly nice chap, available in fine bookstores everywhere.


Evidence Based Medicine and Clojure

by Joel Kuiper

Evidence Based Medicine concerns itself with making sense of all the clinical data out there, from Randomized Controlled Trials to Electronic Patient Records. Unfortunately, this data is often much more messy than you’d expect, and the academic process is well … academic. In this talk the general problems faced within this field will be outlined, and we’ll dive into how forgotten technology such as Semantic Web offers a nice integration with Clojure’s data-driven approaches. We’ll also touch on how to communicate evidence effectively (“new literacy”) and avoid the same mistakes in current practice by using Lisp s-expressions as a GUI concept.

About Joel Kuiper

Once set out on doing academic research for a living, but then thought better of it. He has a Bachelor of Science degree in Artificial Intelligence from the University of Groningen, the Netherlands. Passionate about software development, user experience and machine learning.


Concurrency’s Next Frontier: Actor Systems in Clojure

by Andrei Ursan

Wunderlist, with millions of active users, continues to grow, bending its realtime sync technology to the limits. This pushed them to rethink and experiment with different architectural approaches. As a result Akka’s Actor System become a key component of theirs realtime architecture. However Actor Systems are not popular in the Clojure Ecosystem. In this talk Andrei will cover what they learned from using Actor Systems, what are their advantages and how to use them in Clojure.

About Andrei Ursan

Andrei is a Software Engineer @Microsoft, part of the polyglot team that builds Wunderlist. He’s now enjoying the world of Microservices and the challenges of scalability. Having worked with a number of programming languages he finds Clojure and its simplicity to be his preferred tool.


Experience report: Clojure on iOS with React Native

by Jelle Akkerman

We just released our iOS app built with Clojurescript on top of React Native in the App Store. YOLO tech or solid like a rock!? An experience report on building for iOS with Clojurescript.

About Jelle Akkerman

Full stack developer/designer currently working with Fy in Berlin. Previously worked for Dream Industries in Moscow and studied design in the Netherlands.


Growing Clojure systems. From functions to microservices.

by Marcin Bilski

Microservices are the new silver bullet. But how do you avoid the added overhead and more complicated deployment in the initial stages of your project?

With a bit of planning and sound development principles you can grow your system starting with a single process using simple functions through namespaces and components all the way to full blown microservices after the architecture stabilizes.

About Marcin Bilski

Marcin has been incurably addicted to programming all the way since Basic on Atari 65XE through C++, Ruby (starting with Rails 1.2) and a couple of other languages. His recent sweatheart he’s been in a serious relationship for 1.5 years is Clojure.

Currently, Marcin is a CTO at Designed.ly. The company has recently released Proton Red – a super-secure database backup of medical records; a Clojure/ClojureScript application backed by a set of microservices also written in Clojure and a Ruby on Rails administrative UI.

He is also the founder of Criticue.com – a feedback exchange platform for website designers and owners.

Marcin’s most recent contributions to open source include: Reforms - a Clojurescript library which lets you build beautiful data-binding, validating forms with Om, Reagent and Rum, om-event-bus - easy event handling for Om components and Pipes - a Clojure library that lets you chain processes and threads via pipes.

Marcin is active in the local community supporting and participating in startup- and software- related events including NetCamp and RailsGirls.

[MARCIN > In case you’re grinning right now imagining me dressed up in a skirt to covertly enroll to RailsGirls, a girl-only event, I have to shatter that image. I did participate several times, correct. As a coach. It turns out they don’t discriminate against coaches.]


Type Your Data!

by Michael Sperber

“The map is a stark data structure and everywhere it is passed there is much duplication of process.” –@msimoni

Clojure is untyped. But even if you’re a fervent defender of this defining quality of Clojure, you should use types to guide the design of your code. In particular, the PLT project’s “program by design” is a very effective methodology for constructing programs systematically. Coming from Racket, another untyped language, “program by design” can be applied in Clojure to great effect. The talk shows how it’s done.

Unfortunately, the idea of supporting types to organize data came to Clojure as an afterthought. Hence, support for it is less than optimal: The operations for collection types are a mess, and defrecord still views structured objects essentially as maps. Consequently, “program by design” chafes against Clojure’s idea of organizing data.

The talk gives a short introduction into “program by design”, shows how to apply it in Clojure, and exposes where Clojure went wrong on data.

About Michael Sperber

Michael Sperber is CTO of Active Group in Filderstadt, Germany. Mike is an internationally recognized expert in functional programming, with many publications and several books under his belt. Mike also maintains a strong interest in teaching programming, and has designed introductory courses for several German universities. He’s a co-organizer of the annual BOB developer conference, which immediately precedes :clojureD in Berlin.


Erlang in The Land of Lisp

by Jan Stępień

Clojure has been the fabric of our systems for over three years now. We’ve been taming its power, learning its quirks, and all in all becoming good old friends with Clojure. But we haven’t lost the urge to explore.

This talk is dedicated to lessons we’ve learned while designing, developing, and deploying to production our very first Erlang project. Erlang, despite its functional goodness, is a whole different world. Built on top of a virtual machine radically different than the JVM and designed to solve a very specific set of problems, it has taught us some valuable lessons about software.

The audience of this talk will learn about differences between Clojure and Erlang, both at the linguistic level as well as, even more importantly, at the level of underlying virtual machines. I’m going to discuss how Erlang challenges our methods of building systems in Clojure. I’ll use our new Erlang-based project as a source of concrete differences.

At the end of the talk attendees will see why the “Let It Crash” philosophy makes so much sense when building on top of rock-solid Erlang foundations.

About Jan Stępień

Jan is a software developer at stylefruits. He runs (½-)marathons and likes wandering in snowy Alpine wilderness. He’s got an MSc in CS from Warsaw University of Technology. He’s easily confused by the assignment operator.


Build Pipelines as Code – Build your own build server with a few lines of Clojure

by Florian Sellmayr

Your applications are code. Your infrastructure is code. And your pipeline? The thing that builds your artifacts, that runs your tests, that deploys your code into production? You probably still click around in your favorite build server to configure it! There is a better way: Build your own build server in clojure! It has power, flexibility, version control, dependency management, refactorings, tool support and testing! In this talk, I will show you how to do it, why clojure is a great fit and how a large organisation uses it successfully to release working software several times a day.

About Florian Sellmayr

Florian is a consultant with ThoughtWorks in Hamburg, working in Software Development and Platform Engineering. In his free time, he is the maintainer of LambdaCD, an open source toolbox to create build pipelines in Clojure code.


A Dataflow Tree

by Matt Huebert

Presentation of a dataflow programming environment in which a reactive graph of ClojureScript cells is exposed via an outliner interface in a web application.

About Matt Huebert

Quite addicted to making things. Designer/programmer, Canadian in Berlin, Recurse Center / Y Combinator alum.