Clojure/conj by Cognitect

Benjamin Pierce

University of Pennsylvania

A Deep Specification for Dropbox

Stuart Halloway

Cognitect

Debugging with the Scientific Method

Allen Rohner

Rasterize

Optimizing ClojureScript Apps For Speed

Single Page Clojurescript Apps are the new craze, because they bring the goodness of Clojure to javascript and allow for rich UI interactions. But they have a few downsides, including speed. In this talk, we'll discuss ways to optimize your app, with an emphasis on page load times. Topics include dynamicly loading clojurescript modules, server-side Om rendering, and UI libraries that run in both clojure and clojurescript.

Ben Vandgrift

Aerostat

Adam Hunter

Aerostat

Serverless Microservices

With the release of AWS' API Gateway and the Lambda service, it is now possible to write scalable microservices without an application server--rather than being charged by the server-hour, you can create a server process that is charged by the processor-millisecond. Adam and Ben will walk through the process (and trade-offs) of defining and deploying an API service backed by Clojure components deployed into Lambda. Initial specification, authentication via an API token and SSO system, retrieval of data, and transformation of that data using the API Service will be covered, along with logging, exception handling, and monitoring.

Bobby Calderwood

Capital One

From REST to CQRS with Clojure, Kafka, & Datomic

Have you ever hit a wall with REST? Does modeling your problem domain into CRUD-able entities feel like fitting a square peg into a round hole? Have you ever tried implementing a PATCH request (without going crazy), or debated PUT vs. POST for resource updates?

An alternative to CRUD-flavored REST is CQRS (Command and Query Responsibility Segregation). In this talk, I'll discuss the advantages and trade-offs of CQRS (and its cousin, Event Sourcing), and demonstrate them using an implementation of CQRS based on Clojure microservices, Kafka, and Datomic. These advantages include:

• Operational simplicity, flexibility, and extensibility
• Applying Clojure's sound model of state transitions to the resources exposed by your web application
• Simplified client implementation

BONUS: We'll even be able to keep the best parts of REST!

I'll also discuss how this technique dovetails nicely with other good ideas in the Clojure community like the design of Datomic and the ideas behind Om.Next.

Chris Houser

ViaSat

Condition Systems in an Exceptional Language

"Some errors, however, are sufficiently obscure to escape detection for a surprisingly long time." -Brooker and Wheeler, 1952

Clojure does not come with a Condition system as powerful as Common Lisp's. Instead, we have Exceptions, which start unwinding the stack the moment they're thrown, destroying information as they go. The values of locals disappear, and there is no ability to continue from the location of the error. Several libraries solve this problem, but they do not compose well with each other. We will discuss these libraries, how they work, and why they don't compose. We will consider alternatives that may compose better, and the tradeoffs and amongst all of these.

Colin Fleming

Ideogram

Improving Clojure's error messages with grammars

One of the most frequent complaints from new users of Clojure is the error messages. But many of the error messages that users are faced with are not actually errors from the core language at all but instead surface from macro parsing code. This parsing code is often brittle, difficult to write and can produce truly awful errors.

Cursive is a Clojure IDE which works from unexpanded source. It uses Parsing Expression Grammars to parse macro forms, which makes the parsing code much quicker to write and also dramatically increases its composability and reusability. Additionally this allows much better error reporting. Syntax errors can be identified at the point the error occurs with much friendlier messages. Achieving better error reporting requires little extra work by the developer. Cursive can use this information to mark syntax errors in the editor and provide information about what was expected at the error point.

I'll show a lot of examples of the grammars that Cursive uses and also the code that uses them. I'll also discuss the benefits from using this technique for more general macro parsing - I now believe we should parse all macros this way.

Derek Slager

IMS Health

ClojureScript for skeptics

Many people are quick to dismiss ClojureScript as a web development language. "It has some neat ideas", they might say, "but it's easier to just use JavaScript for all that". Or perhaps "it's fine for startups, but you'll never build a real team around it".

This talk will discuss the many reasons why ClojureScript is in fact a very pragmatic language to consider for web development. It will discuss recent improvements, some of the not-so-obvious benefits, and use cases where ClojureScript shines.

Elena Machkasova

University of Minnesota, Morris

Thomas Hagen

University of Minnesota, Morris

Ryan McArthur

University of Minnesota, Morris

Super-fun with first-class shapes in Quil

Quil is a very popular Clojure graphical library that is used in a variety of projects and is often introduced to beginner Clojure programmers. A recently developed functional mode ("fun-mode") middleware by Nikita Beloglazov introduces MVC approach that allows for a purely functional state manipulation. However, even in the fun-mode Quil drawing functions draw shapes (rectangles, ellipses, etc) directly on the canvas in an imperative programming style. Our "super-fun" addition to Quil allows shapes to be used as first-class entities in a program: a user defines a shape without drawing it (or even without specifying a position at which it would be drawn). Simple shapes and user-imported images can be combined into complex shapes using "above", "beside", and similar functions. A "draw-shape" function draws the entire shape on the canvas at a specified location. Together with the fun-mode, this approach simplifies working with graphics and provides abstraction over the majority of imperative features of Quil. This is especially important for beginner programmers since they can concentrate on functional approaches, and yet enjoy creating complex dynamic interactive graphics without getting stuck on tedious low-level details. The project has been modeled after beginner-friendly graphical library in Racket.

George Kierstein

National Centers for Environmental Information

GST Technologies

Climate Data, Scientific Data Visualization and Clojure

The controversial nature of climate data demonstrates that scientific data sets can be challenging to communicate about. Traditional visualization approaches often fail to effectively illustrate the implications and limitations of this kind of data. This is especially true when the target audience are not domain experts.

This talk provides an overview of some key differences that scientific data sets have from more common data sets, such as business analytics. These differences impact correctness of results and add complexity to handling, processing, visualization and even understandability of these kinds of data. Using climate data as a touchstone, we will explore these differences with AWS/Clojurescript examples to illustrate what makes visualizing large scientific data sets challenging while demonstrating promising alternative approaches.

Hunter Kelly

Zalando

Using Clojure+Spark to Find All the Topics on the Interwebs

The latest generation of big data tools such as Apache Spark routinely handle petabytes of data while also addressing real-world realities like node and network failures. Spark's (http://spark.apache.org) transformations and operations on data sets are a natural fit with Clojure's everyday use of transformations and reductions. Spark MLlib's excellent implementations of distributed machine learning algorithms puts the power of large-scale analytics in the hands of Clojure developers. At Zalando's Dublin Fashion Insights Centre, we're using the Clojure bindings to Spark and MLlib to answer fashion-related questions that until recently have been nearly impossible to answer quantitatively.

At the Dublin Fashion Insights Centre, we are exploring methods of categorising the web into a set of known fashion related topics. This raises questions such as: How many fashion related topics are there? How closely are they related to each other, or to other non-fashion topics? Furthermore, what topic hierarchies exist in this landscape? Using Clojure and MLlib to harness the data available from crowd-sourced websites such as DMOZ (http://www.dmoz.org, a categorisation of millions of websites) and Common Crawl (http://commoncrawl.org, a monthly crawl of billions of websites), we are answering these questions to understand fashion in a quantitative manner.

Jearvon Dharrie

Comcast

Mobile apps with ClojureScript

React Native enables us to build native mobile apps with JavaScript. Amazing work is being done to pair React Native with ClojureScript. ClojureScript is receiving lots of attention because of how well it pairs with React. Being able to use ClojureScript with React Native opens new doors for developers and the language. The following topics will be discussed: What is React Native?, How does the marriage of the two work? and advantages and disadvantages. The audience will learn about React Native and how to get started with Ambly and ClojureScript.

Kyle Harrington

Harvard Medical School

Scientific Computing with Clojure

Scientific computing has generally been restricted to procedural and object-oriented programming languages, such as C/C++, Java, Python, etc.. We have developed Clojure-based projects to support not only analysis of scientific data, but also scientific simulations. Our analysis tools are applied to biomedical data, in particular biological imaging of clinical human samples and high-resolution subcellular microscopy images. Our simulations are used for modeling ecological and evolutionary dynamics, as well as multi-cellular biological systems. The use of Clojure has facilitated the growth of our software ecosystem due to the power of Clojure to manage code complexity. Furthermore, the ability to rapidly prototype compact yet complex code has allowed us to advance on many fronts of scientific computing simultaneously.

Lee Spector

Hampshire College

Genetic Programming in Clojure

Genetic programming harnesses the mechanisms of natural evolution, including mutation, recombination, and natural selection, to automatically synthesize computer programs. It has been applied to a wide range of problems spanning several areas of science, engineering, and the arts, in many cases equaling or exceeding human performance.

Genetic programming's roots are in Lisp, making Clojure a natural choice for modern genetic programming research and development. In this talk I will show how a simple genetic programming system can be written in about 100 lines of Clojure code, how a mature genetic programming system (PushGP) implemented in Clojure can improve the state of the art in automatic programming, and how genetic programming can be incorporated into an artificial life environment implemented in Clojure and Quil.

Maria Geller

LiveOps

The ClojureScript compiler - A look behind the curtains

Over the past years, development for the ClojureScript compiler has moved at a fast pace and its community is growing continuously. It's a fun community which I enjoyed to be a part of over the past months through my Google Summer of Code project. In this talk I will give an overview of the moving parts of the ClojureScript compiler, dive into some details about the compilation process itself with a hands-on example and will provide you with some pointers on how you could start contributing to the compiler.

Mark Engelberg

Alex Engelberg

Solving Problems with Automata

Many of us have hazy memories of finite state machines from computer science theory classes in college. But finite state machines (FSMs) have real, practical value, and it is useful to know how to build and apply them in Clojure. For example, FSMs have long been popular to model game AIs and workflow rules, and FSMs provide the behind-the-scenes magic that powers Java's regexes and core.async's go blocks. In this talk, we'll look at two programming puzzles that, suprisingly, have very elegant solutions when looked at through the lens of FSMs, with code demonstrations using two different Clojure libraries for automata (automat and reduce-fsm), as well as loco, a Clojure constraint solver.

Mark Mandel

Google

Wrapping Clojure Tooling in Containers

Development tooling for Clojure is impressive. Leiningen, and more recently Boot, are fantastic products that provide library and Clojure version isolation that is often far better than what can be found in other languages.

However, a development environment for a project includes more than just lein or boot. A project often include development workflow plugins, external binaries that are specific to your project, specific Java versions and potentially more. This can be difficult and cumbersome to initially set up correctly on a local machine, and more importantly, can be even more difficult to share with your team in a reproducible way.

In this talk, we'll explore wrapping your Clojure development tooling in a container to take advantage of Docker's resource isolation to create a portable, shareable and most importantly - immutable development environment for you and your team.

While this can be a bit of extra work, encapsulating your development tools in a container can drastically reduce the amount of time it takes for team members get on board a project, cut down those "but it works for me" moments, and can also be a handy way to manage those resources you may only need occasionally.

Mark Bastian

Clearwater Analytics, LLC

Bottom Up vs. Top Down Design in Clojure

The standard approach to developing a program or API in Object Oriented Programming is to take a "Top Down" approach in which the modeler starts with the domain at large and decomposes this domain into smaller pieces, generally in the form of classes. This often results in complex, interconnected type hierarchies. In Clojure, the standard approach is to design "Bottom Up," in which the developer first models an actual domain instance using Clojure data structures and then writes simple functions for manipulating the domain data. These functions can then be recombined and composed into more powerful functions. Ultimately, a program emerges. This approach has several advantages including: 1) bottom up functions have more reuse, 2) bottom up design allows for immediate domain modeling using actual data, 3) it is easier to reason about what is going on in bottom up design. This talk will first describe the two approaches, then it will walk through the development of a program using bottom up design in Clojure, culminating in a live demonstration of the program. Attendees will gain an appreciation for this technique and see it in action. In particular, they will see how Clojure is especially well suited to this approach.

Marshall Bockrath-Vandegrift

Damballa, Inc.

Clojure versus the Botnets

Over the past three years Clojure has become Damballa's secret weapon in the fight against botnet malware. It's now our language of choice for all production data-processing, including ETL, modeling, and access microservices. Three properties of the language make it particularly suited to pragmatic data-processing applications: JVM hostedness, interactivity, and value-orientation. This experience report will describe how leveraging these properties has allowed us to rapidly develop malware-detection machine-learning pipelines which operate on literally Internet-scale data.

Matt Adereth

Two Sigma Investments

clojure.core/typing

Although Clojure programmers should be spending most of their time thinking, we occasionally need to type to get our ideas into computers. We'll talk a bit about this history of keyboards and how Clojure (and lasers!) can be used to design and manufacture the next generation of keyboards.

Matt Bossenbroek

Netflix

Dagobah, a data-centric meta-scheduler

On the Netflix search team we had many data pipelines, patched together using different technologies, which made it difficult to integrate and monitor system health. This inspired us to build Dagobah, a new take on data pipelines with a focus on data provenance.

Dagobah is a cross-platform, meta-scheduler that's different from your typical workflow engine. With Dagobah you describe each node as an independent, addressable computation.

A node can specify its data dependencies and Dagobah will compute them prior to running the node. You then ask Dagobah for data you need and it figures out how to build it and any dependencies, enabling data sharing and versioning in a unique and flexible way.

Users can optionally specify that a node in the graph must come from a specific build, git branch, or commit. Because each computation is memoized and all data is immutable, multiple users can all rely on the same data without duplicating work.

Dagobah is capable of running jobs on many platforms and can be extended to utilize many others. At Netflix, we use Dagobah to build data pipelines that run PigPen jobs on Hadoop, Spark jobs on various platforms, and Docker containers on Titan.

Michael Drogalis

Distributed Masonry

Onyx: Distributed Computing for Clojure

Does your application need to manipulate more data than a single machine can handle? Have you tried Hadoop, Storm, or Spark but felt it didn't quite fit your problem?

Onyx is a new distributed, masterless, fault tolerant computation platform written specifically with Clojure developers in mind. It gracefully composes many concerns that other frameworks complect: computational structure, data flow, stateful lifecycles, deployment, and more. Its superpower is its ability to create distributed workflows at runtime in an ad-hoc fashion. In effect, Onyx allows you to bridge the gap across programming languages, execution environments, machines, and time. Since its release, Onyx has become one of the highest performing open source streaming platforms, burning in on official benchmarks at over millions of messages per second.

Michael Nygard

Cognitect

Ragnar Svensson

King

Game Development Development

Clojure for a desktop GUI application. With JavaFX. For game development. And it's all built on top of an in-memory, transactional graph database.

One of the biggest game developers in the world needed a new IDE to build games for their engine. Eclipse just wasn't cutting it any more.

It may sound a bit nuts to use Clojure for desktop GUIs, but this architecture delivers incredible benefits to the tool developers.

Philipp Meier

Self Employed

I did the API wrong - Tales of a library maintainer

So you wrote a nice new clojure library and are about to release it as open source to the public? What could go wrong? I learned some lessons the hard way and will show what mistakes I made designing the API of the library, what I learned and which part macros played in that game.

Ram Krishnan

juxt.io

Clojure for Business Teams - Decomplecting Data Analysis

Currently, many of the data analytics tools for business users are either severely feature constrained in the name of ease-of-use, or are too complex as thinly wrapped abstractions atop the underlying programming languages. They don't address the needs of savvy business experts who need something more expressive than Excel without having to become software engineers.

Software professionals, on the other hand, are seeking ways to publish their algorithmic and process abstractions in a manner where they can be composed and leveraged further by their users.

Juxt builds upon ideas from past programming systems like Yahoo Pipes and Scratch, to create an interactive and graphical tool for Data Analytics and Web APIs, using Clojure as the extension language.

Applying the best practices from Functional Programming and Data Flow Programming, Juxt enables non-coders to rapidly build sophisticated data driven apps. And our APIs enable Clojure devs to easily publish their libraries as composable and reusable platform components.

In this talk, I'll present the challenges and learning from our experience using Clojure and Clojurescript to build a powerful, performant and highly UX driven app.

David Nolen

Cognitect

Om Next

Rationale and high level design of Om Next.

Steve Shogren

SmartStream Tech

Teaching Clojure at IBM

We had a month till the industry conference. It had to run on JVM. We are a .NET shop. We tallied the team's skills other than C#: Ruby, Java, Python, PHP, Scala, Perl, and Clojure. Not a single overlapping language between us.

"Who would feel comfortable having to train everyone else?"

I put myself forward for Clojure. A month later we shipped.

Here's the report of how I became confident enough to suggest Clojure as an option and then train the rest of the team. I'll cover the skills and attitudes that I believe made the project a success. I'll also make suggestions for what can reduce the friction of introducing Clojure at your company.