by Markus Hjort
There are three hard things in load testing: how to write realistic simulations, how to generate load and how to collect meaningful results. The second one is especially hard problem to solve. We want to take everything out of the processing power we have but at the same time we want to generate exactly the expected load.
I have learned the hard way how to solve the puzzle by utilizing Clojure and core.async for load testing. In this talk I will share my experience from multiple projects.
More and more web applications are being developed as single page applications and the tools to do so are evolving rapidly to match the demand of developers.
This will be an overview of some of the current tools we have in the Clojure world to build SPAs with emphasis on building good behaved ones. I’ll cover handling of URLs, server side pre-rendering, re-frame/reagent, templating, deployment, etc.
Inspired by other music/audio programming languages such as PPMCK, LilyPond and ChucK, Alda aims to be a powerful and flexible programming language for the musician who wants to easily compose and generate music on the fly, using only a text editor.
Clojure proved to be an ideal language for building a language like Alda, not only because of its wealth of excellent libraries like Instaparse and Overtone, but also because of its Lispy transparency and facility for crafting DSLs.
by Nikola Peric
When a project approaches production questions about performance always surface. This talk tackles several real-world problems that have occurred while bringing a data-driven project to production, and walks through the problem solving approach to each.
by Colin Jones
Production apps behave in strange ways: traffic exceeds expectations, APIs time out, and failures are unpredictable. Systems tools like `top` and `vmstat` help but often don’t give us enough detail to find root causes. On the other hand, the JDK ships with dozens of command-line tools, including several specifically targeted at application monitoring. In this session, we’ll grab our utility belt and dive into a floundering Clojure application, using tools that the JDK provides out of the box.
by David Tsao
Spark, Hadoop, PostgreSQL/PostGIS: Clojure reaches into all the crevices where your data are by leveraging JVM interop. Yet, abilities to explore and and visualize data from within clojure are still underdeveloped compared to solutions that exist in the Python and R ecosystems.
This talk introduces Gyptis, a data visualization library for clojure/script designed to address this gap. Key concepts in the theory of statistical graphics will be emphasized.
Clojure and Cljs expose their core data structures and hosts using Protocols. However, typical webapps built on Clojure/Cljs have seldom used Protocols to abstract domain concepts. Thanks to Component, Om.Next, and the announcement of Swift as “Protocol Oriented Language” new abstractions are emerging.
In this talk I’ll discuss the basics of Protocols, the expression problem, and common patterns found in client and server libraries that demonstrate elegant abstractions.
by Alan Shaw
Re-frame is a sensible framework that runs on top of Reagent. But it allows you to spread control decisions throughout your codebase.
Statecharts, a powerful, clean generalization of state diagrams, give you a central, legible, declarative, executable specification of events and their handlers, down to whatever level of detail you find useful, for design, debugging, tracking, and post-crash analysis.
Let’s explore how you can use statecharts in your own app.
CIDER stands for Clojure Interactive Development Environment that Rocks and it’s one of the most widely used tools by Clojure hackers. And there’s one pretty crazy thing about it – it’s built on top of the “ancient” Emacs editor! We’ll quickly introduce CIDER and then we’ll start exploring its vast set of features. By the end of the talk people who haven’t used CIDER will likely be intrigued by it, and even experienced users will likely learn a thing or two.
Clojure can seem very complicated to learn, more so than it actually should be. After spending the last few years learning Clojure by teaching others, I share my experiences, approaches and tips for making the journey as effective, rewarding and as much fun as possible.
by JP Graham
Every language has many pre-defined core functions, so we can quickly get on building what we really want. This ease of use does come with a cost, though. Do we really know the power of the magic that we are wielding?
In this presentation we will look at how to implement our own versions of the Clojure functions reduce, count, filter, map and pmap. The pace will start gently for those with little Clojure experience to follow, but will then dive deep to provide a full understanding.
Clojure is powerful, simple and fun. Depending on how application state is managed, these 3 superpowers can either stay, go somewhat, or go completely. Apps we build for clients are quite different from tools and libraries on github; they are full of state. While there are frameworks that allow you to join the “application context party”, this talk will take a very different approach to manage and reload state with help of a tiny library called “mount“.
Many people ask about how to develop a functional mindset. It’s difficult if you’ve learned another paradigm and don’t know where to start. Functional thinking is a set of habits that you can train that will serve you well while programming in any language.
This talk will cover four important areas: minimize mutation, minimize implicit dependencies, isolate side-effects, and basic idioms. It draws on my experience pairing with and teaching beginners to functional programming.
Code editors work on flat text files, but code is highly structured. Editors will often try to enforce the correct structure, but at the end of the day, the code is still flat text: a structure from the earliest days of computers.
Representing code in a database offers interesting new options, such as semantics guarantees, structural editing, and versioning. This talk shows a system for converting Clojure to Datomic structures, along with a compiler that can read directly from the database.
by Jan Stępień
This talk is dedicated to lessons we’ve learned while designing, developing, and deploying to production our very first Erlang project. 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.
11th–12th February 2016