March 24-26 2014 The Palace Hotel San Francisco

Register for Clojure/West
Register for Intro to Clojure, ClojureScript or Datomic Training


  1. Aaron Bedra


  2. ×

    Aaron Bedra | @abedra



    Aaron is a Principal Consultant at Cigital where he helps drive secure programming practices. Aaron is the creator of Repsheet, an open source framework for web application attack prevention. He is a co-author of Programming Clojure and a previous member of Clojure/core.


    Web development libraries for Clojure have started to mature, but there are still quite a few gaps. Although there has been some activity in securing Clojure web applications, there has not been much of an effort into documenting the options or even explaining what should be done. This includes authentication and password management, securing application responses and options, as well as code review and deployment.

    Join Aaron as he walks through what is available, what is coming, and what does not yet exist in any open and consumable fashion. These are ideas that every production Clojure web application should embrace.

  3. Aaron Brooks


  4. ×

    Aaron Brooks | @0x1B



    Under the influence of strong tea and good friends, Aaron picked up Clojure for side projects in 2008. He did not achieve his dream of being paid-by-the-parenthesis until he was hired as engineer #2 at LonoCloud in 2011. LonoCloud was acquired by ViaSat in 2013.

    Over the years Aaron has shown a penchant for building developer tools and improving the ways that developers work and collaborate. Aaron telecommutes daily to ViaSat from his home in southern New Hampshire where he lives with his one wife, two children and three cats.

    As a recovering kernel engineer Aaron has now been malloc( ) free for nearly five years.

    lein-voom: Projects Want to Be Values

    Clojure projects start out small but, given enough love and attention, are destined to grow wildly out of control. As they grow, they shed their namespaces into separate projects, accumulate dependencies and sprawl across repositories. In this talk, we introduce lein-voom and its accomplice, box. Together these tools keep your project and its dependency relationships stable and fresh.

    The voom and box tools were forged at ViaSat to address the complexities of scaling the relationships between a multitude of fast-moving internal and open source projects. The ideas behind voom are straight out of the Clojure playbook: project identities are immutable trees of values across time. box is all about ease.

    Regardless of the maturity or scale of your project, the benefits of using voom and box are numerous: ending the misery that Maven SNAPSHOTs and version ranges bring, keeping your project dependencies up-to-date, using commits as fine grained releases (even for dependency projects unaware of voom) and delivering both precision and freedom so you can focus on efficiently moving your project forwards.

  5. Alan Dipert


  6. ×

    Alan Dipert | @alandipert



    Alan is a programmer for ViaSat, Inc. He has released and contributed to a wide variety of Clojure and ClojureScript projects.

    Web Programming with Hoplon (co-speaking with Micha Niskin)

    The war against web browser complexity enters its 17th year this August, and we’re not winning. To date, rich client application development with web technology has had the flavor of trench warfare: we make small gains here and there, only to be beaten back by requirement or technology changes that force us to rethink or rewrite entire stacks.

    In the meantime the Web has defeated competing platforms and is now firmly entrenched as the dominant user interface for serious business applications. Web platform technology continues to advance while stakeholders demand ever larger and more capable, robust, and engaging client-side applications. Unless we’re able to find and hold the high ground, our applications will remain fragile, behind schedule, and impossible to reuse in whole or in part.

    Lisp. When it comes to programming, it’s maybe the highest ground there is. We have it in the browser with ClojureScript and on the server with Clojure. Hoplon is a set of libraries, tools, and ideas born of Lisp and Clojure/Script that we think can make for better rich web applications.

  7. Alice Liang

    Climate Corporation

  8. ×

    Alice Liang

    Climate Corporation


    Alice is a developer at The Climate Corporation, where she's been using Clojure to build a database for painless, distributed data ingests, to ingest weather data for our researchers into said database, and to build a distributed tracing system for our internal services. A couple years ago, she studied Applied Mathematics and Statistics at UC Berkeley, and never intended on becoming a developer.

    How to Grow Your Own Distributed Array Database

    At the Climate Corporation, we have a great demand for storing large amounts of raster-based data, and an even greater demand to retrieve small amounts of it quickly. Doc Brown is our distributed, immutable, versioned database for storing big multidimensional data.

    In this talk, we'll take a look at the library design and features, the engineering challenges of managing versions, indexes, caching, while making it fast to ingest and to query data. We will also walk through an example of how to do quick development and validation of data.

  9. Andrew Nguyen

    Body Data Systems

  10. ×

    Andrew Nguyen

    Body Data Systems


    Andrew is the CTO and Founder of Body Data Systems

    Healthcare “big” Data - from Data Management to Web Apps

    Being a healthcare data startup presents us with several key challenges: every customer’s needs are slightly different, we need to build end-to-end solutions, we need to do so with minimal resources, and we need to make it repeatable and scalable.

    The "big" data problem in healthcare is actually thousands of little data problems. Given the same data, a cardiologist and a surgeon will interpret them very differently. Even something as simple as counting the number of patient visits or tracking marital status becomes non-trivial.

    This problem gets magnified as we factor in the number of data systems within a typical hospital (hundreds), and the number of clinical environments (thousands of hospitals, nursing facilities, etc.). There are hundreds of millions of unique data needs, translating into as many data requirements. Our product, a cloud-managed, on-premise appliance, is designed around this massive data variety problem while making the data easily available and accessible for everyone downstream.

    Clojure(script) have become an integral part of our development model, letting us blur the lines between development and runtime requirements. We’ve been using Clojure(script) for 4 months throughout our entire stack. We will share our journey and lessons learned along the way.

  11. Aysylu Greenberg


  12. ×

    Aysylu Greenberg | @aysylu22



    Aysylu Greenberg is a Software Engineer in Search Infrastructure at Google. In her spare time, she works on open source projects in Clojure, does oil painting and archery.

    Looms and Graphs in Clojure

    Graphs are ubiquitous data structures and the algorithms for analyzing them are fascinating. Loom is an open-source library that provides many graph algorithms and visualizations. We will discuss the graph API, look at the implementations of the algorithms and learn about the integration of Loom with other graph representations. We will specifically look at integrating Loom with Titanium to run graph algorithms on graph databases, core.async to visualize the “go” macro's state machine, and Github data to analyze Clojure projects.

  13. Bridget Hillyer

  14. ×

    Bridget Hillyer | @BridgetHillyer


    Bridget is an independent software consultant of many years. She is on the journey to become a Clojure programmer.


    ClojureBridge aims to increase diversity within the Clojure community by offering free, beginner-friendly workshops for women modeled on the work of RailsBridge. In April 2014, we will put on our first workshop in Durham, NC, followed soon by a workshop in San Francisco.

    What does it mean to teach Clojure to beginners - both beginners to programming and beginners to functional programming? We have learned a number of lessons by looking at the models of those who have come before us as well as in the process of developing this new curriculum.

    Since we announced the ClojureBridge effort at Clojure/conj in November 2013, more than 500 people have registered interest at There is huge interest in the Clojure community in beginner materials both for those who want to learn it and those who want to share it.

  15. Chas Emerick

  16. ×

    Chas Emerick | @cemerick


    Chas is a long-time contributor to the Clojure and ClojureScript languages and ecosystem, and is a coauthor of the ‘Clojure Programming’ book from O’Reilly.

    Targeting Clojure & ClojureScript from a Single Codebase

    Clojure and ClojureScript have been cast from the same mold, to the extent that it is possible to write programs (or, parts of programs) that are entirely portable without changes. However, their lineage and target runtimes necessitate some differences, and others arise because of decisions made in ClojureScript informed by the experiences of building and using Clojure for years prior. While relatively minor, these differences can provoke significant pain when building applications targeting both languages / runtimes, including forcing the maintenance of duplicate codebases, and splitting up namespaces and projects to localize language- or runtime-specific code.

    cljx will be presented as a solution to this difficulty, an implementation of "feature expressions" similar to that found in other lisps. Many applications and libraries have used cljx over the past year to eliminate duplication in their cross-language codebases without impacting downstream users (they only ever see "regular" Clojure and ClojureScript), and without sacrificing development-time conveniences (e.g. cljx's integration with nREPL allows you to load code into either Clojure or ClojureScript REPLs as-is, with the necessary transformations applied on the fly). Real-world usage of cljx in the community will be exhibited, and its use in Clojure and ClojureScript REPLs will be demonstrated.

  17. Daniel Glauser


  18. ×

    Daniel Glauser | @danielglauser



    Daniel Glauser is a software developer with over fifteen years of experience ranging from high throughput systems at NBC-Universal, to modeling tools at Comcast, to distributed collectors at VMware. Daniel currently works as a Clojure developer at Sonian where he works on services for their next generation platform. Daniel is based in Denver, Colorado where he runs the Den of Clojure, one of the most active Clojure groups in the United States.

    Beginner’s Luck (co-speaking with Denise Zimmerman)

    Have you wanted to learn Clojure but didn't know where to start? Have you wanted to teach Clojure but aren't sure how to work with students? Beginner's Luck is an interactive presentation where student and teacher share their experiences both learning and teaching Clojure over the past four months. The first part of the presentation will be a dialog where both student and teacher will switch off sharing experiences and coding examples of things that went well and the numerous surprises they encountered along the way. The second part will be a review of the open source beginner curriculum that's published on Github.

  19. Daniel Solano Gomez

    Sattvik Software & Technology Resources

  20. ×

    Daniel Solano Gomez | @deepbluelambda

    Sattvik Software & Technology Resources


    Daniel has been developing with Clojure for over four years and has contributed to a number of Clojure projects. Most notable of these are the Clojure REPL for Android; Neko, the Clojure/Android toolkit; and Clojure itself. He has been both a mentor and an administrator in Clojure's participation in the Google Summer of Code. Clojure projects on his back burner include creating a lean Clojure runtime and developing for Google Glass.

    How Clojure works: understanding the Clojure runtime

    "Any sufficiently advanced technology is indistinguishable from magic."-- Arthur C. Clarke's Third Law

    REPL-driven development in Clojure seems almost magical to programmers coming from languages with long recompile or redeploy cycles. It's something Clojure programmers often take for granted, but how does Clojure actually work, and what are the trade-offs made to support it?

    This session will highlight how key aspects of the Clojure runtime work, such as namespaces, static and dynamic vars, and class reloading. You will also learn how the current implementation impedes some static bytecode analysis and impacts startup speed. Finally, this session will present ideas on how to create a lean, high-performance Clojure runtime intended for production use.

  21. Dave Golland


  22. ×

    Dave Golland | @PrismaticEng



    Dave Golland is a recent PhD graduate from UC Berkeley, where he studied Natural Language Processing with Dan Klein. After graduating (actually, a little before), he promptly joined the backend team at Prismatic. When he joined, he didn't know any Clojure, but upon seeing the light, he now considers Clojure his favorite programming language. He feels privileged to work with such a talented group of engineers and designers at Prismatic, and is excited to present some of the recent projects the team has been working on.

    Wiring Prismatic's API with fnHouse and Coax

    In the functional programming paradigm, web services should consist simply of functions that turn requests into responses. At Prismatic, we’ve developed fnHouse -- a minimal library that transforms a collection of lightly-annotated functions into a full-fledged, production-grade web service. fnHouse enables concise handler definitions, query parameter parsing, and input and output validation (and even coercion) using the Schema library. We also use the function metadata to generate living API documentation that is always up-to-date. Using this functional view, middleware for rate-limiting, authorization, and analytics become straightforward function compositions.

    In this talk, we will describe Prismatic’s web infrastructure: how we construct a service graph using the Plumbing and Graph libraries, and how functions turn into handlers using fnHouse and Schema. We also present Coax, a Prismatic library that generates Objective-C and ClojureScript API clients from the annotated functions. In one fell swoop, these libraries transform a simple, lightly-annotated function into a secure, validated API endpoint and ObjectiveC client API and model classes. Come learn how you can do the same.

  23. David Greenberg

    Two Sigma

  24. ×

    David Greenberg | @dgrnbrg

    Two Sigma


    David Greenberg is a developer at Two Sigma, a Hedge Fund in SoHo, NYC. At work, he builds cluster computing applications in Clojure; at night, he hacks on open source projects.

    Building Interactive Query Tools on Datomic

    One of Datomic's oft-touted features is that its queries are just data structures. What does this mean for us as developers? In this talk, we'll look at how we leveraged queries- as-data to build a UI that dynamically generates queries to answer complex questions about our data. We'll look at design patterns for building a composable query engine on top of Datomic, UI patterns for exposing this to non-developers, and data modeling considerations to maintain high performance.

  25. David Nolen

    New York Times

  26. ×

    David Nolen | @swannodette

    New York Times


    David Nolen is a JavaScript developer at The New York Times. He is the main developer of the Clojure Contrib library core.logic, a Prolog-like logic engine, and match, an optimizing pattern match compiler. He loves hacking at the intersection between object oriented, functional, and logic programming paradigms.

    The Functional Final Frontier

    The Model-View-Controller (MVC) approach to user interfaces was first proposed by Trygve Reenskaug in a 1979 Xerox PARC note. As Object Oriented methodologies gained popularity, MVC too gained traction as a natural and logical way to construct user interfaces despite obvious shortcomings. Even though OO researchers moved forward with alternative approaches likes Morphic and constraint based systems, MVC today maintains a stranglehold on mainstream developer approaches to UI.

    Can functional programming take the good lessons from MVC while advancing the state of the art? Functional Reactive Programming and its derivatives primarily solve complexities around events - what of component modularity and abstraction?

    We'll examine how a new library for ClojureScript called Om, a simple functional layer over Facebook's React, makes some traditional hard problems in MVC based UIs simple without abandoning the abstractions OO programmers find so useful. These concepts are easily portable to other systems provided the presence of persistent data structures.

  27. Denise Zimmerman


  28. ×

    Denise Zimmerman | @westzimm



    Having graduated with Bachelor of Fine Arts and a Bachelor of Liberal Arts and Science, Denise owned and operated a small business where she utilized her innate skills as a researcher and instructor. She uncovered her love for software development while working on her business website, which led her on an enthusiastic path to changing careers.

    After exposing herself to various languages she developed a clear preference for the functional and syntactically sweet style of Clojure. Denise joined Denver’s local users group where she found a synergistic fit working with Daniel, and shortly after began an apprenticeship with Sonian.

    Denise and Daniel are now working together on an open source curriculum for Clojure.

    Beginner’s Luck (co-speaking with Daniel Glausser)

    Have you wanted to learn Clojure but didn't know where to start? Have you wanted to teach Clojure but aren't sure how to work with students? Beginner's Luck is an interactive presentation where student and teacher share their experiences both learning and teaching Clojure over the past four months. The first part of the presentation will be a dialog where both student and teacher will switch off sharing experiences and coding examples of things that went well and the numerous surprises they encountered along the way. The second part will be a review of the open source beginner curriculum that's published on Github.

  29. Ian Eslick

    Vital Reactor

  30. ×

    Ian Eslick | @ieslick

    Vital Reactor


    Ian is an entrepreneur and scientist. His projects include: Vital Reactor, CCHMC Collaboration, C3N Project, and Personal Experiments 2.0.

    Probe: Program Traces as First Class State

    Traditional logging systems throw away a great deal of implicit dynamic program state in the process of serializing to interoperable string formats. Within the walled garden of our Clojure applications, having easy programmatic access to the complete dynamic behavior of your program is not only feasible, but desirable.

    This talk introduces Probe, a library meant to serve as your primary infrastructure for capturing and analyzing dynamic program behavior. Instead of generating strings, it captures maps of explicit (provided via arguments) and implicit program state.

    State, or probes, captured by statements can be enabled/disabled at runtime, reducing the computational cost of putting probe statements in your code. Further, Probe can also attach to any function call interface or probe point at runtime. State maps are immediately handed off to core.async channels to reduce the cost on the current thread. These channels filter, aggregate and route the data to an extendable set of sinks.

    We are using Probe in a pre-production system to capture the dynamic behavior of a distributed cloud-based system to a Cassandra cluster. We introduce a set of user cases and our growing library of forensics queries which simplifies our modeling of a real-time, cloud-based distributed system.

  31. Jennifer Eliuk

    Democracy Works, Inc.

  32. ×

    Jennifer Eliuk | @7maples

    Democracy Works, Inc.


    Jen is a recovering ski bum in Denver, Colorado. She works as an Apprentice Software Developer for Democracy Works, Inc. ( In 2013 she went through gSchool, a six month Ruby on Rails program, and started learning Clojure last fall. Before becoming a developer, she worked in construction and hospitality. Jen is also a core member of ClojureBridge.

    Apprenticeships: I implore you!

    The increase in web development vocational programs means a steady supply of junior developers, but are we prepared to help them become productive members of our teams?

    These programs were created in response to the need for more developers, but I fear without apprenticeships to bridge the gap, we're simply moving the bottleneck upstream.

    In the absence of an established, structured program, I've had to figure out what it means to be a software apprentice and ensure I'm building skills and learning best practices daily. Conversely, the senior developers have had to think about how to integrate apprentices and provide purposeful learning opportunities.

    In this talk, I'll share my experience coming from a vocational web development school and the apprenticeship program we're developing at Democracy Works, Inc.

  33. John Hughes

    Quviq AB

  34. ×

    John Hughes | @rjmh

    Quviq AB


    John Hughes has been a functional programming enthusiast for more than thirty years, at the Universities of Oxford, Glasgow, and since 1992 Chalmers University in Gothenburg, Sweden. He served on the Haskell design committee, co-chairing the committee for Haskell 98, and is the author of more than 75 papers, including "Why Functional Programming Matters", one of the classics of the area. With Koen Claessen, he created QuickCheck, the most popular testing tool among Haskell programmers, and in 2006 he founded Quviq to commercialise the technology using Erlang.


  35. Mark Engelberg

  36. ×

    Mark Engelberg


    Mark Engelberg has been an active member of the Clojure community ever since Clojure turned 1.0, and is the primary developer of math.combinatorics, math.numeric-tower, data.priority-map, and instaparse. By day, he teaches Scheme and Clojure to talented kids in the Seattle area; by night, he creates logic puzzles and games, using Clojure as his "secret weapon".


    Instaparse is a parsing library for Clojure that builds parsers from arbitrary context-free grammars. This talk will explain the underlying algorithm and discuss how Clojure shaped the design and implementation of the library.

  37. Matt Bossenbroek


  38. ×

    Matt Bossenbroek | @MattBossenbroek



    Matt Bossenbroek is a senior software engineer at Netflix. He works on mining Facebook data to provide TV and movie recommendations. Prior to that, he worked at Microsoft where he built semantic technologies on Map-Reduce and for his own startup, where he used machine learning to predict retail inventory levels.

    PigPen: MapReduce for Clojure

    PigPen is Map-Reduce for Clojure, or Distributed Clojure. You write code that looks and feels like it's running locally, and PigPen does the work of running it on thousands of machines. PigPen is designed to support iterative, REPL-driven development and has full support for local unit tests.

    PigPen makes map-reduce development easy because you can do it all in the REPL. You don't have to manage a lot of different files in different languages. Test data can be in the unit test - just like a normal Clojure test. PigPen also does the work of transporting closures to the remote environment. Any parameters or local bindings are available remotely.

    Apache Pig is used, but it's just a host language - similar to how Clojure uses the JVM. You don't need to know anything about Pig to get started using PigPen.

    We are using PigPen in production at Netflix to analyze and predict viewing behavior. So far it has proven to be a huge time saver because we can test our jobs more accurately before submitting to a cluster.

    Check out our github page for more info:

  39. Micha Niskin

  40. ×

    Micha Niskin | @michaniskin


    Hi, I'm Micha Niskin. I live in Miami, Florida. Clojure is pretty much the only reason I am still computing. I am interested in business and workflow applications. I would also like to help designers do more frontend programming.

    Web Programming with Hoplon (co-speaking with Alan Dipert)

    The war against web browser complexity enters its 17th year this August, and we’re not winning. To date, rich client application development with web technology has had the flavor of trench warfare: we make small gains here and there, only to be beaten back by requirement or technology changes that force us to rethink or rewrite entire stacks.

    In the meantime the Web has defeated competing platforms and is now firmly entrenched as the dominant user interface for serious business applications. Web platform technology continues to advance while stakeholders demand ever larger and more capable, robust, and engaging client-side applications. Unless we’re able to find and hold the high ground, our applications will remain fragile, behind schedule, and impossible to reuse in whole or in part.

    Lisp. When it comes to programming, it’s maybe the highest ground there is. We have it in the browser with ClojureScript and on the server with Clojure. Hoplon is a set of libraries, tools, and ideas born of Lisp and Clojure/Script that we think can make for better rich web applications.

  41. Nelson Morris

    Zenslade Software

  42. ×

    Nelson Morris | @xeqixeqi

    Zenslade Software


    Nelson runs Zenslade Software, a software consulting boutique. He's had his hands on many things that make the clojure ecosystem function. He is a co-maintainer of clojars, and has contributed to leiningen (including anything dependency management related), along with several other clojure oss libraries.

    Extending Leiningen to Make it Do What You Want

    The clojure ecosystem has centered around leiningen as the project tool. Some of the downsides include a limited number of built in tasks and the amount of boilerplate when starting new projects. Additionally, sometimes its nice to extend application specific logic to the command line, such as for database migrations. In this talk, I'll cover some of the internal details of leiningen, and how aliases, plugins, and templates can solve these issues.

  43. Priyatam Mudivarti

    Facjure LLC

  44. ×

    Priyatam Mudivarti | @priyatam

    Facjure LLC


    Priyatam writes fiction, shoots street-photography, and recently founded Facjure to build open tools for independent publishers. Since 2002, he worked in many industries and built web apps and enterprise software in Java, Groovy, Python, and more recently adopted Clojure. He has published short stories and is currently working on a collection of poems and a novel.

    The Poem as Value

    A million poems live buried in the public domain. Hundreds of literary magazines archive thousands more that go undiscovered. Humans—even machines, can't curate, annotate, and interact with poems in realtime.

    What would Walt Whitman build to restore poems together?

    • a) Curate poems in edn
    • b) Render typography with lambdas
    • c) Build a human api for linguistics
    • d) Discover poems with Om and Elasticsearch

    In this talk, I'll share my experience building these apis.

    I'll discuss how poets and editors think, how they identify semantic scopes, and what we can learn from them. I'll demo my code with Poetroid, a LightTable-inspired platform, that builds on three similar concepts to discover poetry together: Content, Annotations, Collections.

  45. Reid Draper


  46. ×

    Reid Draper | @reiddraper



    Reid Draper is Software Engineer at Basho, where he writes Erlang and works on Riak and Riak CS. His primary software interests are functional programming, distributed systems and QuickCheck. He enjoys cooking and making cocktails.

    Powerful Testing with test.check

    Unit-testing is a common tool for gaining confidence in code correctness. However, the benefit from these tests is often linear to the number of hand-written test-cases. test.check (formerly simple-check) is a property-based testing tool based on QuickCheck, which allows for thousands of tests with constant effort.

    Tests are written as universal quantifications -- properties which should hold true for all input. test.check then randomly generates test cases, for which the property should pass. In this talk, we'll take a look at the foundations of test.check, implementation details regarding shrinking, and see sophisticated tests of concurrent and non-deterministic code.

  47. Brandon Bloom

  48. ×

    Brandon Bloom | @brandonbloom


    Brandon Bloom is a renegade computer scientist who has worked on everything from video games to enterprise software. Most recently, he helped launch's international Hour of Code campaign, which introducing tens of millions of students to coding. When Brandon is not engaged in mercenary activities, he contributes to ClojureScript and builds other crazy things with Clojure.


    As Clojure programmers, our software is full of trees. Both the values we manipulate and the code we manipulate them with, are made from trees. It's all to easy to get caught up in a project and miss the forest for the trees, but how often have you missed the trees for the forest? This talk is an exploration of trees from a unique perspective that will hopefully inform your thinking and lead your program design out of the woods.

  49. Stuart Sierra


  50. ×

    Stuart Sierra | @stuartsierra



    Stuart Sierra is a programmer, actor, musician, and writer. He lives in New York City and works for Cognitect. He is the co-author, with Luke VanderHart, of ClojureScript: Up and Running (O'Reilly) and Practical Clojure (Apress).

    Components: Just Enough Structure

    Functional programming with immutable values is wonderful, but sooner or later every program has to deal with mutable, stateful, imperative tasks. A large program may need to manage dozens of stateful services: database connections, thread pools, network services, scheduled tasks, and caches. How do we do this in a functional programming model? All too often we fall back, almost by accident, into global mutable state, promiscuous sharing, and imperative spaghetti code.

    To escape this quagmire, we need to recall some basic principles of both functional and object-oriented programming: referential transparency, immutable values, message-passing, encapsulation, and interface contracts. The Component pattern and its library implementation offer a minimal way to structure the stateful dependencies of a functional program.

    This talk will cover the motivation for the Component pattern, its benefits and downsides, comparisons with other approaches, and how to use it in Clojure programs. This talk builds on the concepts in last year's "Clojure in the Large" but does not assume viewers have seen that talk first.

  51. Timothy Baldridge


  52. ×

    Timothy Baldridge | @timbaldridge



    Timothy Baldridge (@timbaldridge) is a developer with Cognitect Inc. He hails from the mountain regions of Denver Colorado (USA). Timothy is a polyglot programmer with experience in Clojure, C#, Python, and Erlang. Most recently he was deeply involved in the development of Clojure's Core.Async library, where he designed, implemented, and maintains the state-machine code rewriting macro known as "go".

    Data all the ASTs

    The ClojureScript has inspired a revolution in compiler design. The concept of treating Abstract Syntax Trees as nested hash maps was a design decision that started with this compiler and has since spread to almost every compiler in the Clojure ecosystem.

    This talk will start with a description of how ASTs are traditionally designed in other languages (C#, Haskell, ML, and Clojure as examples). The problems with these approaches will be discussed. The talk will then describe how the hash map approach used by Clojure enables compiler designers to be more productive. The talk will then end with examples and case studies from ClojureScript, Clojure in Clojure, core.typed and core.async.

  53. Travis Vachon

    Utah Street Labs

  54. ×

    Travis Vachon | @tvachon

    Utah Street Labs


    Travis uses Clojure and ClojureScript daily as a co-founder and general nerd at Utah Street Labs. His passion for Clojure can be traced to his time at the Climate Corporation, where he lead the initial push toward Clojure adoption. He has built web UIs, mobile app backends, Cascalog ETL systems and robust Storm topologies in his capacity as a professional Clojure developer. He can frequently be found at Ithaca, NY tech meetups madly raving about Clojure to anyone who will listen.

    cljs All The Things: Full Stack Apps with ClojureScript

    JavaScript has a ubiquitous presence in the modern web, not only in the browser but as the substrate for platforms on which developers build web and mobile applications. Thanks in part to Clojure's attitude toward its host platforms, using ClojureScript on these platforms is easy, fun and extremely productive.

    In this talk, we'll discuss 8 months of developing mobile and web applications using ClojureScript for both client and server development. We'll discuss the joys of a single-language stack, the pitfalls of riding the bleeding edge, and Clojure's influence on the design and layout of projects at Utah Street Labs. We'll also introduce parseapp-cljs and its accompanying Leiningen template, two tools we built to enable ClojureScript development on's Cloud Code platform.

  55. Vincent Rivellino

    Room Key

  56. ×

    Vincent Rivellino | @vince_riv

    Room Key


    Vince is the Operations Lead for Room Key and supports a production Clojure web application environment hosted in Amazon Web Services that handles approximately 15 million visitors a month. Within this environment is a Datomic database backed by DynamoDb that has been operational for a year and a half.

    DevOps Done Right: Room Key’s Datomic Deployment in AWS

    Making the transition from a development and/or test deployment of Datomic to a production deployment can be a daunting task for the uninitiated. This presentation will provide an overview of’s Datomic deployment, the evolution there-of, real world examples of deployment methodology to the audience, and the pitfalls Room Key stumbled upon during the course of operating Datomic in a production environment.

    Real world examples of CloudFormation templates will be shared, along with examples of how to perform transactor and peer upgrades with minimal database downtime.

    In addition to Datomic, Amazon Web Services will be at the heart of the discussion, so familiarity with AWS will be helpful to audience members.

  57. Zach Tellman


  58. ×

    Zach Tellman | @ztellman



    There is a sense of emptiness that comes over Zach Tellman at evening, with the odor of elephants after the rain and the sandalwood ashes growing cold in the braziers, a dizziness that makes rivers and mountains tremble on the fallow curves of the planispheres where they are portrayed, and rolls up, one after the other, the dispatches announcing to him the collapse of the last enemy troops, from defeat to defeat, and flakes of the wax of the seals of obscure kings who beseech his armies' protection, offering in exchange annual tributes of precious metals, tanned hides, and tortoise shell.

    Predictably Fast Clojure

    Clojure can be as fast as Java, but that doesn't mean it always is. This is an exploration of the abstractions and data structures used by Clojure, their performance characteristics, and when it's appropriate to strike off on your own.

our sponsors


Sign up for updates on Clojure/West