We will have two tracks in parallel. The detailed schedule is still being worked on. To get updates about the schedule, check our official twitter account.
The prelimiary outline of the schedule looks like this:
09:50 Conference Opening
13:00 Lunch Break
15:45 Coffee Break
17:00 Lightning Talks
18:30 Evening Get Together
But, you can already check out the growing list of the amazing speakers and topics right here:
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.
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.
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.
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.
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.
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 :).
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…
Long-time Clojure enthusiast, independent software consultant/engineer, trainer. Co-author of Clojure Programming.
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.
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.
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.
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.
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.
Dave is a freelance Clojure contractor based in Berlin.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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 is lots of fun and frustrating at times, and so can learning Clojure be. So why not combine both for maximum effect?
This is a talk about my experiences along the way.
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.
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.
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.
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.
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.
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
Mathematician, part-time mountaineer, fine chap.
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.
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.
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.
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.