Clojure/west by Cognitect

Alex Kehayias

Shareablee

Functional Game Engine Design for the Web

Sharing the many joys and challenges of building a game engine in a functional style using Clojure and ClojureScript. Over the course of 2+ years, the speaker has been actively writing (and rewriting) a functional game engine to find the ideal combination of a quick feedback loop, testing with data, and performance. Join in the sorrows and triumphs of bringing functional programming to web-based game development for fun and zero profit!

Allison Carter

Houseplans

From Fluxus to Functional: A Journey Through Interactive Art

The concept of what makes something a work of art has always been a contentious topic. As technology has advanced, so have the ideas of what constitutes art and the mediums with which art is created. From Clojure performance artists REPL Electric and Meta-ex to artists of the Fluxus movement, the medium and act of creation has been intrinsically tied to the piece itself. Moving backwards through history from today's interactive works created with Clojure and Overtone to Lisp AI painters of the 90s and multimedia auteurs of the 70s, let's explore how art has evolved into its current landscape.

Amie Kuttruff

formerly Little Bird, currently Jama Software

Deepen and Diversify the Clojure Community with Jr Engineers

The simplicity of the Clojure language and the supportive, collaborative spirit of its community played a pivotal role in my success as a junior engineer. I felt frustrated with cryptic 'method_missing' stack traces in my first years of programming, and Clojure reshaped the way I saw code and data. We will examine elements of the language that help and hinder newcomers, ways in which teams can better support junior developers, and how companies can create value by investing in upcoming talent. Living wage apprenticeships for developers can provide opportunities for a richer, more diverse tech industry.

Aysylu Greenberg

Google

(+ Loom (years 2))

Loom is an open-source Clojure library that provides many graph algorithms and visualizations. Loom's graph API focuses on generality and simplicity of integration, which enables other graph representations to be ported to Loom. In this talk, we'll look at how Loom's API and graph implementations evolved in the past 2 years since being presented at Clojure/West 2014. We'll also discuss complexities of maintaining an open-source library.

Bryce Covert

LIFFFT

USE lisp WITH game - Making an Adventure Game with Clojure

Old-school adventure games were infamous for their mind-bending logic. While you might pull quite a bit of hair playing one, writing one can be a lot more fun, especially when written in Clojure. We will embark on a quest, examining how some of Clojure's features, libraries, and functional paradigms can bring some sanity and simplicity into the otherwise complex world of game development. We'll look at how to model SCUMM-style dialogue trees, write in-game cutscene scripts, and build a game while it's running using an nREPL server.

Christopher Small

ThoughtNode Software

Datalog all the way down

This talk is about building Clojure/Clojurescript web applications with Datomic and DataScript. In addition to covering the basics of syncing data between client and server, we'll look at how reactive Datalog queries simplify front end code, how Datomic's flexible and queryable schema lets us describe UI with data, and how we can handle authorization in this setting. In closing, we'll reflect on the big picture of this architecture in relation to current trends in FRP.

Claire Alvis

SparkFund

Creating DSLs - a tale of spec-tacular success and failure

Datomic has a fantastic Clojure API that is simple and data-driven, but too low level to directly express certain restrictions on the shape and types of data living on the database.

spec-tacular is a DSL that lives between Clojure and Datomic and enforces extra restrictions on data types (via a specification language) by providing concise syntactic shortcuts to create, update, and query those well-typed entities from Clojure. Unfortunately, the resulting language (as implemented) has unreasonable restrictions that do not compensate for the corresponding loss of expressive power.

In this talk, I'll present the design of spec-tacular and describe how well it lives up to my vision of a healthy layer of abstraction over Datomic. I'll discuss the success of spec-tacular features in production, and trace failures back to poor language design.

Daniel Higginbotham

Adzerk

Parallel Programming, Fork/Join, and Reducers

If you don't know your work/span from your fork/join, this talk is for you! By attending this introduction to "thinking parallel," you'll learn why parallel programming matters, how to think about performance, and how to tackle real-world concerns. You'll learn about how the fork/join framework embodies best practices. And of course, you'll learn how Clojure implements these ideas with reducers.

Devon Peticolas

Chartbeat

One Million Clicks per Minute with Kafka and Clojure

We feed 300K messages per second into Kafka. This stream describes the activity of tens of millions of users on our customers' sites. This talk follows the evolution of our Kafka and Clojure use, and the lessons we learned as we built a contextual site overlay which tracks internal traffic at a rate of over one million clicks per minute in real time.

Donevan Dolby

Base2 Solutions

Managing one of the world's largest Clojure code bases

This talk discusses the development of a feature-rich onboard application for the Boeing 737 Max. We structured our application with a service framework and message queues to enable communication between disparate parts of the service while preserving separation of concerns.

The onboard diagnostic system designed for the Boeing 737 MAX checks and reports on over 6,000 faults, giving airplane technicians and maintenance crew a critical window to the health and performance of the aircraft.

Tom Marble

Paul Robertson

Model based programming in PAMELA

We'll introduce PAMELA (Probabalistic Advanced Modeling and Execution Learning Architecture) which is a new declarative language and framework for process modeling. We'll also give a live demo of PLANVIZ - the PAMELA visualization tool to visualize Temporal Planning Networks (TPNs) and Hierarchical Task Networks (HTNs). PLANVIZ is written in ClojureScript, is based on om.text and leverages schema to parse and render TPNs and HTNs as interactive, resolution independent SVG graphs. Multiple users can collaboratively view the same perspective of a graph and even watch progress as the temporal plan is executed in real time. Dynamic Object Language Labs uses PAMELA to support automated reasoning about systems, to plan for mission implementations, and to diagnose and track model state at run time.

Ghadi Shayban

PokitDok

Parsing Text with a Virtual Machine

As the saying goes, all the good ideas in computer science came from the 1970s. We'll explore a new library for parsing text that calls upon an old, unconventional approach: compiling parsers to custom bytecode and then running it through an interpreter.  Along the way, we'll learn about how PEGs fit a sweet spot between regular expressions and heavier parsers, and how Clojure is an ideal language for writing simple compilers.

Jack Dubie

Ladder Life

Fast full stack testing in om.next

Distributed systems are hard. om.next makes them simpler making state transfer and state transitions idiomatic. With synchronization out of the way a developer can finally focus on testing business logic. In this talk we will explore a lightweight method of property based testing for the business logic that spans client and server. Talk will include a demo using your favorite tools like om.next, component, datomic, test.check, and the reader conditional.

Jonathan Boston

Cicayda

Caleb Phillips

Cicayda

Building a Legal Data Service with Clojure

In the process of litigation, parties must sift through and classify massive piles of data - anything from emails to spreadsheets with millions of rows to entire databases.

In this experience report, I'll share how Cicayda has used the familiar principles of Clojure - immutability by default, simplicity, and thinking concurrently - to build a robust, multi-tenant cloud hosted SaaS that allows clients to manage diverse data and load profiles. Datomic has given us a ton of leverage, including being able to track how things happened and taking read scaling for granted. ClojureScript has provided us with a unified development environment on both sides of the wire and has helped us push toward a data-oriented UI.

I'll also talk about some of the challenges we've encountered with a write-heavy application on top of Datomic and the various generations of UI libraries that live in our app.

Katherine Fellows

Simple

Anna Pawlicka

Walmart eCommerce

ClojureBridge in Practice

ClojureBridge is a nonprofit organization that provides free, inclusive workshops in Clojure to women. Over the past two years, the Clojure community has written a curriculum, developed an organizing guide, and started teaching workshops--but, how have those workshops played out in practice? In this talk, we'll look at what it takes to organize and run a successful ClojureBridge workshop, hearing from those who have done it, themselves!

Mario Aquino

The Climate Corporation

The Age of Talkies

We are at the dawn of a new paradigm of human-computer interaction, where humans speak to computers in the cloud and the computers talk back. Amazon's Alexa platform offers technologies for adding a voice interface to mobile applications. This talk will introduce an open source Clojure library (Boomhauer) that simplifies tying voice commands to service interfaces via the Alexa Skills Kit. With example code in Clojure running on AWS Lambda, this talk will give you a peek into how accessible voice interfaces can be and how easy it is to add another dimension of usability to your application. The next generation user interface is invisible.

Michael Drogalis

Distributed Masonry

Inside Onyx

Onyx is a high performance, fault tolerant, distributed computation platform written purely in Clojure. It couples an all-data API with thoughtful streaming primitives to encourage flexible application design. But how does it work?

In this talk, we're going to dive into Onyx's architecture and discuss its most unique trait - its "masterless" coordination scheme. In other words, we'll look at how Onyx uses Clojure to achieve consensus and safety, even when networks partition and machines fail.

Michał Marczyk

Aviso

defrecord/deftype in Clojure and ClojureScript

Practising Clojurians rely on facilities implemented in terms of deftype and defrecord every day - data structures, channels and buffers, transducible contexts, custom control structures... This talk aims to draw lessons on the most effective use of both from several examples of effective use in Clojure and in ClojureScript, as well as a closer look at some of the most interesting details of their own implementation and their relationship to protocols and interfaces.

Mikaela Patella

Yet Analytics

Web Development is Distributed Systems Programming

Web development has an undeserved reputation. Many in our industry hesitate to call it "real programming," yet designing even the simplest web application draws upon deep traditions in networked computing.

In this webdev real talk, we are going back to the beginning. We will graph out the advancement of web systems from their humble origins, and, with each new storage and rendering component, watch the architectures of today's massive web systems emerge. Then, we will explore recent works from members of the greater Clojure community that push the boundaries of this era in our distributed web.

Nathan Marz

Red Planet Labs, Inc.

Specter: powerful and simple data structure manipulation

When writing Clojure or ClojureScript, it is very common to make use of data structures that are combinations of maps, lists, vectors, and other data structures. It is very common to query for nested elements in a data structure, or to transform only parts of a data structure. This kind of code tends to be highly nested, hard to follow, and error-prone. Specter is a library that gives you the power to write these queries and transformations concisely and elegantly - with performance rivaling hand-optimized code. In this session you will learn the basics of Specter and why it has near-universal applicability for Clojure and ClojureScript programming.

Nathan Sorenson

SparkFund

Hybrid Automata and the Continuous Life

Functional programming suggests that the best way to comprehend a world in flux is with abstractions that are declarative and immutable. However, most of the approaches we have at hand are suited for discrete changes: tools like refs, atoms, and agents can't effectively describe continuous or gradual change. Hybrid automata combine the discrete nature of finite automata with the continuous nature of differential equations to offer a powerful and succinct way to describe continuous systems, and they have been used to model everything from microbial ecosystems to macroeconomic equilibria. In this talk we will see how hybrid automata provide a programming model that helps us manage the complexity of flowing time without a calculus degree. We will also show how SparkFund uses hybrid automata and Clojure to navigate a world of cash flows, interest rates, and financial contracts.

Bozhidar Batsov

Toptal LLC

CIDER: Inside the Brewery

A visit to CIDER's brewery where all the magic is happening. On this exciting journey you'll learn more about the current state and the future of the CIDER project. We'll examine recently added features and CIDER's next release. We'll also take some time to speculate about the future and we'll go over some of the more ambitious plans lying around in our cellar. But above else - we'll have some fun while doing so!

Peter Schuck

Bendyworks

Hash Maps: more room at the bottom

Since it's invention the Hash Array Mapped Trie has grown to become the defacto Immutable Hash Map implementation. However there is still room for big improvements with this central data structure. It's possible to get speedups of 100% for iteration and equality checking. Great, more complex algorithms and bit twiddling, you say. Balderdash! We make some simplifications to the underlying data structure making the operations on it simpler and faster.

Priyatam Mudivarti

Level Money, Capital One

Caching half a billion user transactions

While many robust Cache libraries exists, understanding cache invalidation and cache-misses in a distributed platform requires a deeper understanding of your data access patterns. At Level Money we built our own caching solution, backed by a Memcached Cluster. In this talk I will share our story: how we name and version our caches, grow dependency graphs, find expensive computations, avoid race conditions, and define compute functions to serialize financial data using a simple Protocol.

What's more-there's a happy ending!

Stuart Sierra

Cognitect

The Joys and Perils of Interactive Development

The ability to interact with and modify a running program is one of the great strengths of modern programming languages. But runtime modification forces us to make trade-offs at every stage of a program's design. After several years of work on tools to mitigate this problem - Lazytest, tools.namespace, Component, the 'reloaded' pattern - this is the story of what I've learned, mistakes I made, and the problems that still need to be solved.