Talks 2015


We will have two tracks in parallel. At least six of the talks will be recorded on video. Time slots may change slightly.

Check out the amazing programme:

</tr>
Time Big Hall (Ingeborg-Meisel Saal) H24 (Lecture Hall)
08:15 Registration  
08:50 Conference Opening  
09:00 Albrecht Schmidt: "Start your engine: My Clojure Bot in the Hello World Open 2014" Falko Riemenschneider: "JavaFX GUI architecture with Clojure core.async"
09:45    
10:00 Martin Klepsch: "Boot - Build Tooling For Clojure" Paulus Esterhazy and Christian Betz: "Data Processing with Spark and Clojure"
10:45    
11:00 Hugo Firth: "Continuous Delivery in Clojure" Meikel Brandmeyer: "Hay - a concatenative language"
11:45    
12:00 Konrad Szydlo: "The power of Datomic database" Stefan Kamphausen: "Instant Spaß with Instaparse - Generating Parsers With Clojure"
     
12:45 Small Lunch Small Lunch
     
13:30 Andreas 'Kungi' Klein: "Frameworkless Web Development in Clojure" Michael Klishin (via Video): "Scalable Way of Doing Open Source: The ClojureWerkz Story"
14:15    
14:30 Michael Sperber: "Taking purity to the limit in GUI programming with React and Reacl" Tobias Bayer: "Clojure Testing with Midje"
15:15    
15:30 Steffen Beyer: "Web Applications by Example: Client, Server, Development" Jan Stepien: "Generative Testing: Properties, State and Beyond"
16:15    
16:30 Jelle Akkerman: "Clojurescript and user interfaces: Simplicity yields possibilities" Burkhard Renz: "3 times Sudoku: Logic and Constraints in Clojure"
17:15    
Lightning Talks:
17:30 Philipp Meier: "Time travel is for beginners, let’s cross the streams"  
17:40 Peter Fessel: "Clarango - The ArangoDB Clojure Bridge"  
17:50 Jan Stepien: "Put Your Clojure in a Bubble"  
18:00 Halit Olali: "Functional In-Memory Data Grid"  
19:00 Evening Get-Together at Eschenbräu brewery!

3 times Sudoku: Logic and Constraints in Clojure

by Burkhard Renz

Sudoku ist a fine example to study programming logic and constraints. The talk presents three Clojure libraries and analyzes their ability to express such problems:

(1) Logic Workbench (lwb): a library for propositional and predicate logic, developed at the THM and used in courses.

(2) Kodkod in Clojure (kic): a wrapper in Clojure for Kodkod, the constraint solver build by Emina Torlak and used in the Alloy Analyzer.

(3) and of course core.logic: the port of miniKanren and the Clojure library for logic programming.

About Burkhard Renz

Burkhardt Renz studied mathematics (group theory in particular) in Tübingen and Frankfurt. He worked 12 years as a software developer and software architect. Since autumn 2000 he is teaching and doing research at the Technische Hochschule Mittelhessen (THM), spezialising in database systems, relational logic, software engineering and formal methods.


JavaFX GUI architecture with Clojure core.async

by Falko Riemenschneider

If you aim to create rich clients based on JavaFX that allow for unit testable presentation logic without using GUI robots then you’ll still face significant challenges.

The well-known approaches like PresentationModel or Model-View-Presenter do help, but it’s not easy to get the design right. And even then your UI logic will still be littered with hard to control callbacks.

Based on the core.async library Clojure allows a CSP programming style, so your system is made up of asynchronous, lightweight processes which communicate through channels.

Surprisingly, CSP brings quite some improvements to the architectural design of GUIs.

The talk will introduce you to the common pitfalls in classic OO GUI approaches and shows how to tackle some of these problems in a fundamentally simpler way.

About Falko Riemenschneider

Falko works as branch manager and software architect for itemis, a Germany based IT consulting company with strong competence on software process improvement via automation. After his computer science diploma 15 years ago, 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.


Functional In-Memory Data Grid

by Halit Olali

As we use clojure data structures as main building blocks in our applications, why not use them in a similar fashion within a distributed system? Building on top of a library called Hazelcast, we have distributed data structures, query engine and map reduce capabilities out of the box. With Clojure we can make this library more data centric. clj-hazelcast implements some wrappers for distributed data structures, entity listeners, map-reduce and makes it more clojure friendly. Using clj-hazelcast you can easily create a map distributed across JVM’s and query it. The talk contains a short introduction to the library, creating a distributed map data structure and running queries over it with the map-reduce. The aim is to create a ground for discussion and hopefully get some feedback and brainstorm with the attendees about how to make it better.

About Halit Olali

Halit is a software engineer with 9 years of experience, mainly worked on enterprise backend-middleware projects, high-traffic web services and big data solutions. He used Clojure in production for his own startup for 1.5 years. Currently he is working as a Senior BigData Engineer in Hamburg for Smaato, Leading Global Mobile Advertising RTB Exchange.


Put Your Clojure in a Bubble

by Jan Stepien

Live code reloading isn’t anything new these days. Erlang-based systems were capable of hot-swapping without downtime for years. Clojure’s dynamic features enable us to alter our functions at runtime as well, but results can be far from perfect. Reloading of namespaces isn’t atomic and may lead to unexpected behaviour. Let’s see what we can to address this problem. Let’s make hot swapping Clojure code a more predictable experience. Let’s put it in a bubble.

About Jan Stepien

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


The power of Datomic database

by Konrad Szydlo

Databases underlie literally all major applications. The dominant technology are relational databases. New trend of NoSQL DBs tries to disrupt the status quo. Datomic provides an innovative way to look at databases, architecture, storage and use of data. The talk is going to explore the philosophy behind Datomic, components of its architecture, benefits and trade-off of Datomic design and finally we are going to explore Datomic’s flavour of Datalog - logic programming language- that is used for querying the data.

This talk is available on Youtube

About Konrad Szydlo

Konrad is a psychology and computing graduate combining his passion for computing with psychological insights. He works as a full stack web-developer enhancing the web experience of sport fans. When not programming he’s swimming or practising judo.


Boot - Build Tooling For Clojure

by Martin Klepsch

For a long time built tooling in Clojure has been declarative. It served us well. But the declarative style also made it hard to compose more complex build processes out of smaller pieces. Boot provides a simple feature set that allows you to write these smaller build steps like Clojurescript or SASS compilation in a composable and reusable way. In this talk you’ll learn about the benefits of Boot and how it solves the problems arising from a less declarative style.

This talk is available on Youtube

About Martin Klepsch

Martin is an independent Clojure(script) programmer. In his free time he’s tinkering with open source, personal projects or sometimes playing Go. @martinklepsch on Twitter.


Hay - a concatenative language

by Meikel Brandmeyer

An embedded scripting language can often enhance the usability of an application. In particular in terms of automation. However just exposing the implementation language itself may or may not be feasible for a variety of reasons. A separate scripting language has to interface quite closely with the host language. We will explore such design constraints and implement a little language interfacing easily with Clojure.

About Meikel Brandmeyer

Meikel Brandmeyer is a clojurian of the first hour. He tours across Europe organising Clojure trainings and teaches the Gradle build system how to handle Clojure projects.


Taking purity to the limit in GUI programming with React and Reacl

by Michael Sperber

In recent years, JavaScript has become a serious portable front-end platform, particularly through the advent of implementations within the Java and .NET platforms. ClojureScript and Facebook’s React framework provide excellent abstractions on which to implement to implement rich user interfaces. However, while React builds on ideas from functional programming, it does not take those ideas to the limit: Component state is still manipulated imperatively, and React manipulates component identity in subtle and sometimes hard-to-debug ways. (The popular Om wrapper for React also provides an imperative API, despite ClojureScript’s affinity to immutability.) The talk describes Reacl, an alternative ClojureScript GUI framework based on React, which manipulates component state in a purely functional fashion, building on the ideas of Racket’s world/universe teachpacks. The resulting component model more clearly decouples the GUI from the underlying application than React/Om, allows arbitrary representations of application state, and overall provides a programming interface even more pleasant than React’s and Om’s. Active Group has used Reacl successfully in several commercial products.

This talk is available on Youtube

About Michael Sperber

Michael Sperber is CTO of Active Group in Filderstadt, Germany. Mike specializes in functional programming, and is an internationally recognized expert in the field, with many publications and several books under his belt. He was project editor of the R6RS standard for the Scheme programming language. Mike also maintains a strong interest in teaching introductory programming, and has designed introductory courses for several German universities. He is co-founder of the blog funktionale-programmierung.de, organizes the BOB conference (on the day before :clojured, also in Berlin!), and is a member of the steering committees of the International Conference on Functional Programming, the Workshop for Commercial Users of Functional Programming, and the Workshop on Functional Art, Music, Modelling and Design.


Instant Spaß with Instaparse - Generating Parsers With Clojure

by Stefan Kamphausen

Instaparse is a Clojure library for generating parsers from a context-free grammar. It implements a GLL parser, takes grammars in ABNF or EBNF and can create grammars at runtime. Without an additional compile step and due to the flexible input format and some useful additions, Instaparse is particularly pleasant to use. This talk introduces Instaparse with simple examples, continues with real-world examples and finally explores the dynamic nature of Instaparse.

About Stefan Kamphausen

Stefan is a long-time Lisp addict which is reflected by several articles and talks on Emacs and Clojure and his authoring of the first German Clojure book. Currently he works at Acrolinx in Berlin, focussing on DevOps and natural language processing.


Clojure Testing with Midje

by Tobias Bayer

Midje is an alternative testing framework for Clojure. It is easy to use and tests developed with Midje are well readable. This talk will give a short introduction to Midje and show you how to compose facts, checkers, checkables and prerequisites into an effective test suite for a Clojure program.

About Tobias Bayer

Tobias Bayer is a Senior Developer and Software Architect at inovex GmbH. He focuses on developing web applications with Java and mobile apps for iOS. Moreover, he has a strong interest in functional programming, especially in Clojure.


Start your engine: My Clojure Bot in the Hello World Open 2014

by Albrecht Schmidt

Programming Contests are a good and fun way for testing skills and learning new things. If done right they can also provide a glimpse into programming for a broader audience. With over 2500 competing teams and a broadcasted final in the finnish television, the Hello World Open 2014 was a pretty big one.

Backed by the code of my bot for this contest, we will have a look at principles like data orientation and to never leave your repl. Discussing advantages and disadvantages of those, we will see how it all comes together very well and why Clojure in my opinion is an excellent choice for contests like this.

About Albrecht Schmidt

Albrecht studies mathematics in Dresden. Right now he is working on his diploma thesis. Besides studying he has worked as a developer for a big german IT company. Since he learned about Clojure in 2009, his interest in computer science and programming languages has grown continuously.


Frameworkless Web Development in Clojure

by Andreas ‘Kungi’ Klein

Web frameworks like Rails, Zend and Django are ubiquitous in current generation web development. They dictate a well defined structure for web application development, but are much too large in scope for some applications. Microframeworks are a solution to this problem. They offer a very small feature set, often just enough to handle HTTP in a comfortable way.

Most Clojure web applications today don’t use any web framework at all. They are crafted from a carefully selected number of libraries fitting together, therefore building their own application specific ‘web framework’. Clojure’s emphasis on using primitive data structures, instead of hiding data in objects, makes it easy for different libraries to work together without any knowledge of one another.

This talk examines the commonalities in modern web frameworks and introduces Clojure libraries for all of these jobs. It is a primer on the most widely used tools for building web applications in Clojure.

This talk is available on Youtube

About Andreas ‘Kungi’ Klein

Andreas finished his MSc in CS from University of Heidelberg two years ago and plunged into the industry by co-founding DemandFlow GmbH together with his dad. For more than a year now he uses Clojure exclusively on the job. He creates software for sales and marketing automation and enjoys using core.async and the Clojure web stack.


Data Processing with Spark and Clojure

by Paulus Esterhazy and Christian Betz

Apache Spark is an engine for efficiently processing large amounts of data. We show how to apply the elegance of Clojure to Spark - fully exploiting the REPL and dynamic typing. There will be live coding using our gorillalabs/sparkling API.

In the presentation, we will of course introduce the core concepts of Spark, like resilient distributed data sets (RDD). And you will learn how the Spark concepts resembles those well-known from Clojure, like persistent data structures and functional programming.

Finally, we will provide some Do’s and Don’ts for you to kick off your Spark program based upon our experience.

About Paulus Esterhazy and Christian Betz

Being a LISP hacker for several years, and a Java-guy for some more, Chris turned to Clojure for production code in 2011. He’s been Project Lead, Software Architect, and VP Tech in the meantime, interested in AI and data-visualization.

Now, working on the heart of data driven marketing for Performance Media in Hamburg, he turned to Apache Spark for some Big Data jobs. Chris released the API-wrapper ‘chrisbetz/sparkling’ to fully exploit the power of his compute cluster.

Paulus Esterhazy Paulus is a philosophy PhD turned software engineer with an interest in functional programming and a penchant for hammock-driven development.

He currently works as Senior Web Developer at Red Pineapple Media in Berlin.


Clojurescript and user interfaces: Simplicity yields possibilities

by Jelle Akkerman

Being able to write complex frontend applications in a functional way gives you less headaches and more possibilities. In this talk I’ll show some cool extras which you get for free when building your rich frontend in Clojurescript.

This talk is available on Youtube

About Jelle Akkerman

Designer by heart, programmer in skills; minimalist in design and code. Currently working with Klekt, Hitfox Group and 3plet in Berlin. Previously worked for Dream Industries in Moscow and studied design in the Netherlands.


Continuous Delivery in Clojure

by Hugo Firth

Continuous delivery is often thought of as an extension to Agile software delivery - if you can build your application in a iterative way you’ll need to be able to get small changes into production quickly, easily and in a repeatable fashion. While continuous delivery is not specific to Clojure during this talk I’ll look at some of the different challenges you’ll likely encounter on the road to continuous delivery and different approaches you can take to solving these challenges. Some of these challenges will include: Testing - different types of testing and some good practises. Continuous Integration - Running all of your tests automatically for every check in. Deployment - What you should be deploying to your production environment, and configuration management for different environments. Infrastructure management - bringing version control to your Infrastructure and a touch of what’s going on in this massive space.

About Hugo Firth

Hugo is a software developer with the global consultancy ThoughtWorks. Hugo fell in love with Clojure during a project in 2012 and has since been heavily involved in the Brisbane Clojure community. Even on projects where Hugo is not writing Clojure there is always a strong emphasis on continuous delivery.


Generative Testing: Properties, State and Beyond

by Jan Stepien

The aim of the talk is introducing attendees to property-based testing in Clojure. The talk will discuss how does it compare to traditional testing methods and demonstrate its principles on simple examples. In order to bust the myth of inapplicability of property-based testing in a real-world setting we’ll bring up some use cases from the industry. In the second part of the talk we’ll move on from immutable, static properties to a more dynamic setting. We’ll see how tools present in the Clojure ecosystem allow us to validate stateful computations through generation of test scenarios. Finally, we’ll wander into the world of concurrency and automation of race conditions detection.

About Jan Stepien

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


Scalable Way of Doing Open Source: The ClojureWerkz Story

by Michael Klishin (via Video)

Many company and individuals these days release parts of their work as open source software. This benefits the entire software development community and brings are new set of challenges. Maintaining open source well takes time and effort. Abandoning a project can be very problematic for your users. How does one find a balance?

In this talk we’ll discuss how we did the impossible: make the users of more than 30 ClojureWerkz projects happy and still have a life.

About Michael Klishin (via Video)

Michael is an experienced software engineer interested in all things data and long time open source contributor.

After deciding to give this Clojure thing a try in 2011, he has ended up maintaining over 30 Clojure libraries, and contributed to many more.


Web Applications by Example: Client, Server, Development

by Steffen Beyer

In the course of this talk a complete working web application (a basic CMS) will be shown and explained, implementing a reactive UI (React.js) and live server updates (Sente), backed by a PostgreSQL database. A number of libraries will be presented to achieve this goal.

The application will be published under a liberal license to be used as foundation for your own developments.

This talk is available on Youtube

About Steffen Beyer

Tinkering with computers since early childhood, Steffen got to know a vast number of hardware and software technologies, including embedded systems, video streaming and systems security. Being a Rubyist for several years, a long-lasting attraction to LISP could finally be fulfilled by Clojure. He is also grateful to discuss topics like cooking, philosophy and music.


Time travel is for beginners, let’s cross the streams

by Philipp Meier

Clojure’s immutable data structures make undo easy, given you hold the application state in a global reference. But what when there are multiple users or just multiple revisions of a single user’s application state? I will show how to put methods like ‘Operational transformation’ and the algorithms behind the darcs distributed version control system into play and cross the streams timelines.

About Philipp Meier

Philip Meier is the author of clojure liberator, speaker at euroclojure 2013 and the conj 2013.


Clarango - The ArangoDB Clojure Bridge

by Peter Fessel

Clarango is the bridge between the rather young NoSQL database ArangoDB and Clojure. With ArangoDB aiming to be ‘the MySQL in NoSQL’ and an seemingly endless set of features, combining a document-oriented, key-value and graph approach in a single database, the future of this database seems to be bright. Clarango tries to give the developer a set of tools at hand to access the database in a ‘clojuresque’ way as much as possible. The talk will first introduce you to the main features of Clarango and how to use them in a practical example. Following that, some of the more experimental features will be pointed out.

About Peter Fessel

After graduating a bachelor in computer science and media (‘Medieninformatik’), now working as a frontend developer at Viasto, a Berlin startup offering a solution for asynchronous video interviewing. Studying a masters in practical computer science. In his free time hacking on things in Clojure and working on electronic music. www.peterfessel.com

Sponsors

Thanks again to our sponsors in 2015:

innoQ

itemis

PurelyFunctional.tv

futurice