Clojure/west by Cognitect

Melanie Mitchell

Melanie Mitchell is Professor of Computer Science at Portland State University, and External Professor at the Santa Fe Institute. She has also held faculty or professional positions at the Univ. of Michigan, the Santa Fe Institute, Los Alamos National Lab, and the OGI School of Science and Engineering. She is the author or editor of five books and over 70 scholarly papers in the fields of artificial intelligence, cognitive science, and complex systems. Her most recent book, Complexity: A Guided Tour won the 2010 Phi Beta Kappa Science Book Award. Melanie directs the Santa Fe Institute's Complexity Explorer project for the field of complex systems.

Visual Situation Recognition: An Integration of Deep Networks and Analogy-Making

I will describe my current research on building computer systems that can recognize visual situations. While much effort in computer vision has focused on identifying isolated objects in images, what people actually do is recognize coherent situations—collections of objects and their interrelations that, taken together, correspond to a known concept, such as “a child’s birthday party”, or “a man walking a dog on the beach”, or “two people about to fight”, or “a blind person crossing the street”. Enabling computers to flexibly recognize visual situations would create a flood of important applications in fields as diverse as medical diagnosis, interpretation of scientific imagery, enhanced human-computer interaction, and personal information organization.

Situation recognition by humans may appear on the surface to be effortless, but it relies on a complex dynamic interplay among human abilities to perceive objects, systems of relationships among objects, and analogies with stored knowledge and memories. No computer vision system yet comes close to capturing these human abilities. In this talk I will describe research—currently in early stages—on bridging the gap between low-level perception and higher-level image understanding by integrating a cognitive model of concepts and analogy-making with a brain-inspired “deep network” for lower-level vision.

Alan Dipert

Adzerk

Micha Niskin

Adzerk

Boot Can Build It

Boot is a radically different JVM build tool written in Clojure. Where most build tools are their own environments, Boot is a library you can use on the JVM and within Clojure to automate builds the way you'd automate anything else: with programming. Boot is really easy to get started with and is growing in popularity. In our talk, we'll describe abstractions unique to boot, including pods, filesets, and tasks. We'll also demonstrate how they can be combined to solve complicated build problems in simple, straightforward ways, making new things possible and old things easy.

Anthony Marcar

WalmartLabs

Clojure at Scale

There are many resources to help you build Clojure applications. Most however use trivial examples that rarely span more than one project. What if you need to build a big clojure application comprising many projects? Over the three years that we've been using Clojure at WalmartLabs, we've had to figure this stuff out. In this session, I'll discuss some of the challenges we've faced scaling our team and code base as well as our experience using Clojure in the enterprise.

Boris Kourtoukov

OCAD University

Clojure, Sound, and Wearable Technology

Although sound is not uncommon within the Clojure community, this talk will present a more embodied approach to creating and interacting with it through wearables. The talk will consist of a live demo and a quick dive into the code that powers it.

The demo will contain live sound and video generated from a set of wearable sensors.

Code examples will focus on:

ClojureScript on Node.js communicating with the set of wearables and dealing with the flood of live data that they provide.

Clojure on the JVM transforms this stream into a multitude of possible events. These events are passed to Overtone and through it generate a highly responsive soundscape. At the same time, these events are also used to construct projected visuals.

This could not be achieved without Clojure's ability to inter-operate with its host platforms, provide tools for live prototyping, and the incredible diversity of interests within the Clojure community.

Work presented here stems from the Quipucamayoc project. It will culminate in 2016 with an interwoven performance between two communities on both sides of the Andes.

Brandon Bloom

Circle CI

Building CircleCI's Frontend With Om

CircleCI's frontend is a large, production-caliber, open-source Om project. CircleCI has long enjoyed the benefits of Clojure to power our CI platform, so we jumped at the opportunity to be ClojureScript + Om pioneers as well. Om represents both a significant step forward in UI development and considerable new opportunities for improvements. This talk will explore the benefits and challenges we've encountered, as well as provide a roadmap for using Om in your own projects.

Bruce Hauman

Dropzite LLC

Developing ClojureScript with Figwheel

Figwheel is a tool that helps ClojureScript programmers. It facilitates a live interactive programming workflow and much more. In this talk, I will go over the main ideas behind Figwheel and demonstrate how it works. I will explore several tricks to help people get the most out of using it. The goal of this talk is for attendees to walk away with a solid understanding of Figwheel and its use.

Christopher Small

Polis

Strange Coop: How Clojure saved my chickens from the evil racoons

Gather round and hear the harrowing tale of how Chris saved his Chickens from the evil raccoons using Clojure on a BeagleBone Black to automatically shut and lock the coop door at night and open it in the morning, using ambient light sensors to ascertain the time of day. Learn what it took to get Clojure running on the BBB, what some of the challenges were, and how Clojure handled for device programming. Get a sneak peak of libraries being extracted from this project, which you'll be able to use for general purpose device programming. Bask in glorious victory with Clojure and the dancing chickens.

Colin Fleming

Cursive

Debugging Clojure code with Cursive

Debugging Clojure code has traditionally been something of a black art. Cursive provides a complete JVM debugger based on the one provided in IntelliJ, including breakpoints, stepping and expression evaluation. In this talk, we'll see some of the features that Cursive provides to make debugging easy and discuss some tricks and tips for debugging Clojure code. We'll also discuss the JDI that the debugger is based on, and how some of its limitations affect debugging functional languages.

Dan Lidral-Porter

Puppet Labs

Generating Art in Many Worlds

Because they are computed, generative art systems necessarily explore a state space, but many of their state spaces exhibit wild variations in visual interestingness across their domain. This makes them unsatisfying to use in live performance, since they'll lapse into the boring parts and resetting the state to restore it is visually unpleasant.

In this talk I'll give an introduction to generative art with a focus on iterated fractal systems in particular, which have some absolutely fascinating portions of state space alongside very boring ones. I'll present Many Worlds, a system that visualizes state space traversals ahead of time remotely to allow the user to find a compelling state path in an interactive, iterative way

Elango Cheran

Google

Exploring Programming Clojure in Other Human Languages

While the software industry contemplates how to increase diversity in its ranks, what if Clojure could be the very tool to spread Clojure (and programming in general) to the world of non-English speakers? By seriously considering the macro perspective, we can see how simple ideas can lead to opportunities for lasting change. How far could we extend these efforts in Clojure-esque simplicity? Find out what makes Clojure uniquely suited to supporting other human languages.

Elena Machkasova

University of Minnesota, Morris

Adapting Clojure to an introductory CS classroom.

Lisps are a great starting point for teaching computer science since they allow introduction of essential concepts, such as functional abstraction, recursion, and higher-order functions. Clojure provides additional benefits for novice programmers due to its rich set of data structures and predefined functions, easy access to concurrent processing, and an active open source and industry community. However, in order to introduce Clojure in an introductory programming class for students with no programming experience, one has to address several challenges, such as non-beginner-friendly error messages and a lack of a beginner-friendly IDE. In this talk I will discuss progress that my students and I have made towards filling in the missing pieces for incorporating Clojure into an introductory class.

Fumiko Hanreich

World Singles, LLC

HoneySQL: SQL Queries as Clojure Data Structures

At World Singles, HoneySQL is used to construct over a hundred queries with a dozen filters on the fly for graphing purposes. HoneySQL allows you to represent SQL queries as Clojure data structures, which make it easier to read and debug, simpler to modify, and faster to add more queries. In this talk, we'll build example queries step-by-step with HoneySQL, walk you through from our graph menu setup to how a request is processed on the backend at runtime. We will also cover how filters and joins are handled as well as how the data is customized to be graphed (with highcharts on the front-end).
By the end of this talk, you will feel confident about writing elegant, modestly complex queries in Clojure.

Gary Fredericks

Groupon

Purely Random

Random number generation is unsettled territory in the Clojure ecosystem. The language's built-in mutable random number generator is not helpful for more purely functional approaches. An immutable, splittable RNG has an ideal interface, but is challenging to implement robustly. This talk will motivate the topic by showing how switching to splittable RNGs makes the implementation of test.check (the property-based testing library) more solid, and describe an implementation of a splittable RNG in Clojure based on recent research.

James MacAulay

Shopify

Composing interactive applications with Zelkova

Zelkova is a library for Functional Reactive Programming (FRP) that lets you compose your Clojure or ClojureScript application as a graph of "signals" defined using pure functions. It is heavily inspired by Elm, a language which embraces an innovative flavour of first-order FRP as its central paradigm.

This talk will show Zelkova in action, demonstrating how it can be used together with GUI libraries like Om and Reagent to solve practical problems while making state management unexpectedly fun.

Jeanine Adkisson

GoodGuide, Inc

Design and Prototype a Language in Clojure

Have you ever wanted to try your hand at designing and building a language, only to be driven away by ancient and obtuse tools? Clojure makes an excellent sandbox for quickly designing and prototyping new language ideas. This talk lays out a roadmap for the aspiring language inventor, from design to parsing to building a runtime.

John Hume

DRW Trading Group

Life of a Clojure Expression: a quick tour of Clojure internals

This talk will try to demystify the path between a simple piece of Clojure code and its execution. We'll follow a single expression-from text, to parsed form, to analyzed expression, to byte-code, to execution. We'll look at a lot of code, including some highlights from the 8500+ lines of love that are Compiler.java. Hopefully Clojurists will come out of the talk better understanding how their code works and more willing to dig into the guts the next time it doesn't work as they'd expect.

Leon Barrett

The Climate Corporation

Clojure Parallelism: Beyond Futures

One of the best parts about Clojure is its support for parallelism, and understanding that support (including the quirks) lets us do great things. This talk will explain Clojure parallelism by showing how future and pmap work, discussing their limitations, and introducing advanced alternatives like reducers, tesser, and claypoole. Come deref the future!

Luke VanderHart

Cognitect

The ReactJS Landscape

ReactJS! Om! Reagent! Quiescent! ReactJS and ensemble have made a big splash in the ClojureScript world in the past year, but what exactly is it all about? It's exciting, but it's moving so fast that it can be overwhelming to keep up with. This talk is a refresher on what ReactJS is, and why it is a good fit for ClojureScript. It concludes with a survey of the three primary CLJS interfaces to React (Om, Reagent and Quiescent) and provides code samples and walkthroughs of example applications, comparing and contrasting the different approaches.

Morgan Mullaney

Factual, Inc

Well I wouldn't want to make a *dys*functional game

Perhaps contrary to popular belief, there is a rich history of lisp and other functional languages in game development. How can the choice of programming language inform game design and empower the artist? What properties of lisp, and Clojure in particular, make it suitable for building games? This talk will start by considering the wisdom of our ancestors before diving into an exploration of the application of functional programming as engineering practice to the art of game design.

Nathan Sorenson

SparkFund

Domain Specific Type Systems

When writing DSLs, we sometimes forget we're not stuck with the type system of the host language. We may be in a situation where dynamic or gradual types don't give us the best power-to-weight ratio for our specific use case. This talk will show how macros enable localized forms of static checking that go beyond vanilla Clojure or core.typed. We'll tackle the gnarly problems of error messages (what good is a statically-checked error we can't understand?) and interoperability (what good is code that can't interact safely with other libraries?) Practicality will be paramount as we show these ideas at work in a typed query DSL for Datomic.

Nathaniel Smith

Puppet Labs

Ruth Linehan

Puppet Labs

One Binder to Rule Them All: Introduction to Trapperkeeper

Trapperkeeper is an open source services framework for large scale Clojure applications. Trapperkeeper is used for decomposing application code into reusable, swappable, and composable components. At Puppet Labs, we now use it as the basis for all of our backend development. Come hear an introduction to Trapperkeeper and a tour of all of its core services including our new transparent RPC capability.

Priyatam Mudivarti

Facjure LLC

Responsive Grids with Garden & Clojurescript

Clojurescript community has been slow to embrace Garden, a simple library for rendering CSS in Clojure/ClojureScript. Conceptually similar to Hiccup, Garden allows you to design pages and layouts like a functional programmer: plain-old data structures, functions, and abstractions.

In this talk I will focus on responsive grid techniques popularized by Bootstrap, Susy, Flexbox, followed by a live-coding session. We will explore how to implement fluid, responsive, nested, and even DIY grids with Garden, and render CSS3 on the server or client. We will end with a demo of a page designed in Garden, rendered with Om, to showcase the benefits of using Clojurescript all the way.

Robert Krahn

CDG Labs

Programming Clojure, Smalltalk-style

This talk will introduce the cloxp Clojure development kit. Cloxp aims to combine ideas first found in some of the original Smalltalk and Lisp environments with the possibilities of a modern web-based infrastructure. The tool is build around the fact that Clojure provides rich runtime and meta-programming facilities that enable a highly interactive workflow. Instead of being focused on a file-centric development approach, code exploration, modification, and versioning happens on the level of code entities.

Ron Toland

Sonian

Staying SAFE: a Foundation for Clojure Applications

Sonian's been using Clojure in production, at large scale, for 6 years. In that time, we've developed a common foundation for back-end Clojure services, embodied in our SAFE codebase.

For this talk, I'll walk through the major features of that foundation, explaining the reasons each was chosen and how they work together to make building new Clojure services easier.

Ryan Neufeld

Homegrown Labs

Simulant in anger; an experience report

As a community, we talk a lot about generative testing, especially in the small. What happens when we apply these approaches at the systems level? (Hint, it's Simulant!) In this talk, we'll explore how we applied Simulation Testing to a modern financial system. At the end, you'll have a cursory idea how to model and implement a simulation test for a multi-actor system.

Sean Johnson

Path

Pattern Matching in Clojure: Best Practices

Good Clojure practice emphasizes programming with immutable data. Another practice which can greatly simplify your code is declarative programming via pattern matching. Powerful pattern matching libraries such as core.match and defun give Clojure pattern matching abilities that rival Prolog and Erlang. This session is an experience report and best practices from extensive use of pattern matching libraries in recent open source Clojure projects.

Soren Macbeth

Yieldbot

Data Science on Clojure

Yieldbot's data platform is built on top of clojure. I will cover some of our experience using clojure for data (sciencing and platform). I will cover our two major open source projects, marceline, a clojure dsl for apache storm/trident, and flambo, a clojure dsl for apache spark.

Timothy Gardner

Kitchen Table Coders

Ramsey Nasser

Kitchen Table Coders

Games and 3D Graphics in Arcadia

Arcadia is the integration of Clojure into the Unity 3D game engine and development environment. Unity exports to nearly all major gaming platforms, while Clojure's functional data and capacity for live programming and optimizing macros provide unique benefits to game developers. We will discuss progress since our last release, the internals of the Arcadia compiler, and the ramifications of industrial game development in Clojure, with live usage demos.

Tom Faulhaber

Infolace

Creating Beautiful Spreadsheets with Data and Templates

Programmers hate Excel, but we often have to deliver results as spreadsheets. This is what we miss: used correctly Excel is a tool of tremendous expository power that can enable richer communication.

I'm going to show you what makes a spreadsheet beautiful and how you can create beautiful spreadsheets from pure Clojure data structures using the Excel templates library. Along the way, we'll discuss how to use spreadsheets to enhance understanding of quantitative data throughout our organizations.

Tyler Tallman

Breeze EHR

Composable Healthcare

To reach a diagnosis, a medical professional must now consider not only a sea of symptoms, but also an increasing number of factors: genotypes, functional genetics, proteomics, etc.. Caretakers, insurers, governments, medical researchers and most of all patients are looking technology satisfy their disparate goals. I will describe how our team is using Clojure, Datomic and React to provide a more humane medium for real-time collaboration. The primary focus of is to propose systems that scale well with high intrinsic sociological complexity. I will give a development log of how we are attempting to enable all parties in the healthcare ecosystem to create interactions, giving agency to the machine to participate on their behalf in the moment medical encounter.

Yoko Harada

Cognitect, Inc.

The Joys and Pains to Write a Clojure Curriculum for Beginners

Suppose you'd like to teach Clojure in your local community and are the first person to do--where would you start? You'd need a nice and clear curriculum with focused exercises and simple-but-engaging apps; however, soon, you'd find that writing such curriculum on your own is a difficult task. That's why ClojureBridge curriculum team has been collaborating on its own new Clojure curriculum, so that people from all backgrounds can enjoy coding in Clojure. It is as if the team is walking, sometimes staggering, on a long and winding road leads to a better curriculum for beginners. In this presentation, you'll learn what the curriculum team has accomplished so far, what work is on the horizon, and how you can offer your input, ideas, and help now.

Zach Tellman

Factual

Everything Will Flow

Queues, it seems, are back in fashion. This is exciting, as queues let us explore problem spaces that were unreachable by pure, immutable primitives.

But queues, and the execution models that drive them, are very different than what we're used to. Naive use of libraries like core.async will create brittle, unpredictable systems that fall over when we least expect.

This talk will cover the basics of queueing theory, and its practical application in Clojure systems large and small.

Zachary Kim

Zaarly

No-strings mobile app development for Clojure

Mobile development is the next great frontier for the Clojure ecosystem. Traditionally, mobile Clojure apps have been trapped in a WebView, resulting in limited capabilities and a less-than-steallar user experience. This is no longer the case. Come hear about production examples leveraging the existing Clojure ecosystem to build real, native mobile applications. No strings, caveats, or restrictions.