first clojure-conj

22 - 23 Oct 2010, Durham, NC

The Speakers

  • Aaron Bedra

    Aaron Bedra has led the development of several commercial projects using Clojure and Compojure. He is a regular speaker on Clojure at conferences such as DevNation and the No Fluff, Just Stuff symposium series.


    Follow @abedra » Go to »
  • Sean Devlin

    Sean Devlin discovered Clojure out of necessity, when he had to stretch a one man operation even further in a previous job. He now works on network monitoring applications at Sean has an Electrical Engineering degree from the University of Delaware.

    Protocol XIII: Clojure Protocols Explained

    Everyone seems to be interested in protocols, but not too many tutorials exist on the topic. I'm assuming that we'll have a fair amount of video game fans in the audience. The goal of this talk is to explain how protocols & datatypes work by analogy, using the Final Fantasy XIII character & job system.

    Follow @fulldisclojure » Go to Full Disclojure »
  • Chas Emerick

    Chas Emerick is a coauthor of the forthcoming "Clojure Programming" book from O'Reilly, founder of the Snowtide, architect of DocuHarvest, and has called the Clojure community home for more than two years. He has contributed significantly to both Clojure and clojure-contrib, dozens of other open source Clojure libraries, and tries to be a consistently helpful, friendly presence in #clojure.

    (Continuous) Deployment of Clojure Web Applications

    Building applications with Clojure and its web frameworks is a relatively well-understood process. However, programmers and organizations often find themselves ill-prepared to deploy their creations to the wider world in ways that maximize reliability and scale, minimize administrivia, and accelerate the time spent between conceptualizing new capabilities and getting them into the hands of users and customers. This talk will present a Clojure-centric approach to the deployment problem, using jclouds to coordinate the provisioning of resources, and pallet to declaratively configure those resources and deploy applications. Depending upon the time allotment, integrating this process into Hudson to "close the loop" on a continuous deployment process will be described and exhibited.

    Follow @cemerick » Go to »
  • Tom Faulhaber

    Tom Faulhaber has been dabbling in Lisp since the days of Lisp 1.5. For the past two years, he has been using and contributing to Clojure, including writing the Clojure pretty printer and the autodoc tools used to create the online documentation for Clojure and Incanter. Other Clojure projects include a web application for viewing live video streams and statistical analysis tools for manufacturing.

    Outside of Clojure, Tom has a varied background. Starting his career as an operating system and networking hacker, he developed the TCP/IP implementation for SVR4 Unix. Later, he moved to graphics and was a lead developer on the Application Visualization System (AVS), a dataflow-based environment for creating rich visualizations of scientific processes from the big bang to oil exploration. More recently, he has been a management consultant and developed children's games, data warehousing transaction systems, and an ORM that includes real-time notification of changes.

    Tom currently serves as Director of Engineering at 3VR Security and is active in the Bay Area Clojure Users Group.

    Lisp, Functional Programming, and the State of Flow

    Since the beginning of computer science, many programmers have been driven by a desire to feel a oneness with the essentially abstract processes on which they're working. In no area has this been more pronounced than symbolic computation and AI. Hackers working through the night, night after night, to find that connection with information and abstraction were legendary from Cambridge to Palo Alto throughout the 60's and 70's and entered the mainstream consciousness in movies such as The Matrix in the Internet generation.

    It should come as no surprise then that the ideas presented by Mihaly Csikszentmihalyi in Flow: The Psychology of Optimal Experience (and a very famous 2004 TED presentation) found an excited audience among the Hacker News crowd. Csikszentmihalyi describes (and validates) a condition that many of us have sought out and enjoyed for many years.

    In this talk, we will explore how particular programming concepts, especially those found in Lisp and functional languages, seem to enhance the quality of flow we achieve while programming. Many Clojure programmers have described the enjoyment they find programming in Clojure. I want to investigate that and see why it's important to work in a language that makes programming fun.

    Follow @tomfaulhaber » Go to »
  • Michael Fogus

    Co-author of The Joy of Clojure and a programmer in the DC area currently working on web-services, code generation, and distributed systems.

    Fertile Ground: The Roots of Clojure

    Whereby I explore some of the programming language and paradigm influences on the Clojure programming language. Clojure contains its own novelty, but its greatest strengths are built on the foundation of existing language features. I will go through a handful of features in my 30 minutes and explain how they were influenced by existing features in other programming languages. LIkewise, I will explain how Clojure diverges from its progenitors.

    Follow @fogus » Go to »
  • Christophe Grand

    Christophe Grand, a French independent consultant, is a long term member of the Clojure community and contributor to Clojure. He is also the author of the Enlive and Moustache libraries. He blogs on Clojure at

    (not= DSL macros)

    Too often, one writes a DSL by starting with macros. However, this is often a case of premature optimization. An approach centered around "DSV" (domain specific values) and an interpreter leads to greater dynamicity. Macros can be added afterwards for optimization purposes or as syntactic sugar.

    Follow @cgrand » Go to »
  • Phil Hagelberg aka technomancy

    Phil Hagelberg (aka technomancy) used to write a lot of Ruby, but these days he is better known as the author of Leiningen and the Emacs Starter Kit. He currently maintains clojure-mode and swank-clojure and has written commercial screencasts on Clojure and Emacs for PeepCode. Phil works for Sonian out of his home in Seattle where he has started Seajure, the Seattle Clojure group.

    Making Leiningen Work for You

    Everyone is probably familiar with the basic Leiningen workflow: new, deps, test, swank, etc. But there's more to our resourceful friend than meets the eye. Learn how to customize Leiningen for your project and how to teach it new tricks through plugins.

    Follow @technomancy » Go to »
  • Stuart Halloway

    Stuart is the author of Programming Clojure. He advises the Clojure/core team on matters of mentorship, training, and practical development with Clojure.

    Simplicity Ain't Easy

    A quick review of what programmers have to say about simplicity might lead you to the following (incorrect!) conclusions:

    • every language/design approach/tool under the sun lays claim to simplicity, usually as a key virtue
    • simplicity means many different things and is so subjective as to be worthless
    In fact, simplicity is objective. It has a definition, and an etymology, that are very useful to software developers. In this talk, we will:
    • cut through the noise to the definition of simplicity
    • demonstrate how simplicity informs the design of Clojure, and Clojure programs
    • help you make your programs simpler, and explain to others what this means, and why.

    Follow @stuarthalloway » Go to Relevance, Inc. »
  • Rich Hickey

    Rich is the inventor of Clojure. He serves as an advisor to the Clojure/core team, bringing his technical expertise in matters of Clojure and programming in general to ensure the highest quality development and mentoring experience for our customers.


    Clojure's time model exposes the state of an object as a series of immutable values, each value a function of the prior. But that function need not be pure. Transients hinted at the potential here. In fact, the production of a new value from the prior is, or can be, a process. Safely extending that process over time and to multiple (potentially concurrent) participants is the job for a new reference type, code-named "pods."


    Prepare to be provoked.

    Go to »
  • Chris Houser

    Chris Houser is a co-author of The Joy of Clojure, and an primary contributor to Clojure and Contrib. An "old hand" in the #clojure IRC channel, he culpable for Contrib libraries including lazy-xml, zip-filter, error-kit, ClojureScript, and much of repl-utils. He is excited to see where Clojure is going and looking forward to helping it get there.

    Finger Trees: Custom Persistent Collections

    Clojure's existing persistent collection types cover many usage scenarios, but do leave a few gaps. Finger trees can fill gaps such as sorted sets with efficient support for 'nth', sequential collections that can grow at the front, the back, or even insert values anywhere in the middle, and more. In fact, finger trees can be customized to support a variety of application-specific needs while remaining persistent and playing nicely with Clojure's sequence and collection abstractions. We'll look at examples of using and customizing finger trees, and talk a bit about their internals.

    Follow @chrishouser » Go to »
  • David Liebke

    David Edgar Liebke is the author of Incanter, a statistical computing and graphics environment for Clojure. He has a B.S. in cognitive science (UC San Diego), M.S. in applied mathematics and statistics (Georgetown), and an M.B.A. (UC Irvine).

    From Concurrency to Parallelism

    Concurrency is commonly mistaken for parallelism, but the two are distinct concepts. Concurrency is concerned with managing access to shared state from different threads, whereas parallelism is concerned with utilizing multiple processors/cores to improve the performance of a computation.

    Clojure has successfully improved the state of (single VM) concurrent programming, and now the goal is to do the same for (single VM) parallel programming.

    A promising approach to achieving this goal is to leverage the functionality of JSR 166, based on Doug Lea's Fork/Join Framework. This work began in Clojure's "par" branch, and is now under active development for Clojure 1.3.

    This talk will 1) layout the goals for improving parallel programming in Clojure, 2) provide illustrated walk-throughs of both the general fork-join algorithm and a version of the algorithm that exploits specific properties of Clojure's persistent data structures, the latter of which is used by the parallel map and reduce functions found in Clojure's "par" branch, and 3) compare the performance characteristics of the fork-join enabled map function with the current map and pmap functions.

    Follow @liebke »
  • Mark McGranaghan

    Mark is an engineer at Heroku, where he works on platform infrastructure. Previously, he was a web developer at TechCrunch and student at Bowdoin College.

    One Ring to Bind Them

    Ring is a tool for writing web applications in Clojure. It provides some functionality itself, but also acts as a binding between various other Clojure web libraries. In this talk I discuss how the Ring spec enables this interoperability, show examples of Ring-based libraries, and discuss the emerging Clojure web development ecosystem. I suggest that web development with Ring is an example of the more general idea of composable, functional abstractions.

    Go to »
  • Laurent Petit

    Laurent Petit is a French software developer based in Lyon, France. Laurent worked 8 years for consulting companies and is now software developer at Yseop in the R&D department (Yseop is the software vendor of a disruptive innovation based on artificial intelligence for automating text generation). Laurent fell in love with clojure in early 2008, and is a long term member of the Clojure community. He is the core developer of Counterclockwise (aka ccw), an Open Source Eclipse plugin helping developers write Clojure code; and of paredit.clj, an Open Source effort to port the most interesting parts of paredit.el (the famous emacs structural text edition mode) to pure -and in an IDE/GUI agnostic way- Clojure.

    State of Counterclockwise: Past, Present and Future

    In this talk, I will present Counterclockwise aka ccw, a set of Eclipse plugins aimed at easing the development of Clojure projects. First, I will give an overview of the features, focusing on some with an interactive demo. Next, I will take my hands off of the keyboard to explain my goals as the core committer of ccw, starting with a brief explanation of why I chose to get on board, and a tentative projection of where it could be in the near and middle future.

    Follow @petitlaurent » Go to the Counterclockwise website »
  • Stuart Sierra

    Stuart Sierra is a member of the Clojure/core team and the author of several popular open-source Clojure libraries. He is the co-author, with Luke VanderHart, of the book Practical Clojure recently released from Apress. Stuart received his M.S. in Computer Science from Columbia University. He lives in New York City.

    "Functional Programming and You"
    Or, "How I Learned to Stop Writing Compilers and Love Functional Abstraction"
    Or, "Macros are like Fight Club"

    Come with me on a journey, a journey that begins with a simple idea -- to write a better testing framework for Clojure -- and ends with a theory of how software should be designed. Along the way, we'll take a look at the universality of Clojure's data abstractions, the power of function composition, the pitfalls of inventing new scoping rules, and various corollaries to Greenspun's Tenth Rule of Programming.

    Follow @stuartsierra » Go to »
  • Luke VanderHart

    Luke VanderHart is a long-time Clojure user and co-authored the book Practical Clojure with Stuart Sierra. He currently lives in Annapolis, MD and works as a consultant with NuWave Solutions in the DC area.

    Clojure Zippers

    An introduction to the Clojure zip data structure, which supports fully functional tree navigation and editing. Includes a discussion of how to use the data structure effectively, as well as an overview of its performance characteristics.

    Follow @levanderhart »