Nov 20-22, 2014Warner Theatre
Washington D.C.

Speakers

  • Anna Pawlicka

    @AnnaPawlicka

    Anna is a Data Engineer at Mastodon C. She crunches big data with Clojure, Hadoop and Cassandra and visualises it with open source technology. She's been a developer on a variety of projects ranging from banking to robotics. When she's not programming, she's either hiking, reading sci-fi or looking for the next thing to explore.

    Om nom nom nom

    Have you ever needed an easily customisable dashboard? Or needed to visualise data in a browser but was overwhelmed by d3.js? This talk will cover basics of React and Om, some data visualisation libraries and techniques, ways to handle live data and combining all that into an easily customisable dashboard. Expect demos, code and maybe, just maybe, om nom nom nom cookies.

  • Ashton Kemerling

    @ashton

    Ashton is a developer at Pivotal Labs where he writes Javascript for Pivotal Tracker. Residing in Denver, Colorado with his fiancé and two cats Ashton is an avid hiker, an inexperienced but enthusiastic angler, and fences regularly in the Italian longsword style.

    Generative Integration Tests

    Functional programmers are already aware of generative testing libraries like test.check as a supplement or replacement for traditional unit testing. Since unit tests alone cannot cover an application, integration tests are typically used to assist in verification and regression detection. Given the difficulty of creating integration test cases, it makes sense to combine the power of generative testing with the necessary complexity of integration tests to find errant application behavior. In this talk we'll go over the tools and techniques used to wire up generative tests to a large JS application, Pivotal Tracker, and also talk about the complexities of introducing Clojure to a traditional Ruby and JS shop.

  • Bozhidar Batsov

    @bbatsov

    I'm the maintainer of CIDER and the editor of the community Clojure style guide. Most people would probably describe me as an Emacs zealot (and they would be right). I'm also quite fond of the Lisp family of languages, functional programming in general and Clojure in particular.

    The evolution of the Emacs tooling for Clojure

    A session dedicated to the evolution of CIDER (the Clojure dev environment for Emacs) and all the new features that have been added since I took over the project exactly one year ago.

    The talk would examine briefly the shortcomings of the old "eval-based" model we used before 0.6 and the benefits of the nREPL middleware model we currently employ. It would also showcase some of the nice new features that were introduced recently (like ClojureScript support, vastly improved Javadoc support, Java definitions lookup, exception handling, apropos, inspector, tracing, clojure.test support, etc.)

    We'll wrap up with a brief glimpse into the future of CIDER.

  • Brian Goetz

    Brian Goetz is one of the leading authorities on the Java platform. He is the author of the very successful 'Java Concurrency in Practice', and has published over 75 articles on software development. He was the specification lead for JSR-335 (Lambda Expressions for the Java Language) and has served on numerous other JCP Expert Groups. Brian is the Java Language Architect at Oracle.

    Keynote

  • Colin Fleming

    @cursiveclojure

    Colin is the developer of Cursive. He has programmed things for a long time now, and came to Clojure from Java via Scheme a few years ago. When he's not hacking on Cursive he's mostly waiting for his daughter to get old enough to program robots together.

    Cursive: a different type of IDE

    Cursive is an IDE for Clojure, based on the IntelliJ framework. In contrast to the majority of Clojure development environments, Cursive uses static analysis of the source code to work its magic rather than taking advantage of the REPL. IntelliJ also provides a sophisticated indexing infrastructure, and this in combination with static analysis allows many interesting features which are difficult or impossible to achieve with a traditional REPL-based environment. Essential code navigation tools such as Find Usages and refactorings such as Rename become possible, and using IntelliJ's code inspections can provide error marking and even provide equivalents to tools such as Kibit and Eastwood, right in the editor. This ability to see problems immediately provides an even shorter feedback loop than working in the REPL. We'll look at some more of the interesting features that Cursive already offers which differentiate it from other tools, and talk about some of the features planned for the future. We'll also discuss some of the challenges of developing a traditional IDE for a language as flexible as Clojure, as well as the various ups and downs of developing it in Clojure.

  • David Pick

    @davidpick

    David is a software engineer at Braintree Payments. He likes to work on data and performance problems.

    Building a Data Pipeline with Clojure and Kafka

    As Braintree has grown the need for a good data pipeline has become more and more apparent. In order to solve this problem with built out a platform that can fully power our search and ETL services and keep them update in real time using Clojure. In this talk I'll talk about the issues we faced and why Clojure was a good fit for the problem.

  • Ghadi Shayban

    @smashthepast

    Ghadi Shayban is an engineer at LivingSocial, working on internal systems built in Clojure. He spent ten years in conservatory training as classical pianist, and currently has an active schedule as a chamber and symphony musician. Ghadi lives in Charleston, SC and is a contributor to Clojure and core.async.

    JVM Creature Comforts

    Far from its history of focusing on one language, the JVM has evolved into a platform for hosting all sorts of guest languages whose execution semantics don’t necessarily align with Java’s. Hosting dynamic languages like Clojure poses unique challenges which led to the introduction of a new bytecode instruction, the first since 1995. In this talk we will survey mechanisms that the JVM exposes to guest languages, from invokedynamic and the MethodHandles API to future improvements like value types, “classdynamic”, and the experimental Truffle runtime. Language guts will spill as we look at state-of-the-art assembly code from Nashorn (a new JavaScript implementation for the JVM) and JRuby.

  • Glenn Vanderburg

    @glv

    Glenn is Director of Architecture and Internal Applications at LivingSocial. He has been a professional programmer for 30 years, is a longtime Rubyist, and has been using Clojure since 2009. He knows just enough about typography to notice when it's bad, and is the kind of annoying person who notices when a period is in the wrong font.

    Cló: The Algorithms of TeX in Clojure

    Cló is a typesetting library for Clojure, implementing the core typesetting algorithms of TeX as composable functions. Although much work remains before Cló is useful in practice, even at an early stage it is instructive, providing interestingly complex examples of real-world procedural algorithms translated into functional form. Thinking about typesetting as a functional problem has yielded valuable clarity and insight about these algorithms, even though in their original form they were written with instruction and teaching in mind (the notion of "literate programming" was invented for TeX). In this talk, I'll share some of the background, code, results, and lessons learned so far.

  • Jeanine Adkisson

    @jneen_

    Jeanine writes compilers. She's passionate about languages, tools, and library design from a UX standpoint. She's currently writing languages and tools for the science team at GoodGuide.

    Variants are Not Unions

    Some of the most confounding design problems occur when a value can be more than one type of thing. Variants, a.k.a. tagged unions, are an elegant solution to this problem that is not supported in an obvious way in Clojure and is not supported in most mainstream languages or databases. I'll demonstrate how and when to use tagged unions in Clojure, including a pattern-matching destructor and use with core.typed and storage in Datomic.

  • Julian Gamble

    @juliansgamble

    Julian works in Financial Services and is a family man. In his spare time he writes and presents on all things software related. Julian is the author of the upcoming book Clojure Recipes.

    Applying the paradigms of core.async in ClojureScript

    In this talk you’ll see a Clojure program that visually demonstrates Clojure’s concurrency semantics and then see how to solve the same underlying concurrency problems using core.async. You’ll see the mapping between programming paradigms you already know and core.async concepts. You’ll apply this in the browser with ClojureScript.

  • Lucas Cavalcanti

    @lucascs

    Lucas Cavalcanti is the Lead Software Engineer of Nubank, an early stage Brazilian Internet bank built as a service oriented architecture leveraging Clojure and Datomic. Lucas is a functional programming enthusiast, and proponent of best practices in software development, with a vast experience in real production applications written in Java, Scala, Ruby and now Clojure. He holds a BS in Computer Science from the University of Sao Paulo.

    Exploring Four Hidden Superpowers of Datomic

    This session will explore four common problems, and the unique and surprising tools Datomic provides to solve them elegantly:

    1. HTTP caching - How to generically generate and validate Last-Modified and If-Modified-Since headers
    2. Audit trail - how to extend Datomic’s immutable transaction log to include arbitrary audit related metadata
    3. Mobile database sync - trivial implementation of an incremental update API for high latency/low bandwidth clients
    4. Authorization - easily determine resource ownership, and centrally isolate users from data they are not allowed to see

    These problems have certainly been solved before using other databases, but Datomic provides features that make the proposed implementations concise, generic, and purely functional.

  • Edward Wible

    `Edward Wible is the CTO of Nubank, an early stage Brazilian Internet bank built as a service oriented architecture leveraging Clojure and Datomic. Prior to co-founding Nubank, Edward worked in technology-focused private equity (Francisco Partners) and management consulting (The Boston Consulting Group). He holds an AB in Computer Science from Princeton University and an MBA from INSEAD.

    Exploring Four Hidden Superpowers of Datomic

    This session will explore four common problems, and the unique and surprising tools Datomic provides to solve them elegantly:

    1. HTTP caching - How to generically generate and validate Last-Modified and If-Modified-Since headers
    2. Audit trail - how to extend Datomic’s immutable transaction log to include arbitrary audit related metadata
    3. Mobile database sync - trivial implementation of an incremental update API for high latency/low bandwidth clients
    4. Authorization - easily determine resource ownership, and centrally isolate users from data they are not allowed to see

    These problems have certainly been solved before using other databases, but Datomic provides features that make the proposed implementations concise, generic, and purely functional.

  • Michał Marczyk

    Longtime 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 and data.avl.

    Persistent Data Structures for Special Occasions

    Clojure(Script) programmers know the power of sophisticated data structures; after all, the built-in suite of persistent data structures is a major factor contributing to the elegance with which complex ideas can be expressed in Clojure. This presentation aims to familiarize the broader Clojure community with several additions to the built-in suite of PDSs available off-the-shelf in the form of Contrib libraries.

  • Nathan Herzing

    Nathan is a developer at Democracy Works where he enjoys writing Clojure to save democracy. He, alongside his colleagues, is a co-author of various open source Clojure libraries. When he’s not writing Clojure, he enjoys thinking about how software gets made and how to improve that process.

    Helping voters with Pedestal, Datomic, Om and core.async

    Democracy Works has been using a combination of Pedestal, Datomic, Om and core.async to build software to help voters know the status of their mail-in ballots. And we're ready to condense months of work to under an hour.

    We will write (on stage) a system that accepts FTP uploads of postal service data on one end and on the other end continuously updates a voter about the status of their mail-in ballot. We'll get through Pedestal, Datomic, Om and core.async on the way in four small, independent projects. And we'll do it "backwards", from the front-end to the back-end.

    Included in the talk will be some discussion of a couple of libraries we've released to make this easier.

  • Chris Shea

    Chris Shea has been writing Clojure professionally since 2010, currently using it at Democracy Works to make voting easier. He was a judge for the Lisp In Summer Projects contest and has contributed to various open source projects in numerous languages. He received an MFA in Writing from the School of the Art Institute of Chicago.

    Helping voters with Pedestal, Datomic, Om and core.async

    Democracy Works has been using a combination of Pedestal, Datomic, Om and core.async to build software to help voters know the status of their mail-in ballots. And we're ready to condense months of work to under an hour.

    We will write (on stage) a system that accepts FTP uploads of postal service data on one end and on the other end continuously updates a voter about the status of their mail-in ballot. We'll get through Pedestal, Datomic, Om and core.async on the way in four small, independent projects. And we'll do it "backwards", from the front-end to the back-end.

    Included in the talk will be some discussion of a couple of libraries we've released to make this easier.

  • Rich Hickey

    @richhickey

    Rich Hickey, the author of Clojure and designer of Datomic, is a software designer with over 25 years of experience in various domains. Rich has worked on scheduling systems, broadcast automation, audio analysis and finger printing, database design, yield management, exit poll systems, and machine listenings, in a variety of languages. Rich is the CTO of Cognitect, Inc.

    Transducers

    Talk abstract coming soon

  • Steve Miner

    @miner

    Steve Miner is a software developer focused on Clojure. He has programmed professionally in many languages, including Common Lisp, Smalltalk, Objective-C and Java. Most of his career has been with Silicon Valley companies such as SRI International, Xerox PARC, ParcPlace and Apple. At Apple, he was a senior software engineer on the Enterprise Objects Framework, WebObjects and Core Data projects. Steve received his B.S. in Electrical Engineering from Stanford University. He now resides in South Carolina.

    Generating Generators

    Property-based testing provides good test coverage and automatic shrinking of failure cases. However, coding universal properties with the test.check generator combinators is somewhat of an art. In many cases, it's easier to start from a declarative description of the test data. The Herbert library automatically generates test.check generators from EDN schemas. Learn how schemas can offer simplified testing, easier maintenance and better documentation for your Clojure code.

  • Steven Yi

    @kunstmusik

    Steven Yi is a composer and programmer. He is the author of the Blue Integrated Music Environment (http://blue.kunstmusik.com) and a core developer of Csound (http://csound.github.io). He is currently working on a PhD in Digital Arts and Humanities at the National University of Ireland, Maynooth; he expects to finish his degree in Summer 2015. In his free time, he enjoys practicing and studying T'ai Chi.

    Developing Music Systems on the JVM with Pink and Score

    Pink and Score are two libraries for music systems development, written in Clojure and targeting the Java Virtual Machine. Pink is a low-level library for audio signal generation and processing, event handling, and audio engine design. It comes with a number of pre-built features that allow users to get started quickly, but it is also designed so they can easily reuse parts to create their own music systems.

    Score is a higher-level library for modeling music and generating musical events. It is designed to be agnostic to the target system that will be used to perform the musical data. Users can learn to express their musical ideas in Clojure and Score, and move their musical ideas between various systems. The library is designed to use standard Clojure abstractions so as to maximize interoperability and reuse with other Clojure libraries.

    In this talk, I will discuss music systems designs in existing systems (i.e. Overtone, Csound, Common Music), and the motivations for creating Pink and Score. I will give demonstrations using both libraries separately, then explore the interesting possibilities that emerge when the two are used together. Finally, I will present lessons learned while building these libraries and discuss their future directions.

  • Paul deGrandis

    @ohpauleez

    Paul deGrandis lives for magnificent engineering. Elegant, well-founded, useful solutions to problems that say something about engineering's beauty. He loves metrics, taking on the impossible, and making lives better through technology. Paul has previously worked on next-generation cable systems, autonomous internet infrastructure, distributed search and recommendation engines, massive online social game platforms, and more.

    Unlocking Data-Driven Systems

    It is becoming increasingly common to see Clojure-based systems express their primary interactions with data (e.g. Datomic queries) - but what's the rationale?

    This talk analyzes the merits of that design decision, the qualities that emerge, and the tips for implementing similar systems of your own. To motivate the topic, we will walk through a Consumer Reports' pilot project that stretched the concept across an entire stack - Pedestal services, Datomic ETL jobs, and even entire ClojureScript applications all expressed as data. With a heavy mix of core.async and core.logic, let's see just how far the rabbit hole goes!

  • Zach Oakes

    Zach is an independent programmer and tutor in the Pittsburgh area. He made Nightcode, a Clojure IDE for beginners, and is working to make Clojure games a reality with the play-clj library and Nightmod, a game creation tool. Previously, he was a programmer at the National Security Agency in Maryland.

    Making Games at Runtime with Clojure

    Games are a modern art form, and like other artists, game designers need to experience their work as they create it. This talk will explore the benefits of making games "at runtime". Through both abstract discussion and concrete demonstration, we will see why Clojure is uniquely suited to the task.

  • Zach Tellman

    @ztellman

    The first place I think of, when I try to tell someone about this quality, is a corner of an English country garden, where Zach Tellman grows against a wall.

    The wall runs east to west; Zach grows flat against its southern side. The sun shines on him and as it warms the bricks behind Zach, the warm bricks themselves warms the peaches on him. It has a slightly dozy quality. Zach, carefully tied to grow flat against the wall; warming the bricks; the peaches growing in the sun; the wild grass growing around Zach's roots, in the angle where the earth and roots and wall all meet.

    Always Be Composing

    The Clojure ecosystem, we're told, is made up of small, composable libraries. In practice, though, it's all too common to find that two libraries simply will not cleanly compose. This typically will lead to another library that does the same thing, but in a subtly different way. Sometimes this is warranted, but often it's not.

    This talk will discuss the constraints and affordances that make a piece of code play nicely with other pieces of code. Attendees will learn how to write clean, reusable Clojure, drawing on the speaker's many past failures and few notable successes.

Sponsors Download Sponsorship Prospectus