•  

Clojure/West 2013 schedule

View as grid

Monday 18th March 2013

  • Cascalog: Logic programming over Hadoop

    by Alex Robbins

    Cascalog is a clojure library that makes it easier to write distributed batch processing jobs. It is built on top of Hadoop, but allows computations and queries to be written at a much higher level of abstraction. Cascalog allows large, distributed processing jobs to be written in a declarative manner, greatly shortening and simplifying writing many Hadoop tasks.

    This talk will provide an introduction to Cascalog, a brief tour of its features, and finish with writing a sample application using some live coding. The intent is to help people unfamiliar with Cascalog to identify places it could be of use in their systems.

    At 9:00am to 9:40am, Monday 18th March

    In Studio theater, Gerding Theater at the Armory

  • Domain Driven Design with Clojure

    by Amit Rathore

    For a lot of us, Clojure is very different from anything we’ve used before. The syntax is different, the functional paradigm is different, multimethods are new, the macro system is alien, immutability, side-effects, mutating state, protocols, data-types, reify... oh my!

    Even after understanding the basics of the language, there’s often uncertainty about how to go about writing programs. How to structure applications? What goes where? What kind of layers? What about I/O? What’s the scene with TDD? Mocking or stubbing? What about distributed computation? How to organize namespaces? What’s this bottom-up thing? Composition? Meta-linguistic abstraction? Really?

    This talk is drawn from multiple large-scale Clojure systems, across nearly 5 years of real-world Clojure usage. You’ll see how to get started with designing non-trivial applications, how to ensure the code communicates to anyone reading it, and how to ensure you can grow the code-base and the team, with some level of sanity.

    At 9:00am to 9:40am, Monday 18th March

    In Main stage theater, Gerding Theater at the Armory

  • RESTful Clojure

    by sivajag

    Everyone knows the value of exposing their web APIs to internal and external clients. A well written web API is a great asset to any organization and to all that use it.

    Now, there’s been enough written and said about this topic, so what new ground could we cover here? The question we’ll try to answer is, “then why do most web APIs suck so bad?"

    This talk is about a holistic, end-to-end approach on how to build good web APIs using Resource Oriented Architecture (ROA) and Clojure. I’ll talk about the importance of ROA, and then show to build an awesome web APIs example Clojure code. And yes, it will be Richardson Maturity Model Level 3 compliant. Don’t know what that is? You’ll learn that too!

    At 9:50am to 10:30am, Monday 18th March

    In Studio theater, Gerding Theater at the Armory

  • The Data-Reader's Guide to the Galaxy

    by Steve Miner

    Don't panic if you're unsure about picking up data-readers. It turns out that tagged literals are mostly harmless. Much as Douglas Adams produced "The Hitchhicker's Guide" material in multiple forms, a Clojure programmer can assign data-readers to process tagged literals with customized implementations. Clojure 1.5 adds a new feature that makes dealing with unknown tags simple and convenient. We'll also talk about the Extensible Data Notation (EDN), which aims to be the Babel fish of data transfer. Finally, we will explore a few unothordox uses for data-readers.

    At 9:50am to 10:30am, Monday 18th March

    In Main stage theater, Gerding Theater at the Armory

  • Building a PaaS in Clojure

    by arohner

    We built a Platform-as-a-Service written entirely in Clojure. CircleCI has run hundreds of thousands of builds for thousands of customers and every line is written in Clojure.

    PaaSs tend to be written in a combination of scripting languages and bash. However, Clojure's features were uniquely well-suited for the task. Clojure allowed us to compose high level features such as DSLs, threading macros, multithreading, middleware with very low-level concepts such as EC2 machine managment, VM building, filesystem twiddling, and running arbitrary user commands over SSH.

    We discuss what went and well, and problems we faced, including JVM OOMs, horizontal scaling and distributed systems headaches.

    At 10:40am to 11:20am, Monday 18th March

    In Studio theater, Gerding Theater at the Armory

  • Engines of Abstraction

    by Jim Duey

    "If I have seen further it is by standing on the shoulders of giants.", a quote by Isaac Newton, succinctly expresses the art of programming. We build software on a foundation made with layers of abstractions that others have built.

    This talk surveys several abstraction techniques that can help us build sound applications on the foundation of Clojure and highlights how we're already using specific examples of such abstractions in ad hoc fashion today.

    At 10:40am to 11:20am, Monday 18th March

    In Main stage theater, Gerding Theater at the Armory

  • Clojure in the Large

    by Stuart Sierra

    Having an expressive programming language like Clojure comes with a price: it's not always clear how programs should be structured. Without classes in the traditional OOP sense, what are the fundamental building blocks of an application? How do we divide up our source files? Where do different kinds of state and behavior "belong"? These problems become more acute as programs grow larger and more complex.

    This talk will present patterns for building Clojure programs out of independent components. Topics will include:

    • Achieving modularity with protocols and dependency injection.
    • Managing startup / shutdown of components.
    • When (not) to use dynamic binding.
    • Interactive development with tools.namespace.
    • Testing and mocking.

    At 12:40pm to 1:20pm, Monday 18th March

    In Main stage theater, Gerding Theater at the Armory

  • Introducing Pedestal: Architecture and Services

    by Tim Ewald and Brenton Ashworth

    Pedestal is a set of libraries for building rich interactive Web
    applications using Clojure, ClojureScript and EDN. This talk starts
    with the big picture: problems Pedestal is designed to solve and the
    typical architecture of a Pedestal application. Then it dives into
    HTTP services, covering the details of the plumbing, including it's
    relationship to Ring, and how they enable collaborative applications.

    At 1:30pm to 2:10pm, Monday 18th March

    In Main stage theater, Gerding Theater at the Armory

  • Introducing Pedestal: Rich Client Applications

    by Brenton Ashworth and Tim Ewald

    This talk will build on part 1, starting with a statement of the problems
    faced when building large interactive applications in the browser. The
    talk will then show how the ideas behind Clojure can be used to solve
    these problems. Finally, it will introduce a model and tools for building
    applications which make them easier to build, test and reason about.

    At 2:10pm to 2:50pm, Monday 18th March

    In Main stage theater, Gerding Theater at the Armory

  • Beyond Contracts: An exploration into unified specifications

    by Paulie

    Clojure's rich interactive development encourages developers to explore a solution space while experimenting within a problem domain. But what if those explorations could be captured as tangible specifications, and used to automatically generate tests and documentation, be applied as contracts for functions, and even used in external verification systems?

    This talk dives into such a system, illustrating the advantages of unifying core.contracts, test.generative, and external systems under a single common specification, captured as a value.

    Specification-as-a-value serves as a useful tool that guides developers through all phases of the software development lifecycle: from design to deployment. A single specification could ensure your conceptual design is complete, that your functions conform to the design at runtime, and the functions pass an array of automatically generated tests.

    At 3:10pm to 3:50pm, Monday 18th March

    In Main stage theater, Gerding Theater at the Armory

  • Design, Composition, and Performance

    At 4:00pm to 5:00pm, Monday 18th March

    In Main stage theater, Gerding Theater at the Armory

Tuesday 19th March 2013

  • Piplin - A DSL for describing silicon in Clojure

    by David Greenberg

    Designing hardware is a fascinating and frustrating procress–the virtually unlimited parallelism and customizability are often outweighed by the simple, relatively inexpressive languages would-be hardware programmers must use. Piplin is an open-source DSL that allows a subset of Clojure to be automatically converted into a hardware description, which can then be placed onto an FPGA or made into a silicon chip.

    Piplin has several interesting features: it provides polymorphic implementation of the standard Clojure library, along with a flow-typing and inference system that allows for libraries to define new numeric and structural types. Piplin also takes an atypical approach to embedding–it can actually produce hardware descriptions or Clojure functions without any performance penalty due to an innovative internal representation.

    This talk will discuss the design of Piplin, focusing on how it leverages Clojure's polymorphic capabilities to provide an extremely flexible system for simulating and synthesizing hardware modules in Clojure.

    At 9:00am to 9:40am, Tuesday 19th March

    In Studio theater, Gerding Theater at the Armory

  • Winning the War on Javascript

    by Bodil Stokke

    When Rich Hickey in his great benevolence took pity on web developers and gave us Clojurescript, he freed us from the burden of Javascript and its many Bad Parts, and brought the design principles of Clojure—or at least those that could be ported—to the browser platform.

    Sadly, though, he could do little about the preexisting APIs, which embody none of those principles. The DOM and its equally vile cousins are all stubbornly object oriented, referentially opaque, and for the most part splendid examples of how not to design clean and friendly APIs.

    Don't worry, though: Clojure is a language flexible enough to overcome any adversity. In this talk, Bodil shares with you the interop horrors she faced building the Catnip web based editor and the Dog Fort web server, and the tools and abstractions that came out of the process of having to deal with Node and the browser, both single threaded and staunchly object oriented environments.

    At 9:00am to 9:40am, Tuesday 19th March

    In Main stage theater, Gerding Theater at the Armory

  • Metaprogramming Polyfill: Feed Clojure Data to your JavaScript Libraries

    by tom white

    We should make it as easy as possible to use JavaScript libraries idiomatically from ClojureScript. While ClojureScript functions and JavaScript functions are wonderfully interchangeable, the same is not true for idiomatic Clojure and JavaScript data structures. The impedance mismatch can be found as data translation points sprinkled through the code, and are often spelled clj->js and js->clj. What a shame that after we data all things, we find we have to make an explicit runtime copies back and forth for our JavaScript friends.

    In many cases it turns out that this data translation is unnecessary. By adding some JavaScript metaprogramming to ClojureScript prototypes, we can polyfill JavaScript libraries so that they can natively use ClojureScript collection classes. With just a wee bit of hackery, a JavaScript library will think that all ClojureScript seqs are JavaScript arrays and all ClojureScript maps are JavaScript objects. Tom will show examples of using this technique to write idiomatic ClojureScript code that uses the d3.js dynamic graphing library.

    At 9:50am to 10:30am, Tuesday 19th March

    In Main stage theater, Gerding Theater at the Armory

  • PuppetDB: Sneaking Clojure into Sysadmins' Toolkits

    by D Giridharagopal

    Puppet is the most widely deployed open-source configuration management tool on the planet, written in Ruby. As deployments got bigger, people began demanding more of Puppet: store more data, store it more reliably, store it more quickly, and give us better ways to access it.

    Thus, PuppetDB was born. It's an open-source, centralized storage system for Puppet users; it persists object graphs, key-value data, and time-series logging information. Ruby wouldn't cut it for us. Written in Clojure, it features a bespoke query language and compiler, exploits and embeds a wide variety of JVM libraries such as ActiveMQ and Jetty, uses a whole ton of Clojure libraries for things ranging from cheshire to ring to clojureql to slingshot and so on.

    In this talk we'll discuss a few major topics: what PuppetDB does and how it does it, the experience of bringing Clojure to a Ruby shop (comparing and contrasting the toolchains), and things we learned from having thousands of non-developers consuming our Clojure code.

    At 9:50am to 10:30am, Tuesday 19th March

    In Studio theater, Gerding Theater at the Armory

  • Global Forest Watch: an open source Clojure project to monitor deforestation from satellite imagery

    by Dan Hammer

    Deforestation accounts for 15% of annual greenhouse gas emissions, more than the entire global transportation sector. We will all die if carbon emissions continue apace. Any viable effort to curb the rate of deforestation depends on open and transparent monitoring of forest clearing activity.

    We have developed an algorithm to parse terabytes of NASA satellite imagery toward a tractable estimate of deforestation at 500-meter resolution, updated every 16 days. The algorithm is now the basis for Global Forest Watch, which will be released in April 2013 by the World Resources Institute.

    We rely on Clojure and Cascalog to analyze and classify the spectral time series of each pixel in the humid tropics. A few off-shoot Clojure projects support the data processing, including lein-emr to manage an Amazon Web Services cluster and cartodb-clj to interact with a large-scale spatial database directly from the Clojure environment.

    At 10:40am to 11:20am, Tuesday 19th March

    In Studio theater, Gerding Theater at the Armory

  • Securing Clojure webapps and services with Friend

    by Chas Emerick

    Friend is "an extensible authentication and authorization library for Clojure Ring web applications and services".

    We'll take a look at Friend's overall design and how you can use it to model and implement authentication and authorization for your app within the Ring tradition. We'll also go beyond well-worn paths like interactive form login and role-based authorization to see how Friend may be extended to implement things like multi-factor authentication, phishing prevention, and arbitrary authorization schemes.

    At 10:40am to 11:20am, Tuesday 19th March

    In Main stage theater, Gerding Theater at the Armory

  • clj-v8 and the Dieter Asset Pipeline

    by Paul Biggar

    Lots of web front-ends are written in DSLs such as CoffeeScript, Less and Haml. Dieter and clj-v8 combine to provide a fast, effective asset pipeline for Clojure web apps.

    We use dieter in a production Clojure web application, used by thousands of developers. Dieter is easy to use, written in the Clojure way, and - through integration with the V8 Javascript engine - very very fast.

    A tale of low-level integration, optimization, beautiful code and clean abstractions.

    At 1:00pm to 1:40pm, Tuesday 19th March

    In Studio theater, Gerding Theater at the Armory

  • Clojure and LLVM

    by Timothy Baldridge

    LLVM is a compiler toolkit for developing native languages. With companies from NVidia, to Apple pouring resources into this project, how can we leverage these libraries in Clojure?

    In this talk, I will show my work writing a compiler in Clojure that uses LLVM for code generation. This project is known as clojure-py2. This from-the-ground re-write of clojure-py uses LLVM to create native (machine-code) Python extension modules on the fly. The resulting code is not only faster than python, but with proper type hints can approach the speed of ClojureScript and Clojure.

    Running Clojure on Python opens up new areas to explore. Systems like the Raspberry Pi are often too memory constrained to run a JVM language. Python fills this gap by running closer to the metal, while also providing an extremely rich set of libraries to pull from.

    At 1:00pm to 1:40pm, Tuesday 19th March

    In Main stage theater, Gerding Theater at the Armory

  • clojure-scheme: Compiling Clojure to Native Code via Scheme

    by Nathan Sorenson

    Clojure's targeting of the JVM makes a vast array of libraries readily available. However, this dependency puts certain platforms, such as iOS mobile devices, out of reach. With the advent of cross-compilation approaches such as ClojureScript, these limitations are starting to lessen. This talk will focus on clojure-scheme, a recent fork of the ClojureScript compiler that translates Clojure code to Scheme code. In combination with the mature and robust Gambit Scheme compiler, it now becomes possible to compile this Schemified Clojure code to raw C. This talk will show how to use this trick to perform stunning feats never seen before, such as creating tiny and efficient executables or running Clojure code natively on iOS with full access to Objective-C libraries. We will also look behind the curtain and see the semantic similarities between Scheme and Clojure that make this technique straightforward, as well as the differences that pose more difficulty.

    At 1:50pm to 2:30pm, Tuesday 19th March

    In Studio theater, Gerding Theater at the Armory

  • Core.logic and SQL Killed my ORM

    by ℭґ@ḯℊ ℬґ◎ℨεḟṧк⑂

    The relational programming model provided by core.logic frees developers from the impedance mismatch, and other limitations of Object Relational Mapping systems (ORMs). This allows for massive gains in write speed and schema flexibility, avoids the rigidity of a single entity-relationship model and artifical notions like object identity, and greatly reduces the complexities of modeling time and change.

    By extending core.logic defrel/fact we were able to define a set of relations that worked both with core.logic, and also mapped naturally to SQL tables. A single data model was used to build our rule system for identifying malware behavior, as well as being the schema for our analysis and correlation database which is served up via a Clojure web app.

    In this talk we will be presenting the tradeoffs involved with moving to a purely relational model, and ditching your ORM. We will also introduce some of the tools we built to facilitate this.

    At 1:50pm to 2:30pm, Tuesday 19th March

    In Main stage theater, Gerding Theater at the Armory

  • FRP in ClojureScript with Javelin

    by Alan

    Functional Reactive programming (FRP) is a paradigm that holds great promise in the ClojureScript world as a way to mitigate the difficulty of modeling control flow and side effects in the browser. FRP techniques allow one to write "reactive" code in terms of dependency relations instead of in terms of callbacks or watches.

    I'll introduce Javelin, a ClojureScript library, and demonstrate how it can be used to express a variety of asynchronous workflows in concise and composable ways.

    Along the way, I’ll compare FRP with spreadsheets, contrast FRP with Clojure's sequences, and cover some of the ideas, implementation techniques, and vocabulary common to many FRP libraries.

    At 1:50pm to 2:30pm, Tuesday 19th March

    In Main stage theater, Gerding Theater at the Armory

  • Introducing ClojureScript-in-ClojureScript

    by Joel Martin

    I would like to introduce you to a new compiler that I have been working on: ClojureScript-in-ClojureScript. The current ClojureScript compiler leverages the regular Clojure compiler for much of the heavy lifting. ClojureScript-in-ClojureScript (cljs-in-cljs) is a port of ClojureScript (including the Clojure top-half and other JVM specific code) entirely to ClojureScript.

    This talk will describe the process of creating cljs-in-cljs and the missing pieces that had to be ported or created from scratch. I will walk through the read/analyze/emit/eval process for several common Clojure forms and describe the difference in handling between the three compilers (Clojure, Cljs, cljs-in-cljs). Along the way I will discuss some of the deep dark magic at the heart of both the Clojure and ClojureScript compilers (namely vars and namespaces) and I will describe the alternate solutions I used for cljs-in-cljs.

    I will also demonstrate the cljs-in-cljs port in action and give an idea of where and why it is useful. Finally I will discuss where I would like to see cljs-in-cljs go in the future and what it will take to merge it upstream.

    At 3:00pm to 3:40pm, Tuesday 19th March

    In Studio theater, Gerding Theater at the Armory

  • Code Execution as Data

    by Zach Tellman

    A system in motion generates tremendous amounts of ephemeral data.

    We put some of it our logs, trying to capture as much context as we can without drowning in it, but this gives us only glimpses of what's actually going on. We can use the logs and source code to guess, but this remains a painful, error-prone process.

    This talk will discuss how to instrument and analyze running systems, using real world examples from Factual's production systems.

    At 3:50pm to 4:30pm, Tuesday 19th March

    In Main stage theater, Gerding Theater at the Armory

  • Macros: Why, When, and How

    by Gary Fredericks

    Macros are the classic meta-feature of lisps, enabling the implementation of nearly anything imaginable. On the other hand they're frequently overused and their overuse is frequently complained about. Against all good judgment, we will give an intuitive account of what macros are, how they work, and how to analyze their behavior; give advice for when to use them or avoid them, and how to write good ones when you need to; and show off some of the wilder possibilities.

    At 3:50pm to 4:30pm, Tuesday 19th March

    In Studio theater, Gerding Theater at the Armory

  • core.logic.nominal

    by Nada Amin

    [This session is part of the miniKanren Confo colocated with Clojure/West.]

    Nominal logic simplifies reasoning about scope and binding, so that implementing interpreters and type inferencers is almost as easy as on paper. Inspired by alphaKanren, we embed nominal logic programming into Clojure. Unlike alphaKanren, which is incompatible with cKanren, core.logic.nominal extends core.logic. In this talk, I will introduce the core.logic.nominal primitives (fresh, tie, hash), show some examples (quine generator, typed lambda calculus, theorem prover) and highlight our implementation.

    On Tuesday 19th March

    In Sequoia II, Marriot Courtyard City Center

  • Intro to CLP with core.logic

    by Ryan Senior

    [This session is part of the miniKanren Confo colocated with Clojure/West.]

    Traditional logic programming allows only a single constraint via equality. Until recently, this was the only option in core.logic. Constraint Logic Programming (CLP) allows the user to declare more specific information about the possible values of a variable. A variable could be declared as a number in a specific range, for example. This goes beyond a basic equality check and allows for efficient higher level operations, such as arithmetic. With features inspired by cKanren, core.logic now has support for CLP. This opens up another large set of problems that core.logic can help solve efficiently. This talk will introduce CLP using core.logic through examples and live coding. The coding and examples will build to some logic puzzles and give attendees the essential background to have some fun with core.logic and CLP.

    On Tuesday 19th March

    In Sequoia II, Marriot Courtyard City Center

  • Logic programming in the wild

    by werg

    [This session is part of the miniKanren Confo colocated with Clojure/West.]

    Logic programming may be powerful, but it is hard to apply. Even experienced developers get tripped up by unwelcome surprises time and again. Accordingly, hardly any real software gets written in Prolog -- and many who do work with logic programming focus on very clever (but at times contrived) toy problems.

    miniKanren and kin are an exciting development because they integrate well with their functional host language and get many things right, promising to get more actual work done. Nevertheless I believe there still is room for development.

    In my talk I will focus on LP in two core areas that should matter strongly to working software developers: metaprogramming and data access (both in a wide sense). I will outline the potential LP has in these areas and study some major roadblocks to realizing this potential, with respect to formalisms and cognitive load.

    We will proceed to take apart the core components of logic programming and look at ways to reassemble them with more leverage. Using that leverage we can introduce features to guide and assist developers avoiding everyday LP madness. I will provide a survey of new and well-known techniques to deal with some of the most pressing usability issues in logic programming.

    I might claim that LP language designers have yet been neither crazy and nor considerate enough to both sufficiently empower and shield users and victims of logic programming in the wild.

    On Tuesday 19th March

    In Sequoia II, Marriot Courtyard City Center

  • Molog: Typed Functional Logic Programming in Haskell

    by Adam Foltzer

    [This session is part of the miniKanren Confo colocated with Clojure/West.]

    Molog is an experimental derivative of miniKanren embedded in Haskell, designed to bring to bear the power of Haskell's type system on logic programs. In this talk, I will show Molog versions of familiar examples, give an overview of the distinction between relational and functional logic programs, describe how Molog's core persistent heap monad enables optimizations like path compression, and survey the challenges and benefits of insisting on strong types for a logic programming language.

    On Tuesday 19th March

    In Sequoia II, Marriot Courtyard City Center

  • The Architecture of core.logic

    by David Nolen

    [This session is part of the miniKanren Confo colocated with Clojure/West.]

    core.logic is designed to be extended to whatever constraint domain you please. We'll examine the various design decisions that allow different constraint solvers to peacefully coexist under the same framework.

    On Tuesday 19th March

    In Sequoia II, Marriot Courtyard City Center