Beyond code: Repository mining with Clojure
To understand large legacy systems we need to look beyond the current structure of the code. We need to understand both how the system evolves and how the people building it collaborate. In this session you'll learn about a Clojure application to mine social information such as communication paths, developer knowledge and hotspots from source code repositories (including Clojure itself). It's information you use to improve both the design and the people-side of your codebase. We'll also look at some interesting libraries like Incanter and Instaparse before we discuss the pros and cons of writing the tool in Clojure.
About the speaker: Adam combines degrees in engineering and psychology to get a different perspective on the challenges of software. In his role as software consultant, he works as both an architect and a programmer. Adam also writes open-source software in a variety of programming languages. He's the author of Your Code as a Crime Scene, has written the popular Lisp for the Web tutorial, and self-published a book on Patterns in C. His other interests include modern history, music and martial arts.
In the last few months we've implemented and open sourced the document management system Pepa.
In this presentation we'd like to showcase how such an end-user facing application can be built using the great open source libraries the Clojure ecosystem has to offer, e.g. Liberator, Stuart Sierra's Component, core.async, Transit, and Om.
We'll discuss how we implemented a push-enabled web interface, background workers, configuration, authorization, and several more aspects of a real-world application on this technology stack.
About the speakers: Moritz Heidkamp is head of development at bevuta IT GmbH of Cologne. He's a Lisp and functional programming enthusiast, has used Clojure professionally since around 2010 and is a core member the CHICKEN Scheme compiler project. On the internet he usually goes by the name DerGuteMoritz.
Moritz Ulrich is also a developer at bevuta IT GmbH and coincidentally also started using Clojure professionally since around 2010. He is a regular member of the local Clojure user group and enjoys functional programming as well as tinkering with electronics. His nickname is the-kenny.
Clojure-Android initiative is a group of tools and people that aim to make Clojure a first-class language for Android development. It is almost four years old now, and during these years it evolved from being a small hobby project into an ecosystem that some companies use professionally. This talk will present the current state of Clojure-Android, explain why and in what areas Clojure is better than Java for Android development and give a brief overview of Clojure-Android tools and libraries. It will also feature Project Skummet, an optimizing Clojure compiler for both JVM and Android, that can make an application load 3-4 times faster. The talk will conclude with a short demo where a very simple Clojure-Android app is created step by step.
About the speaker: My name is Alexander Yakushev, currently a postgraduate at Gjøvik University College. I'm the maintainer of Clojure-Android (CoA) initiative, under which I (co)developed a few projects: a CoA build tool, a toolkit library for idiomatic CoA development, developer tooling etc. I participated in three Google Summer of Codes on Clojure/dev behalf, two years working on CoA, and last year created Project Skummet - an optimizing compiler for Clojure for both JVM and Android.
Clojure is getting more and more traction, and more people use it for all kinds of backend processing. During last 3 years us in ClojureWerkz concentrated on making lives of backend developers simple. Today, Clojure is one of the best choices for Analytics and Data-Driven Backends.
I'll tell you about our motivation, experiences and our success story, how we made a data processing backend, currently pushing millions of messages per second, how Clojure made our development cycles and time-to-production shorter, lives of our devs better, and made our customers happier.
About the speaker: Alex is working on making backends for analytics and data processing. He's been involved with Clojure since 2011, and co-created ClojureWerkz, is actively involved in development and maintenance of many Clojure libraries. Spends most of free time reading Math and Probability Theory textbooks, figuring out how things work.
ClojureBridge was created to introduce women and other underrepresented groups to the Clojure language over a one day workshop, with the aim of increasing the diversity of Clojurian communities. This talk covers the practical steps required to organise a ClojureBridge event, based on the speaker's experience of organising the first European ClojureBridge and supporting and mentoring other organisers. It also looks at how Clojure might fit into a learner's programming education, and how to maximise the outcomes so that workshop attendees become active members of their local Clojure programming community. ClojureBridge events have so far been held in Edinburgh and London, with more planned for Solingen, Berlin, Bristol and Helsingborg.
About the speaker: Ali King was the lead organiser of the first ClojureBridge event held in Europe, in Edinburgh, Scotland. She also serves on the board of the ClojureBridge organisation and mentors other event organisers, as well as working in local code education and diversity initiatives in Scotland. Ali has recently joined FanDuel, where she will be slipping Clojure into Big Data applications wherever possible.
The ability of persistent data structures to participate in complex version graphs where many independent instances of a data structure are derived from a single original through the application of various update-like operations is crucial to many of the benefits that they bring to our day-to-day programming in Clojure.
Ctries, presented by Prokopec, Bronson, Bagwell and Odersky, bring this ability to the world of concurrently modifiable data structures. In addition, they are lock-free ("global progress guaranteed") and admit constant-time snapshots; and under the hood, they bear a striking resemblance to Clojure's transients.
This talk aims to examine some of the more interesting aspects of Ctries' inner workings and their relationship to the data structures built-in to Clojure, and to describe the API choices made by ctries.clj to make using them feel natural in Clojure.
About the speaker: Long-time contributor to all parts of ClojureScript, including the compiler and the core library; most notably, author of the ClojureScript ports of the persistent map and set types and PDS-related functionality such as transients. Author and maintainer of core.rrb-vector, data.avl and ctries.clj.
The talk will discuss how property-based testing compares to traditional testing methods and demonstrate its principles on simple examples. We will also see how does it fit into a TDD workflow. 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. Afterwards 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 the speaker: Jan is a backend developer at stylefruits. He runs (½-)marathons and likes wandering in snowy Alpine wilderness. He's got an MSc in CS from Warsaw University of Technology. He's easily confused by the assignment operator.
One of the most challenging aspects of microservices architectures is keeping the green light on the whole system operational status, and to quickly and effectively react and survive failures. This talk explores what it takes to successfully operate a full deployment of clojure microservices, and will demonstrate how to effectively employ available tools and techniques that will keep that 3am call away.
About the speaker: Carlo is a travelling technologist who started his life in Sardinia, lived and worked in 8 cities and 5 countries in the last 20 years, settling mainly in Amsterdam where he runs the Amsterdam Clojure meetup since 2010.
Over the past year and a half the ClojureScript community has collectively become the industry's leading experts on building effective and compelling user experiences over immutable data. However, while immutability and functional programming dramatically reduce the complexity of client side code there is more work left to do, especially at the boundary between clients and servers. There are a growing set of technologies and ideas that can complete the story that deserve assessment. We'll examine Relay (Facebook), JSONGraph (Netflix), and Datomic (Cognitect) and see how these technologies are guiding the design of the next version of Om, a popular React binding for ClojureScript.
A deep understanding of Clojure, how it executes, and the runtime it sits on is a whole lot of work to acquire. But there's a shortcut. Doing performance work forces you to peel apart the layers of abstraction your software sits on, and understand what really goes on. This is an exploration of war stories from performance tuning a production Clojure application, with an eye towards surprising lessons about Clojure and the runtime it executes on: the JVM.
About the speaker: Tom Crayford has been using Clojure since before Leiningen was released. He runs Yeller, which tracks the exceptions your Clojure apps hit in production and helps you fix them.
A case study covering an intense project to deliver a major UK property portal in under ten months. We will look at the background of the project, the journey of getting an experienced team together, the technology selection process, the architecture, and challenges facing during delivery. We will look at lessons learned, and the pros and cons that Clojure brought to the table.
About the speaker: Jon Pither has led development of large Clojure projects at an Investment Bank, an online newspaper website, a major property portal, and is now working on various other Clojure projects. Jon is a co-founder of JUXT, a consultancy specialising in using Clojure.
At Atlassian we are currently building services to enable realtime collaboration in both new and existing products. Of all technologies we could have chosen from we picked Clojure and ClojureScript.
In this talk I will share the reasons for this choice, the benefits of running Clojure both on the server and on the client-side as well as our clustering solution built on top of core.async.
About the speaker: Leonardo Borges is a programming languages enthusiast who loves writing code, contributing to open source software, and speaking on subjects he feels strongly about.
After nearly 5 years of consulting at ThoughtWorks he is now a senior software engineer at Atlassian where he uses Clojure and ClojureScript to build real-time collaborative editing technology.
He is the author of "Clojure Reactive Programming" and founder of the Sydney Clojure User Group.
Often times your business logic relies on remote data that you need to fetch from different sources: databases, caches, web services or 3rd party APIs, and you can't mess things up. You need to keep your business logic clear of low-level details while performing efficiently: fetching data in parallel, batching requests, handling failures, retries, and so forth. There are a few projects that aim to solve this problem: Haxl (open-source Haskell library from Facebook) and Stitch (Scala library from Twitter, not open-sourced yet but a few talks are available). Both projects give you the ability to access remote data sources in a concise and consistent way, while the library handles batching and overlapping requests to multiple data sources behind the scenes. How can you solve the same problem with Clojure code? In this talk we'll go over concrete examples and see how to achieve the same results with Clojure.
About the speaker: CTO at Attendify. Mostly Clojure engineer, but work also with Scala and Erlang on a regular basis. I'm passionate about distributed systems, smart compilers and useful type systems. I work hard to make concurrent and parallel programming simple and enjoyable. I'm active open source contributor.
Immutable, persistent data structures are at the heart of Clojure's philosophy. It is instructive to see how these are implemented, to appreciate the trade-offs between persistence and performance. Lets explore the key ideas that led to effective, practical implementations of these data structures. There will be animations that should help clarify key concepts!
About the speaker: Mohit is the co-founder of Dev To Prod - a startup focused on teaching DevOps tools, techniques and culture. He has been a Clojure programmer at Helpshift, a Ruby programmer at Thoughtworks and a Java code monkey at Oracle. He has worked on building mobile scale websites, enterprise solutions and an event processing server. He is interested in languages (human and computer), distributed systems and pop psychology. He has also been a teacher and a backpacker in a past life.
Most complex distributed systems happen by accident, as an evolution ofa design initially thought simple. Not everyone wants to be involved in getting the semantics of a distributed system right. In this talk, we'll explore how a clever mix of Clojure, and Apache Mesos can help simplify and decouple the inner workings of distributed systems.This talk will give a short introduction to distributed systems and examples of infrastructure components that rapidly grow into behemoths. A mesos overview will be given to finish off with an example scheduler interaction with clojure and core.match for decision making.
About the speaker: Pierre-Yves is CTO at exoscale where he is responsible for architecture and strategic technology choices, relying on experience in the architecture of very large corporate system as well as technical product design in several startups. Pierre-Yves is an active member of the open-source community with key contributions to OpenBSD, collectd and riemann and is the author of cyanite and pithos
Relational programming, or logic programming, is a paradigm that exhibits remarkable and powerful properties, to the extent that its implementation seems frightfully daunting to the layman. μKanren is a minimal relational language that seeks to strip the paradigm down to its core, leaving us with a succinct and elegant set of primitives on top of which we can rebuild even the most powerful relational constructs.
In this talk, we will explore the μKanren language by implementing it from first principles in a simple functional programming language, going on to demonstrate how you can assemble these simple building blocks into a semblance of its richer parent, miniKanren, and maybe solve a logic puzzle or two to make sure it's working as advertised.
The μKanren paper, and the original μKanren implementation, were authored by Jason Hemann and Daniel P. Friedman. The paper is available at http://webyrd.net/scheme-2013/papers/HemannMuKanren2013.pdf, and the Scheme implementation at https://github.com/jasonhemann/microKanren
Datomic decouples transaction, storage, and query, and puts query right in an application's process. Sounds great from an architectural perspective, but how does that play out in our Clojure applications? In this talk we'll look at the query, entity, and pull APIs, and the impact of local data on the development process and the resulting code.
About the speaker: David creates and improves software at Cognitect by day, and plays samba and choro on his cavaquinho by night. Also, even though Datomic will remember the good old days if David ever changes his mind, David likes pizza.