Krakow square

KRAKOW

June 26-27, 2014

A two day conference for the Clojure community

Conference Info

What

EuroClojure is the first 2-day, full-blown conference in Europe for the Clojure community. After an extremely successful 2013 edition in Berlin we are replicating in Poland this year! The conference will be held on Thursday 26th and Friday 27th June in Central Krakow, Poland.

Speakers

Rich is the author of Clojure and Datomic, and Metadata Partners co-founder. He is now the CTO of Cognitect

Rich Hickey

David Nolen is a software engineer for Cognitect. He enjoys making music, writing JavaScript, writing ClojureScript, and exploring new approaches to user interface programming.

David Nolen

Meta-eX Live Performance!

We are immensely happy to announce that Meta-eX will perform live at the end of day 1, during the social evening!!

Sam Aaron and Jonathan Graham are a live coding duo: improvising with code to weave immutable data structures into ephemeral sounds. As they riff with their code, projected live in front of their audience, the system responds instantly to their whim.


Check their website out for a taste of what's to come.

Programme

June 26th

8:00-8:50 Registrations + light breakfast
8:50-9:00 Opening
9:00-9:45
Components: Just Enough Structure - Stuart Sierra
Functional programming with immutable values is wonderful, but sooner or later every program has to deal with stateful, imperative tasks. A large program may need to manage dozens of stateful services: database connections, thread pools, network services, scheduled tasks, and caches. How do we do this in a functional programming model? All too often we fall back, almost by accident, into global mutable state, promiscuous sharing, and imperative spaghetti code.

To escape this quagmire, we need to recall some basic principles of both functional and object-oriented programming: referential transparency, immutable values, message-passing, encapsulation, and interface contracts. The Component pattern and its library implementation offer a minimal way to structure the stateful dependencies of a functional program.

This talk will cover the motivation for the Component pattern, its benefits and downsides, comparisons with other approaches, and how to use it in Clojure programs.
Stuart Sierra is a programmer, actor, musician, and writer. He lives in New York City and works for Cognitect. He is the co-author, with Luke VanderHart, of ClojureScript: Up and Running (O'Reilly) and Practical Clojure (Apress).
9:45-10:30
Clojure at a Post Office - Logan Campbell
For the last 6 months I've been working with a new team of about 10 devs. I will speak about what we've tried and learned. In particular:
  • Micro service architecture
  • Asynchronous web stack
    • To leverage async IO
    • Allow for hundreds of thousands of simultaneous connections per machine
  • Team dynamics
    • Experienced java devs
    • Who where interested in FP
    • But had mostly had exposure to scala
      • Through coursera
      • And through general java community interest
    • Have another Clojure dev
    • He's a fan of macros
    • A lot of questions come from memes in the Scala world
  • CQRS
    • Implementing indexes / materialised views with Cassandra
  • Re-writing legacy Java
  • Hiring
  • Deployment
    • We have a systems team
    • There's been fear, uncertainty and doubt
Logan is a consultant from Melbourne, where he runs the local functional programming user group
10:30-11:15
Multi-armed Bandit Optimisation in Clojure - Paul Ingles
You're in a casino with $100 ready to spend and faced with a wall of slot machines, each with a different probability of paying out. How do you spend your $100 optimally? This is the Multi-armed Bandit Problem: balancing learning about the world (exploration), and maximising your reward (exploitation).

Although a relatively well researched topic it has become popular recently as a more applicable alternative to running A/B tests (or randomised controlled trials) with web content: providing better test efficiency (less time spent with inferior arms) and emphasising experimentation (and by extension, exploitation) over time rather than in discrete steps. Multi-armed Bandit approaches have useful applications beyond replacing A/B testing; the model can also be applied, for example, when ranking items (products, articles etc.) and more broadly when learning how to optimally make choices.

We will explore the Multi-armed Bandit problem through some of the different algorithms, how they're implemented in the Clojure library bandit and how you can use them in your web applications.
11:15-11:30 Coffee Break
11:30-12:15
JVM Break Glass - Using a Clojure REPL to troubleshoot live Java/JVM processes - Mathieu Gauthron
When developing an application in a JVM language like Java, there are generally three main options to track a bug: 1) printing the state of various variables and analyse the logs 2) use of debugger to carry out step by step analysis of the code behaviour. 3) expose your objects, via a transport like JMX or a rest layer, to read or interact with them.

Some bugs only appear in production size environments. It can be slow or impractical to apply any of the above techniques to carry out an investigation. Instead, would it not be convenient to just be able to interact with the deployed JVMs individually and ask them questions or trigger some actions without having premeditated them?

An alternative exists: hooking a Clojure REPL to a Java application is all it takes to provide an interactive prompt onto the JVM. It can be used to launch all sorts of commands to introspect inside the content of the process e.g. to work out, at runtime, what values are contained inside objects. It can also be used to inject code, create new classes, instantiate objects, call methods and traverse various chains/collections of objects to carry out live debugging at run time. Even private members can be accessed. Anything that could be coded in Java is accessible without re-deployment thanks to the dynamic nature of the Clojure language.
Mathieu Gauthron is a distributed computing and DevOps expert, working day-to-day with a variety of technologies and languages. He provides solutions for large enterprise applications looking to scale with simplicity.

In his pursuit of reducing IT's ever growing complexity, his interest has turned towards the use of functional languages, the latest of which is Clojure. He believes the use of such tools can dramatically improve software development productivity and maintainability.
12:15-13:00
Using Clojure for Sentiment Analysis of the Twittersphere - Gary Crawford
Sentiment analysis of social media is a rapidly growing research area with an increasing number of interesting applications, for example, analysis of the Twittersphere has:
  • Predicted trends in Dow Jones IA 5 days ahead of realisation
  • Predicted spread of contagious disease 8 days ahead of medical confirmation
Such studies, often known a Mood of the Nation studies, are growing in complexity and their results offering ever increasing accuracy. We now have level of understanding which could allow us to derive meaningful insight from social media.

This talk will present a server application which consumes the Twitter stream, extracting key information and converting this into data prepared for high speed, in memory analytics. The result of this analysis is exposed through an web API and presented through a web frontend.

The application is written in Clojure, and utilises:
  • LMAX Disruptor for high throughput concurrency
  • Redis BitMaps for high performance, in-memory analytics
  • Raster based reverse geocoding using a server-side, in-memory application of D3
  • OpenNLP for part-of-speech tagging and lemmatisation
  • Compojure for exposing data and serving web requests
  • D3 for browser based visualisation of analysis (may become C2 if time allows...)
  • An Panas-t approach to sentiment analysis augmented to account for text speak, emoticons, acronyms etc.)
Although a lot of ground will be covered, this talk will be accessible by Clojurians of all levels as much of the content will focus on the architecture - i.e. anyone with a computing background will understand the technologies and concepts at play.
Gary discovered Clojure while researching technologies for developing a biomedical image analytics platform and was quickly captured by it's clean, concise, expressive ways. He is now fortunate enough to work with Clojure Monday to Friday, but still manages to sneak it into extra-curricular projects at any opportunity. He is a senior consultant with ThoughtWorks based in Sunny Scotland.
13:00-14:30 Lunch
14:30-15:15
Escaping DSL Hell By Having Parenthesis All The Way Down - Tom Hall
Domain Specific Languages, defined broadly, are everywhere. We will look at the good, the bad and the ugly and see where Lisp excels.

The world is buzzing with the idea of teaching everyone to program. Sometimes we create simpler languages and environments for learning but if we constrain them too much we can impoverish the learner.

For scientists we have R, Maple, Mathematica and Matlab etc - but how easy is it to build a web service, run Hadoop jobs, read files in some obscure format or talk to a datastore? Better to give them a productive environment to solve their problems quickly, with the full power of Clojure when they need.

Concretely we will reimagine netlogo and geomlab as Clojure DSLs. See how embedding them in Clojure makes the implementation easier, gives greater power to the user and enables extension.

We have a bunch of great embeddings already in Clojure: logic, stats, datalog, CSP - Let’s build more and not trap people in DSL Hell.
15:15-16:00
Schema & Swagger: making your Clojure web APIs more awesome - Tommi Reiman
This talk is for all programmers working or wanting to work with Clojure web APIs targeting non-Clojure clients. After the talk, everyone with leiningen, favorite editor (and internet) installed should/could have a simple Schema-driven, Swagger-enabled Clojure web API running on their laptops.

Most of the things covered don't require any special skills in Clojure, so should be good for beginners too.

In this presentation, I'll talk of the following:
  • Swagger specification - for describing and visualizing the web APIs
  • Ring-swagger, a library for implementing Swagger spec for Ring apps
  • Walkthrough of the Prismatic Schema library
    • how to create, validate and coerce pure Clojure data structures
    • creating schema-contracts in your applications
    • doing things you can't do with objects
    • Schema extensions
  • Using Schema in your web APIs
    • with Compojure-api, a lightweight DSL on top of Compojure
      • Using schemas to fuel the APIs
      • Adding Swagger-support
      • porting your Compojure API to use the compojure-api
      • extending the library for creating your own route DSLs
    • with fnhouse, a web lib from Prismatic
      • walkthrough of the concepts
      • adding Swagger-support with ring-swagger
  • Comparing the two libraries & approaches
  • How to get started
Tommi is a programmer and a co-founder at Metosin, a small software & consultancy company from Finland. Works mostly with Clojure, Javascript and Scala. With a mission to promote Clojure in the local scene & for the enterprise (Java & Scala) developers. Tries to find time to develop & contribute to open source thingies.
16:00-16:15 Coffee Break
16:15-17:00
The Compiler, the Runtime and other interesting "beasts" from the Clojure codebase - Renzo Borgatti
If you started developing Clojure you should also have realised how core.clj is a useful and important source of information along with the standard documentation. It will also come the time to look at how the runtime RT.java is implementing some functions that are not performing so well. Compiler.java and the compilation process is also an area worth looking at. But these are huge classes (2K+ loc) written in a funny style (for typical Java standards). Have you ever wondered why Clojure was designed like this? Why stack traces are somehow confusing? Would you like to contribute a patch but don't know where to start?

With this talk I'd like to take you on a journey through the Clojure sources. We'll see how Clojure was designed, what problems a Lisp on the JVM is typically facing with, what decisions were made and what was abandoned, what happens during initialization and what at runtime. Hopefully after the talk it should be clear to you why bigger projects are struggling with long startup times, why there is an elegant object model at the heart of a functional language and what improvements are in the pipeline to make Clojure better than ever.
I started programming professionally 15 years ago. I had the pleasure to work with many interesting languages like Ruby, Objective-C and enough Java. I currently work at the Mailonline, one of the biggest Clojure web apps out there. When not hacking at the keyboard I spend time with my kids and discover new cycling routes north of London.
17:00-18:00 Rich Hickey :-D
18:00-21:00 Drinks & nibbles at the venue, stay and mingle

June 27th

8:30-9:00 Light breakfast
9:00-10:00 David Nolen :-)
10:00-10:45
Why DevOps needs Clojure - Ali Asad Lotia
Although there is much disagreement on what the term DevOps represents, it is widely acknowledged that maintainable and reliable automation of infrastructure is a core principle. As applications evolve, their infrastructure requirements can also change. Applications and servers can be managed using configuration management and continuous integration/deployment systems but scaling policies, alarms, setting instance sizes, setting metadata such as tags aren't well covered by those tools and engineers need to work with service provider APIs to manage them.

Since Clojure encourages developers to work with data structures instead of objects and the facilities for manipulating data are so beautifully provided for in the language, we have found it to be an excellent fit for building long running services to audit the configuration of our infrastructure as well as for writing jobs to make one-time changes on an AWS hosted platform composed of over 700 instances.

Additionally the excellent Clojure libraries and services for stream processing such as Riemann and Storm provide much of the foundation on which to build tools that allow us to get better visibility into our platform through analysis of logs and metrics.

In this talk I will cover:
  • A brief overview of how the platform engineering team understands and approaches DevOps
  • How we handled infrastructure changes that weren't covered by configuration management
  • How Clojure was introduced into the mix and the observed productivity wins that assured us it was a great fit
  • An overview of some the tooling we have built with Clojure
  • Future work we are looking to do in Clojure
10:45-11:30
Taming Asynchronous Workflows with Functional Reactive Programming - Leonardo Borges
Responding to events is the very nature of most modern business applications. Whether it's responding to user input or network data, asynchronous programming aims to make systems more responsive and pleasant to use.

The way in which these ‘events’ are handled however can be the difference between a clean, easy to reason about codebase and a tangled mess. Who never got stuck in callback hell?

Functional Reactive Programming provides better abstractions in such scenarios.

It models your system’s behaviors as streams of time-varying values. In a functional setting, this allows streams to be filtered, mapped over, sampled, reduced and composed in a number of ways much like you compose pure functions. It is a declarative way to model asynchronous computations.

In this talk you’ll learn what’s in it for you: how you can use FRP, what its sweet spots are and what tools are available to you.
11:30-11:45 Coffee Break
11:45-12:30
Clortex: Real Machine Intelligence based on Neuroscience - Fergal Byrne
The goal of the talk is to introduce Jeff Hawkins' theories as a basis for intelligent computing; to describe how Clortex can be used for both research and development of new applications of Machine Intelligence, and finally to describe some of the key design decisions made in developing a large cortical information processor in Clojure. The attendee will learn about a new vision for understanding how the brain works; a system for developing genuinely intelligent software and hardware based on neuroscience, and how to use the Clojure ecosystem to address large-scale design and development issues.

The presentation will begin with a 3-minute demo of Clortex in action. The demo consists of:
  1. A visual example of Clortex processing and intelligently responding to a real-world problem.
  2. A simultaneous set of visualisations showing the inner workings of the neural regions inside Clortex.
  3. Live manipulation of the algorithms used, and a demonstration of how this affects learning and performance in Clortex.
The first section is a crash course in understanding the neocortex: the seat of intelligence in the brain.

The next section will briefly introduce Jeff Hawkins' theories of Hierarchical Temporal Memory and the Cortical Learning Algorithm, with the key principles of how the neocortex identifies spatial patterns in data and learns sequences of those patterns.

Following this is a brief history of efforts to implement systems based on HTM/CLA, including Numenta's NuPIC, Dileep George's Vicarious, CEPT's Cortical Engine for Text Processing, and a number of hardware projects currently in development at Sandia Labs etc.

The remainder of the talk is about Clortex:
  1. Key Design Goals in Clortex
  2. Architectural decisions
  3. Use of Clojure, Datomic, and various tools and libraries.
  4. How Clortex implements key aspects of HTM/CLA.
  5. Performance, scalability and flexibility.
  6. What can you use Clortex for?
  7. What's next for Clortex and HTM/CLA?
The talk will end with an introduction to the vibrant community growing up around HTM/CLA, NuPIC and Clortex, and a call to join in our effort to achieve true intelligent computing in the next few years.
Fergal has been working with computers since getting a 16Kb Sinclair Spectrum for Christmas in 1983. He's been involved in many areas of computing over the past 22 years, including building some of Europe's first content management and eCommerce websites in the '90s, Ireland's first online photo printing service in the early 2000's, and the re-engineering of an exam revision video service for Irish schoolkids in 2012. His current focus is on Machine Intelligence and Data Science, working with a new body of research into how the brain forms models of the world. Fergal is currently building a new kind of software which embodies Jeff Hawkins' theories of neocortical function and its application in Machine Intelligence. The ambition is to build a "VisiCalc for Machine Intelligence" using the unique power of Clojure and Datomic to deliver simple, understandable, scalable software. Clortex is an Open Source project which serves as a teaching tool, a desktop laboratory, and a production platform for delivering neocortex-inspired solutions for real-world problems.
12:30-13:15
Generative testing with clojure.test.check - Philip Potter
Change the way you think about tests!

Why write individual unit tests, when you can write code to generate as many tests as you like? Generative testing is a technique where you specify properties of the code under test, and the test framework generates test cases randomly to determine if the code under test satisfies the given property.

A well-written property can give much more confidence in much less code than traditional unit tests. By exhaustively searching the problem space, a generative test can find bugs that tradition unit tests would not. Then, through the magic of shrinking, a large and complex failing test input can be reduced to a minimal failing test case, giving meaningful information about what exactly caused the test to fail.

This talk will introduce generative testing using clojure.test.check and show how to get started with it. It will spend some time talking about properties, focusing on how to find useful properties to check. Writing good properties is a skill which takes time to acquire: it can be difficult to see how to write a property which says something useful about the desired behaviour. Therefore I plan to spend quite a bit of time talking about how to write useful properties.

If there is time, the talk will cover the future directions of generative testing, including testing concurrent programs by generating event schedules. This technique has been powerfully used in Erlang's PULSE tool to detect bugs in the eventual consistency property in Riak, and could clearly offer similar benefits to concurrent Clojure systems.
13:15-14:30 Lunch
14:30-15:15
The Hitchhiker's Guide to the Curry-Howard Correspondence - Chris Ford
Functions are proofs. Um, I can see how that might work. Go on.

Types are propositions. Really? In what sense?

In fact, a function is the proof of the proposition its type represents. Woah, you've lose me now.

Don't Panic!

The Curry-Howard Correspondence is an elegant bridge between the planet of logic and the planet of programming, and it's not actually that hard to understand.

In this talk I'll use the Idris dependently-typed functional programming language for examples, as its type system is sophisticated enough to construct interesting automated proofs simply by writing functions. This talk is not designed to convert you into a theoretical computer scientist, but to share with you a wonderful sight in your journey through the vast and peculiar universe of programming.

A familiarity with functional programming would be useful for appreciating this talk, but it will not require any significant prior study of theoretical computer science.
Chris is fascinated by computing, language and travel. Fortunately, programming is a portable profession, and Chris has worked his way around the world, including stops in Australia, the UK, India and Uganda. Chris is presently based in Glasgow, coding Clojure for ThoughtWorks.
15:15-16:00
Reactive data visualisations with Om - Anna Pawlicka
Facebook's React uses a virtual DOM diff implementation for high performance. It updates the view only when it's needed. But David Nolen's Om library (ClojureScript wrapper over React) goes even further. It stores application state in one place and passes "branches" of that state to a number of components. Data is immutable, and components are reusable. No more juggling around with JavaScript object literals. If anyone likes data as much as I do they will enjoy working with Om. It's a great tool for building user interfaces around your data.

This talk will show how to combine core.async, liberator and om with JavaScript visualisation libraries to create interactive charts and maps. I will walk everyone through how to:
  • Generate a resource that can be used in a route and use it to pull data for visualisations
  • Use om to create reusable components out of JavaScript libraries: dimple.js and leaflet.js
  • Create core.async channels and use them communicate user clicks and selections between those components, e.g. selection on a checkbox component triggers reloading of data on a chart component.
The talk will be a practical guide to building small web applications and will be accessible to Clojurians with a basic knowledge of Clojure and HTML.
Anna is a Data Engineer at Mastodon C. She crunches big data with Clojure, Hadoop and Cassandra and visualises it with open source technology. She's been a developer on a variety of projects ranging from banking to robotics. When she's not programming, she's either hiking, reading sci-fi or headbanging to Iron Maiden.
16:00-16:15 Coffee Break
16:15-17:00
The Face of Inspiration, or how Clojure helps bring Lisp to Python - Gergely Nagy
While on one hand, we have the features of the language itself and the many libraries and applications that were developed over the years, on the other hand, we have a topic we rarely talk about: how Clojure helps in areas where it isn't even there. Is it important to care about the world outside of Clojure? If so, why? And in what ways, how does Clojure and its community inspire others to do great things, even without the use of Clojure itself? In this talk, I would like to tell a little story of a language called Hy, which is a Lisp that compiles to Python AST - a different syntax for Python, with some syntactic sugar, if you wish. The tale would tell how Clojure - the language, the community, the tools and libraries around it - influenced Hy and some of the neat little things written in it.

This would be a cultural exploration, rather than a talk about deep technicalities or methods, although a few interesting - or twisted - bits of the deep internals could be explained, for educational purposes, and for comparing how Clojure accomplishes similar things. The presentation would also touch on the differences, and the "why"s behind them, to answer questions like "why isn't Hy a ClojureScript backend?", because the answers are mostly non-technical, and as such, a good fit into the presentations theme.
algernon's a hacker, a tiny mouse behind the keyboard, a free software enthusiast, Debian developer, contributor to ratpoison, syslog-ng and Hy, in no particular order. He writes C for a living, Clojure for sanity, and Hy for fun.
17:00-17:45
Assembling secure Clojure applications from re-usable parts - Malcolm Sparks
By its emphasis on integration via data rather than code, Clojure reduces the integration effort required by library users, thereby enabling the production of a vast number of small independent libraries. Freed from the responsibility of designing a good API integration API, library authors can focus on doing 'one thing well'.

However, there are currently few well-established idioms for assembling applications from this wealth of functionality. As Clojure adoption matures, Clojure systems are becoming larger, more complex and dependent on a greater number of libraries. So the question of how to assemble applications becomes more pertinent.

This talk will begin by introducing Stuart Sierra's component library, demonstrating some examples of its use. It will then show how integration points between components can be created using Clojure's protocols.

The talk will go on to explain the concept of modularity and describe a series of patterns, built upon these protocol-based integration points, for dynamically assembling systems, and configuring them for multiple environments.

It will then demonstrate these patterns using the familiar example of protecting a web-page from unauthorised access. This is an important example because the approach demonstrated addresses the problem of web security raised by Aaron Bedra and this year's ClojureWest conference. The solution will be composed in such a way as to preserve modularity, making it straight-forward to re-configure for different environments or to disable altogether. But more importantly, by creating from a set of re-usable components, such components can be improved in collaboration with other community developers, and thus reach a higher level of quality in comparison with bespoke code.

The talk will conclude by presenting the opportunity to rapidly assemble reliable systems out of re-usable parts, but crucially improving flexibility, choice and quality.
EuroClojure is dedicated to providing a harassment-free conference experience for everyone (regardless of gender, gender identity and expression, sexual orientation, disability, physical appearance, body size, race, or religion). We do not tolerate harassment of conference participants in any form. Sexual language and imagery is not appropriate for any conference venue, including talks. Conference participants violating these rules may be sanctioned or expelled from the conference without a refund at the discretion of the conference organizers.

Our anti-harassment policy

Harassment includes offensive verbal comments related to gender, gender identity and expression, sexual orientation, disability, physical appearance, body size, race, religion, sexual images in public spaces, deliberate intimidation, stalking, following, harassing photography or recording, sustained disruption of talks or other events, inappropriate physical contact, and unwelcome sexual attention. Participants asked to stop any harassing behavior are expected to comply immediately.

Sponsor desks or similar activities are also subject to the anti-harassment policy. In particular, sponsors should not use sexualized images, activities, or other material. Booth staff (including volunteers) should not use sexualized clothing/uniforms/costumes, or otherwise create a sexualized environment.

If a participant engages in harassing behavior, the conference organizers may take any action they deem appropriate, including warning the offender or expulsion from the conference with no refund. If you are being harassed, notice that someone else is being harassed, or have any other concerns, please contact a member of conference staff immediately.

Conference staff will be happy to help participants contact hotel/venue security or local law enforcement, provide escorts, or otherwise assist those experiencing harassment to feel safe for the duration of the conference. We value your attendance.

We expect participants to follow these rules at all conference venues and conference-related social events.

Sponsors

a UK-based price comparison service and a strong supporter of Clojure in commercial uses

We build simple tools to solve complex information problems.

a technological center for innovation and software development located in Krakow where deliver high-quality solutions based on the latest web, mobile and smart TV technologies, employing lightweight software development methodologies.

a software consultancy specialising in Clojure

 

the best place to share code

We build hubs that bring people and businesses together.

Operations Ideas Delivered.

Interested in becoming a sponsor? Please contact info@euroclojure.com to receive the prospectus

EuroClojure 2014 Tickets