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.

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.

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.

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.

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.

➜ Watch on YouTube
 

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.

➜ Watch on YouTube
 

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.

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.

➜ Watch on YouTube
 

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.

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.

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.

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.

➜ Watch on YouTube
 

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.

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.

➜ Watch on YouTube
 

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.

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.

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.

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.

➜ Watch on YouTube
 

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.

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.