The Datomic Architecture and Data Model
This talk will discuss the design of Datomic, and the connections to the ideas behind Clojure.
About the speaker: Rich Hickey, the author of Clojure, is an independent software designer, consultant and application architect with over 20 years of experience in all facets of software development. Rich has worked on scheduling systems, broadcast automation, audio analysis and fingerprinting, database design, yield management, exit poll systems, and machine listening.
Evident Code, at Scale
According to Webster, evident means "clear to the vision or understanding." In this talk, I will present specific practices that you can apply to make your code more evident, particularly on larger projects.
It is relatively easy to make toy-sized programs evident, but the exciting aspect of these ideas is their application at scale. I will share insights from my own experience applying these practices on a multi-year product effort undertaken in Clojure.
About the speaker: Stuart is the author of Programming Clojure. He advises the Clojure/core team on matters of training and practical development with Clojure.
Why Prismatic goes faster with Clojure
Prismatic delivers realtime newsfeeds for thousands of learned topics based on your interests and social networks. The Prismatic backend requires many custom abstractions, sophisticated machine learning techniques, data crawling, and graph analysis algorithms. We discuss how our small backend team (just four engineers) built this stack in record time using a unique design philosophy facilitated by Clojure. In a nutshell, our problem-solving approach prefers lightweight composable custom abstractions for problems rather than monolithic open-source frameworks (e.g., Hadoop).
We talk about how Clojure lets us achieve maximal productivity-per-person and extreme reuse, all while maintaining high performance. We highlight key elements of our stack:
- Flop & Optimize: our fast primitive array manipulation and numerical optimization library. This library is written in pure Clojure and its performance matches optimized Java performance without sacrificing expressiveness or succinctness; for instance, a state-of-the-art numerical optimization is implemented in < 180 lines of clojure.
- Store and Graph: our library of storage abstractions and real-time graph processing respectively. These are fine-grained abstractions customized to our needs (lots of streaming data, real-time monitoring of processing) and admit high-reuse throughout code base, including for communications infrastructure like pub-sub and nameservers.
- Newsfeeds: our service that delivers real-time ranked newsfeeds for thousands of topics. We tackle these problems using custom in-memory data structures and checkpointing rather than heavy re-use of our other libraries. Clojure lets us develop performant lightweight problem-specific solutions very quickly.
About the speaker: Bradford is the CEO of Prismatic. Before starting Prismatic, he was a founder at Flightcaster, where he built the core flight delay prediction systems. Prior to Flightcaster, he worked on infrastructure at Google via ThoughtWorks. He studied Computer Engineering and Finance and Virginia Tech, and studies Mathematics at UC Berkeley.
Engineering(,) A Path to Science: “I don’t want to die in a language I can’t understand”
I’m going to talk about one, old paper: “Mixin-based Inheritance,” by Gilad Bracha and William Cook, published in 1990. Bracha is now one of Google’s Dart guys. I will draw two observations from that paper in its context, one trivial but difficult for some to believe, and one complex whose implications might surprise. The first is that in the discipline of programming languages, engineers create the nature that computer scientists study—that is, engineering precedes science. The second is that we can use Thomas Kuhn’s and Paul Feyerabend’s notion of incommensurability to detect paradigm shifts in our field, and what we learn by doing that can be surprising.
In case this sounds boring to you (fair enough), consider how Kuhn stumbled on the idea of incommensurability:
Incommensurability is a notion that for me emerged from attempts to understand apparently nonsensical passages in old scientific texts.
About the speaker: Richard P. "Dick" Gabriel overcame a hardscrabble, working-class upbringing in the dreadfully industrialized and famously polluted Merrimack Valley of eastern Massachusetts to become one of the few genuine Renaissance men to emerge from the OO milieu: scholar, scientist, poet, performance artist, entrepreneur, musician, essayist, and yes, hacker...
Though somewhat less well-endowed of the effortless intellectual incandescence, easy charisma, and raw animal magnetism of so many of his generation of future object-oriented luminaries, he was able, with discipline, determination, and hard work, to survive the grueling demands of elite, first-tier academic institutions such as MIT, Stanford and UIUC to earn his PhD and become a leader among the burgeoning legions of Lisp-dom during the early nineties.
Gabriel lives in Redwood City, CA, and works for International Business Machines Corporation as an itinerant enforcer. He likes to unwind by writing a poem every night.
Overtone: Clojurepunk for the Masses
Overtone places a whirlwind of sound synthesis and music making opportunities within realistic reach of all Clojure programmers. However, the staggering set of possibilities can often overwhelm the intrepid music programmer seeking their first musical experience.
This talk will introduce an overview of a number of key synthesis and live programming concepts and techniques arming you with an arsenal of important tools to start your adventures with.
Be warned: this presentation will release the Clojurepunk within you.
About the speakers: Sam Aaron is a researcher, software architect and live programmer with a deep fascination surrounding the notion of programming as a form of communication. His previous work focussed upon the design and implementation of DSLs in order to allow concepts to be communicated and transposed more effectively and efficiently. Currently, Sam leads Improcess, a collaborative research project exploring the combination of powerful sound synthesis techniques with tactile and linguistic user interfaces to build new forms of musical device with a high capacity for improvisation.
Unjam: Release your inner Clojurepunk
This unjam will gather current and prospective Overtone hackers together to create an exciting opportunity for collaborative performance.
We will start with simple instructions of how to create basic sounds on the Overtone REPL and then let people creatively modify and generate noises spontaneously to create a cacophony of noise. We will then look into ways to structure and coordinate this sound so that we feel more like an orchestra or band than bunch of monkeys randomly hacking away. We will take two approaches - first we'll try and come up with a collaborative composition which will be conducted by one of the attendees. Finally we will look at how using one Overtone instance as a coordination server can allow rhythms and beats to be tightly synchronised.
The session will be fun, noisy and will strongly encourage exploratory and on-the-fly Clojure hacking.
Namespaces, Symbols, and Vars, Oh My!
Even people who have been programming in Clojure for a while now can get confused by some of the constructs at the core of the language: namespaces, vars, and symbols. In this talk, we'll dive into how these things relate, and how they are processed by the read and eval phases of compilation. Understanding them better will allow you to more easily understand why Clojure code does the things it does.
About the speaker: Craig is a recovering C# programmer who focuses on implementing large-scale, web-based systems (preferably in Clojure) and on answering the often difficult questions his two little girls ask him.
Craig is the author of a series of free webcasts about Clojure concurrency, available at http://link.pluralsight.com/clojure. He has written several articles for technical magazines and spoken at conferences around the world, most recently at the second Clojure Conj. He is the author of numerous open source projects, most notably hobocopy, which has been downloaded over 100,000 times.
Pallet, DevOps for the JVM
Pallet is a DevOps platform for the JVM, written in Clojure. Systems administrators today already automate the building of their infrastructure in the cloud. This talk is about a better way to do so, one that is functional.
In this talk, we'll describe how Pallet provides a set of abstractions over infrastructure components and operation tasks; how you can build automation on top of these abstractions, making the process of automating the infrastructure a matter of functional programming. We will describe the main abstractions in Pallet, covering the key concepts of: operating systems, shell scripts, cloud providers, software packages, clusters of servers, relationships between servers, and a few more. We will then show how any automation programmed against these abstractions is highly reusable and portable to different cloud providers and operating systems, and how the automated infrastructures are highly flexible and easily scalable. To conclude, we'll show how you can build higher level abstractions that match your domain, in this case by building automation for a Hadoop Cluster.
About the speaker: Antoni Batchelli started programming computers for fun when he was eight years old with a ZX Spectrum and has not stopped since then. Over the years, Toni has worked in consulting, startups, academia and corporations. He has gone back and forth between coding, architecting and managing, having fun in each role, while always working on large software installations. In 2009, Toni started Disclojure (http://disclojure.org), a website devoted to news about Clojure. in 2009, Toni met Hugo Duncan, with whom he has since them been working full time on Pallet (http://palletops.com) , an Open Source, Clojure-based DevOps platform; and VMFest, a Virtual Machine automation library. Toni is now focusing on promoting the use of Pallet.
The generative generation
Testing in Clojure has become an interesting and controversial topic. As with most programming languages, quite a few options have sprung up around testing over the years. Most recently, a library called test.generative has quietly made its way into the Clojure world.
Inspired from ideas out of Haskell's quick check and other similar libraries, test.generative is a very different approach to testing that involves describing the inputs and outputs of your system via functions and letting the test framework generate possible scenarios. When done properly, this method of testing can produce far more test cases than any sane human would want to write and maintain. Like other benefits and ideas around testing, test.generative forces its users to think differently about how their software is constructed and helps drive better code out the other side.
Join Aaron Bedra as he walks through writing some Clojure code and testing it with test.generative. Aaron will start with a simple idea and talk about all the different reasons and ways one might test a solution to the problem. He will explore ways of testing that don't involve any test frameworks at all. Then, just as you think he's about to completely miss the point of the talk, he will pull it all together and show the secret sauce behind test.generative and why you should adopt it into your projects going forward.
About the speaker: Aaron Bedra is a senior software engineer at Groupon. He is a frequent contributor to the Clojure language and its supporting libraries as well as an active member of the Clojure community. Aaron has led the development of several commercial Clojure projects and is the co-author of Programming Clojure, 2nd Edition
Real world Cascalog : Past, Present , Future
Federico Brubacher (@fbru02)
By now most of the community has heard about Cascalog, a querying library for Apache Hadop that leverages the full power of Clojure, instead of providing a cumbersome External DSL, like Hive and Pig do.
In this talk I want to focus first on where Cascalog comes from, so I'm going to throw in just a little of Cascading to explain some crucial concepts from which Cascalog builds on. After that I want to move on to what's awesome about Cascalog now and my real world experiences using Cascalog for doing actual production work. In this part I will explain some of the most powerful abstractions, examples of this abstractions are prepared and parametric operations and predicate macros. Finally I want to mention what are the plans for Cascalog in the future, which issues are coming in the pipeline and why you (the audience should be a part of the project).
About the speaker: Federico is a software developer from Uruguay, he has been enthusiastic about programming and Clojure for about two years, his working experience with Clojure includes but is not limited to putting a Hadoop cluster in production and run all sort of queries and batch jobs using Cacsalog. , Also he contributes with Cascalog in his spare time.
Adopting Continuous Testing in Clojure
"We seek, not to build guard rails, but to paint lines on the road. This way we can go faster, others can use the road too and we have waypoints to help us when things get 'foggy'. You still have to know how to drive." ~ Ben Rady, author of "Continuous Testing with Ruby." This presentation will discuss how teams can adopt (and adapt) Continuous Testing (CT) practices for clojure. After defining what the practice is (and is not), the presentation continues in three parts:
- An overview of the goals of the practice including
- Seek to write "executable documentation"
- Develop an environment of constant feedback about what is changing
- Favor speed over completeness (the goal is *not* about proving correctness)
- Compliment the REPL, don't replace it
- Illustrate how a CT workflow in clojure differs from adopting similar practices in other languages
- What is often a two stage iteration (test/code/test/code/etc) becomes three (repl/test/code/repl/test/code/etc)
- That test-first versus REPL first is a false-dichotomy and ultimately dogmatic irrelevance
- That the immutable nature of clojure and the power of using a REPL serves to emphasize the "exececutable documentation" value of CT
- Practical considerations and demonstration including:
- Tools (We've tried midje, lazytest and Expectations and settled on Expectations and why)
- Setup (including repl, leiningen, etc)
- Driving out a solution to an illustrative task using CT
Real World Clojure - Doing Boring Stuff With An Exciting Language
Clojure is often praised for its ability to tackle complex data problems and the glory goes to pattern matching, logic programming and massive scale (Storm, Cascalog etc) but what about real world problems? Is Clojure really only useful for hard problems?
In this session we'll take a look at using Clojure as a general purpose scripting language. World Singles has a multi-lingual, multi-tenant web platform for Internet Dating and we've adopted Clojure as our primary back end language. We'll look at solving real world problems - persistence, email, internationalization, configuration and environment control - ordinary problems, in ordinary applications, to see how Clojure can help you in your day-to-day life.
About the speaker: Sean Corfield used to build compilers, virtual machines, databases and telecom systems but eventually got a real job building web applications. After eight years of ANSI C++ Standardization and a decade of web development with JVM-based languages, he finally found his first love again - functional programming - and now he writes Clojure almost every day.
This talk will introduce Immutant, an application server for Clojure. Immutant is built on the extensible JBoss AS7 platform, exposing its rich set of built-in services to applications via simple API's. These services include asynchronous messaging, background processing, job scheduling, long-running daemons, simple deployment, clustering, and much more.
By providing these integrated services, the accidental complexity inherent with the evolution of an application relying on multiple disparate processes, e.g. Cron, Memcached, RabbitMQ, etc. is significantly reduced.
Immutant was inspired by TorqueBox, a Ruby application server also built on JBoss AS7. Immutant may be combined with TorqueBox to provide a single process capable of deploying both Ruby and Clojure applications, not to mention legacy JavaEE, leveraging the skills of the development teams in an organization without complicating the responsibilities of its operations team. This results in interoperable applications deployed on a single platform, built from best-of-breed libraries and frameworks irrespective of language.
About the speaker: Jim Crossley, a core member of the TorqueBox and Immutant teams, is a Principal Software Engineer at Red Hat with almost 20 years of experience developing software.
Clojure-powered Startups: a three-part story
If Clojure adoption is on the rise, where are the commercial success stories and how was Clojure used in these successes?
This talk examines three personal startup successes where Clojure was utilized to varying degrees. Each piece of the story will discuss the technology need, risk, and tradeoffs encountered as Clojure was consider, as well as what the language provided that led to success. Finally, an outline is extracted on how to apply Clojure as a problem solving tool where agility and continual learning naturally emerge as convenient by-products.
About the speaker: Paul 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. Previously Paul worked at PushButton Labs, Etsy.com, OurShelf, and SilverCloud Software as well as working in advanced research (DARPA).
Programming with Values in Clojure
The attachment of names to values, or “setting variables,” is a capability most useful programming languages provide. It’s almost always the case that a value affiliated with a name in one part of a program must be accessible some way in another part of the program.
What is often unclear in many programs built with these languages are the implications of mutation, or the process of pointing a name to a different value while the program is running. Because the notions of “accessing” and “changing” are often conflated at the lowest possible level of expression, it can be incredibly difficult to understand the relationships between the pieces of a program and the named value that these pieces share.
Awareness of this difficulty has manifested itself in bits of wisdom like “globals variables are bad” and “make it final,” and in principles like encapsulation.
Clojure attacks the problem directly, and by doing two things: providing a small set of unified semantics around mutation, and by making it easy to program without necessarily attaching names to values.
Clojure’s approaches empower those with an investment in the Java platform to tackle concurrent computing problems with new confidence, and are both ultimately possible through Clojure’s recognition that values themselves don’t change – only their names do.
About the speaker: Alan has contributed to Clojure, ClojureScript, and several Clojure projects including Leiningen and Incanter. As a consultant with Clojure/core, he has also worked on a variety of commercial Clojure projects.
He lives in Durham, North Carolina, where he helps run Splat Space, the local hackerspace. His favorite computer is the Arduino microcontroller, for which he implemented a Lisp.
Knockbox, an Eventual Consistency Toolkit
Eventual consistency is everywhere. DNS is the canonical example, but it's becoming more important in mobile applications with sporadic connectivity and databases with high availability requirements. One of the difficulties with these systems is resolving conflicting writes. Some cases allow for last-write-wins, but other domains require a mechanism which doesn't lose data. knockbox is an open source Clojure project that takes data-structure implementations that support automatic conflict resolution, and wraps them up to be used just like any other Clojure seq, set, or map. This talk will explore the motivation behind knockbox, the data-structures themselves, using knockbox with Riak, and issues like garbage collection and synchronization.
About the speaker: Reid is an engineer at Basho, where he works on Riak and other open source projects. He's interested in distributed systems, programming languages, and coffee.
DSLs in Clojure
Revolutions in software development are enabled by new abstractions being used to produce more software while writing less code. Domain Specific Languages are an abstraction that can help fuel the next revolution. This talk will introduce you to the concepts of DSL's, how to think about them, design them and use them to hide complexity at various levels in your software design using some common Clojure DSL's as examples. It will also touch on concepts like macros, monads and arrows to show how these can be used and why you would want to.
About the speaker: Jim has been a professional software developer for 20+ years in a range of industries from process control to video capture. He has been using Clojure for over 3 years and getting paid to do it for more than 2.
What sucks about Clojure…and why you'll love it anyway
Many a programmer fantasy and breathless blog post is rooted in the search for the perfect programming language, that sublime medium that will accentuate our talents, mitigate our failings, guide us to succinctly define our processes yet get out of our way when we wish — all while letting us deploy our creations in the environments we care about.
Of course, no language is perfect, including Clojure. As immensely attractive as its various qualities are, it has its own warts and baggage that you should be aware of as you consider it for tomorrow's projects or push it into production today. This talk will present many of these shortcomings — from the technical to the social to the existential — along with mitigating factors that might make the difference between Clojure frustrating you, and your loving it.
About the speaker: Chas Emerick is a coauthor of Clojure Programming from O'Reilly, and a contributor to Clojure itself and dozens of open source Clojure projects. He's been deploying Clojure in production since 2009 — primarily to solve various improbable document extraction problems — having adopted it as his primary language the year before. He writes about software development, entrepreneurship, and other passions at cemerick.com.
About the speaker: Programmer with experience in machine vision, expert systems, and distributed simulation. Co-author of "The Joy of Clojure" and author of "The Art of Chupacabra Husbandry".
The Taming of the Deftype
You know about Clojure's deftype & defrecord. You have seen them in action. Now you need to create a new type that plays well with Clojure's own collections. Should you use a record, or do you need a type? Which protocols do you need to implement? Or were those interfaces? Decisions, decisions.
In this talk your friendly guide BG will walk you through the process of creating custom types that interoperate with core Clojure collections. You will learn when to use types vs records, about various internal Clojure interfaces & their associated behaviour.
This talk will equip you with real world knowledge about the internals of Clojure collections and building your own datatypes.
In particular, the talk will cover -
- When to use records or types (or neither)
- Internal Clojure interfaces (and corresponding ClojureScript protocols)
- How to find which interfaces to implement
- Mutable types(!)
- How your type behaves with eval and the reader
- Example implementations
About the speaker: Baishampayan "BG" Ghose has been a Lisper for almost all of his professional life. He started his career hacking Common Lisp for a travel startup and has deep admiration for functional programming. He discovered Clojure in 2008 and has not looked back ever since.
Currently he is co-founder at a stealth startup that is building elegant tools for Enterprises to solve complex problems.
The Seattle Clojure group (http://seajure.github.com) has developed a unique style of collaborative interactive development I've termed "swarm coding". It involves a medium-to-small group with laptops all connected to a single host trading off on writing a small, focused piece of software.
This 80-minute unsession will begin with an explanation of swarm coding. We will discuss how to facilitate it at your own user groups, how to pick a project, and common pitfalls. Following this, we will break up into a number of smaller groups and each implement a small project.
About the speaker: Phil Hagelberg has been writing Clojure for three years. He created Leiningen and maintains the Emacs support for Clojure as well as starting and running the Seattle Clojure group. He works for Heroku improving the Clojure support for their platform.
Distributed Apps: The Joys of Testing and Debugging
One tough problem in debugging distributed applications is understanding what happened on a client that later caused an exception on a server. I'll discuss the nature of Clojure stack traces and demonstrate a library that can extend a stack trace from where it was thrown, back across multiple thread or server boundaries to the client that initiated it. Even with more helpful stack traces, however, testing for the handling of race conditions is still very challenging. I'll demonstrate a technique that we've used at LonoCloud in our test suite to consistently reproduce and guard against race conditions.
About the speaker: Chris (a.k.a. Chouser) is a co-author of The Joy of Clojure and a primary contributor to Clojure and ClojureScript. He is a Principal Software Engineer at LonoCloud, where he's using Clojure to build an operating system for cloud applications. Sometimes he alters vars, even though he knows better.
Bootstrapping Clojure at Groupon
This story starts out literally like a movie - millions of dollars on the line and the clock is ticking. We had a large dataset we needed to run expensive calculations on and our existing tools couldn't cut it. Clojure came to our rescue with its wonderful combination of simplicity and performance. But that's just the beginning. I'll also tell the tale of how our little Clojure script grew up. I'll talk about how we constructed our test suite, our experience refactoring Clojure, and the delicate art of introducing new developers to their first Lisp.
About the speaker: I burn my daylight hours helping Groupon change the world of local commerce. Perviously I was a principal consultant at Obtiva, a well known Agile development shop. I reside in Chicago with my wife and two children.
I'm also involved in numerous developer communities and have presented at many conference and user group meetings across the United States. My recent interests include functional & multi-paradigm languages and genetic algorithms.
Code quality matters: programmer happiness and efficiency depend on it, especially as codebases grow and change. The notion of simplicity is a powerful one that offers some guidance, but how, specifically, can we make our code simple?
For object-oriented languages, the SOLID principles are a group of helpful guidelines for improving code, and I claim that these principles also apply to writing simple Clojure. There are certainly others that are at least equally applicable (e.g. Don't Repeat Yourself), and yet others that are more specific to Clojure (e.g. isolating mutation), but given these principles' image as OO-specific rules, I will concentrate on their perhaps-surprising application to Clojure.
I offer some comparisons and contrasts with these ideas' applications in object-oriented programming languages, and hope that by the end of the session, it will seem obvious that these are rules for writing *software*, and not just OO. There will be plenty of code examples to make things concrete.
Just as we learn from the computing past in terms of the JVM platform, database transactions, Lisp's macro system, and the mountain of other great ideas that Clojure the language is built on, we can also learn about building systems that are easy to change from the experience of object-oriented programmers.
About the speaker: Colin is a Software Craftsman at 8th Light, where he builds quality software for clients like Groupon. His open source work includes the Clojure Koans, ClojureSlim, and REPL-y, a work-in-progress attempt to improve the Clojure REPL experience, as well as small contributions to Leiningen, Speclj, and Clojure itself.
Clojure Koans Hackfest
The Clojure Koans are a great way to dive into the language for the first time: no experience necessary! This unsession aims to get budding Clojurians ramped up quickly, but also to provide an opportunity for more experienced Clojure developers to expand and improve the koans.
After a brief introduction to Clojure syntax, you'll get started working through these problems on your path to Clojure enlightenment. Bring your laptop, with Java 1.5+ and your favorite editor, and we'll get you on your way.
If you've been through these before, or know enough Clojure to finish the koans quickly, great! You'll have the option of pitching in to create koans of your own, and submitting them back to the project as pull requests. There are plenty of ideas to choose from, or bring your own.
Building Libraries for ClojureScript - Learning to Love Google Closure
The purpose of this talk is to get people excited about building new libraries for ClojureScript. It will cover some of the challenges that exist when designing libraries in ClojureScript and provide an overview of the Google Closure libraries. We will also take a tour of some current ClojureScript libraries and show how Clojure's abstractions can simplify and smooth the rough edges of client side development.
About the speaker: Creighton Kirkendall has been working in Java web technologies since 1997 and has been accused of being a Perl hack on more than one occasion. For a brief period of time, he drifted to the dark side and played an executive. He even managed to get an MBA to prove it. In the end, it turned out that a techie nerd doesn't make a happy executive. About a year and half ago, Creighton fell in love with Clojure and has since teamed up with Carin Meier to start the Cincinnati Functional Programmers Group (cincfp).
Load testing with Clojure
Andy Kriger - Jun Group
Experiences from the field building automated integration and load testing using The Grinder, Clojure, Pallet, and a continuous integration system. The Grinder is a Java load testing tool that supports scripted tests written in Clojure or Python. Starting with a simple web application, we will explore the possibilities and tricks of using the Grinder to run integration and load tests; spawning an on-demand test-bed with Pallet; running tests and generating reporting with continuous integration.
About the speaker: http://www.linkedin.com/pub/andy-kriger/7/768/3b4
Avout and Distributed State in Clojure
Avout brings Clojure's in-memory model of state to distributed application development by providing a distributed implementation of Clojure's Multiversion Concurrency Control (MVCC) STM along with distributable, durable, and extendable versions of Clojure's Atom and Ref concurrency primitives.
This talk will provide:
- background on Clojure's in-memory model of state
- a walkthrough of Clojure's STM
- a walkthrough of Avout's design
- guidelines for using, and avoiding, distributed state in application development
- instructions on how to extend Avout with different backend state stores
- alternative approaches to distributing Clojure's model of state.
About the speaker: David Edgar Liebke is a statistician, a programmer at Relevance, a founding member of Clojure/Core, the creator of Incanter, Avout, and several other Anathem-themed open source Clojure projects.
Composing statistical graphics on the web
Statistical graphics illuminate by mapping abstract data to visual primitives like dots, lines, and color. Excellent statistical graphics first and foremost *show the data*. Likewise, the tools for making such graphics should emphasize essential data-visual mappings and hide the implementation details of looping, painting, and layout.
Clojure's emphasis on immutability allows one to compose functions while retaining the ability to reason about their behavior. These same strengths can be leveraged to build rich, data-driven graphics composed of smaller visual pieces. Kevin will discuss using ClojureScript with the Cassowary constraint solver to construct and layout statistical graphics on the web.
Clojure in the Clouds
Can you use Clojure to build web apps? Hell yes! Not only do we have Ring and Compojure, we also have recently a development framework called Joodo that'll give Ruby on Rails some competition. In this session we'll demonstrate how Joodo makes it almost effortless to generate and deploy web apps to Google AppEngine and Heroku, for free.
About the speaker: Micah Martin is founder and Software Craftsman at 8th Light, Inc. He's been writing code for over a decade and has authored several open source projects including FitNesse, Limelight, and Speclj. He co-authored Agile Principles, Patterns, and Practices in C# and has contributed to several other books. Micah has also been in driving force in the Software Craftsmanship movement where he helped host the 2008 summit, publish the Manifesto for Software Craftsmanship, and organize SCNA 2009 to 2011. Oh, and he loves to code in Clojure.
Scalable realtime computation with Storm's Clojure DSL
Storm makes it easy to write and scale complex realtime computations on a cluster of computers, doing for realtime processing what Hadoop did for batch processing. Storm guarantees that every message will be processed. And it’s fast — you can process millions of messages per second with a small cluster. Storm was open-sourced by Twitter in September of 2011 and has since been adopted by many companies around the world.
Storm is implemented in Clojure and ships with an excellent Clojure DSL. In this talk I'll start by discussing the basics of Storm: streams, spouts, bolts, and topologies. Then I'll show how to use Storm's Clojure DSL for a wide variety of applications, such as stream processing, distributed RPC, and continuous computations.
About the speaker: Nathan Marz is the lead engineer on Twitter's Publisher Analytics team. Previously Nathan was the lead engineer of BackType which was acquired by Twitter in July of 2011. He is a major believer in the power of open source and has authored some significant Clojure-based open source projects, including Cascalog, ElephantDB, and Storm.
Macros are Hard!
Macros are like stress tests on our understanding of Clojure. Problems arise when writing macros that reveal holes in our mental model of how Clojure works.
Going back to basics and gaining a solid understanding of the reader, evaluation rules, quoting, and compilation goes a long way towards demystifying Clojure macros.
Through many examples, much code, and several puzzles this talk iteratively introduces a model for thinking about how Clojure evaluation works and provides specific tips on writing macros.
Come prepared to read code and think!
Why is a Monad Like a Writing Desk?
Inspired by Alice in Wonderland, we will take a whimsical look at monads and how to understand them by implementing them in Clojure.
We'll follow the adventures of a developer who fell asleep while reading one of Philip Wadler's papers on monads (and eating too much cheese). Along the way, we'll discover why monads are important for a functional language and might accidentally achieve enlightenment by implementing the three different types: the Identity Monad, the Maybe Monad, and the State Monad.
About the speaker: Carin is a software developer at EdgeCase. She started off as a professional ballet dancer, studied Physics in college, and has been developing software for both the enterprise and entrepreneur for the past 15 years. She comes from a solid Java background, but has discovered a passion for the simplicity, power, and elegance of Clojure. She brings fun, enthusiasm, and hot tea to all her software projects and especially enjoys participating in the Open Source community.
She lives in Cincinnati, OH with her husband and two young children. When left to daydream, she thinks of the dynamics of flocks of birds, what the Giant Squids might really be doing down there in the deep, and maybe opening a first-rate cheese shop one day.
Accessing Real-World APIs from Clojure
From status updates on Twitter to business data in salesforce.com, APIs enable applications to access services across the web. Most modern APIs are RESTful, and many of those use the OAuth protocol to authenticate end users for secure API access. This session provides a high-level explanation of OAuth, contrasts it with OpenID, and shows how a Clojure web app, running on Ring and Compojure, can implement OAuth and securely access web APIs.
About the speaker: Pat Patterson is a principal developer evangelist for platform technology at salesforce.com. Pat has been developing Internet software since 1997, joining Sun Microsystems in 2000 and working in a variety of roles in secure Web services, digital identity and open source. Pat moved to Huawei in 2009 to work on cloud storage infrastructure before landing at Salesforce.com in late 2010.
Describing himself as an 'articulate techie', Pat speaks regularly at a variety of events, from developer workshops to conferences such as Dreamforce and JavaOne, hacks all manner of code from Clojure web apps down to Linux kernel drivers, and writes it all up on the Force.com blog, his personal blog, Superpatterns, and, of course, Twitter.
clojure@runa :: dynamic pricing through DSLs
Runa has been in existence since the beginning of 2008, and has had a Clojure system in production since the fall of the same year. This talk is about how a small team of Lisp engineers is disrupting the e-commerce world.
We’ll cover how Runa leverages Clojure DSLs to run the business: i.e. provide real-time dynamic pricing for online retailers to increase conversion.
We’ll also provide a look behind the magic curtain of how Runa’s DSLs facilitate communication between the analytics team, the business team, and the engineering team. Finally, we’ll give up the secret of our profit margin.
This is a relatively high-level talk, and will broadly address the following:
- Clojure DSLs as requirements specifications
- Training non-technical people in Clojure DSLs
- How the Clojure back-end integrates with our internal Ruby/Rails applications
- The Runa Dynamic Pricing/Promotions DSL
- Dropping s-expressions into live systems
We’ll also briefly cover what our analytics process looks like, and what sort of algorithms we use to drive the smarts of our system.
About the speaker: VP of Engineering at Runa, Inc.
Author of "Clojure in Action"
Chief Software Architect, Runa : 2008 to 2010
Lead Consultant, ThoughtWorks : 2002 to 2008
Software Engineer, IBM : 2001 to 2002
Building User Interfaces with Seesaw
Swing has never had a sterling reputation. It is (correctly) perceived as complicated, over-designed and generally difficult to work with. Seesaw is a user interface toolkit built in Clojure that makes UI development fun again. It unifies many abstractions that are scattered or non-existant in the Swing API, for example: event handling, selection, semantic "value", binding, and more. In this talk, we will learn how to combine these capabilities to rapidly construct desktop applications in Clojure. Put away proxy, reify, doto and friends. You won't need them here.
About the speaker: Dave Ray is a software engineer from Ann Arbor, MI. For over 13 years he has worked on a variety of problems including modeling and simulation, cognitive architectures, compilers, image processing, and otherwise gluing together random software systems. He is the author of Seesaw, a friendly user interface toolkit for Clojure.
Clojure, JRuby on Rails, and you
At circleci.com, we're running clojure and jruby on rails in the same process. We wrote ____, (soon to be released) a library for calling jruby from clojure, and vice versa. We'll cover
- Calling JRuby from Clojure
- Calling Clojure from JRuby
- Using the Clojure REPL to speed up Rails development
- Starting multiple ruby runtimes inside the same JVM to speed up testing
Time permitting, we can also talk about testing and continuous deployment at CircleCI, a Continuous Integration SaaS written in Clojure.
Founder of two startups using Clojure in production, reasonr.com (defunct) and circleci.com (active!)
core.logic brings Logic Programming to Clojure and can greatly simplify some kinds of problems. This session will cover a graph querying problem I encountered at Revelytix and how I solved it with and without core.logic. Using graph querying as a goal, I will give an intro to core.logic using live coding. We'll build up abstractions from the basic core.logic constructs and ultimately be able to run sophisticated queries over Clojure data. The focus of the intro will be practical, focusing on concepts and constructs that you need to be productive with core.logic.
About the speaker: Ryan Senior is a Senior Engineer at Revelytix Inc writing Semantic Web software in Clojure. He has worked in many other industries including healthcare, insurance, finance and manufacturing. His main interests are logic programming, programming languages and the semantic web.
Thinking in Data
In Clojure, data is king. But what does that mean? This talk will introduce "data-oriented programming" as a discipline and show how it can make programs easier to write, easier to test, and more performant. If you can represent your problem as a pure function manipulating data structures, you win. This talk uses examples in Clojure but the concepts are applicable to any programming language.
About the speaker: Stuart Sierra is a member of the Clojure/core team at Relevance, Inc., and the co-author (with Luke VanderHart) of Practical Clojure (Apress. 2010).
Crunching numbers with Clojure
In the beginning, trying to do number crunching using Clojure was a pain: to get any sort of performance, you had to resort to low-level, non-idiomatic constructs. Clojure 1.3 introduced enhanced primitive support that promises to make heavily numeric work in Clojure practical. This session will show you how to use these new features, help you become aware of potential pitfalls, and review some of the other tools within Clojure to help you create high-performance number-crunching applications.
About the speaker: Daniel is a long-time Java and C++ programmer who started developing in Clojure over two years ago. He is a Clojure contributor and the creator of the Clojure REPL for Android. Over the past year he has focused on developing for Android using alternate languages such as Clojure and Scala. He is currently writing a book on the subject for O'Reilly Media titled "Decaffeinated Android". When he has time, he writes about programming on his blog, Deep Blue Lambda.
Laziness: the Good, the Bad, and the Ugly
One of the more interesting features of Clojure is its lazy seqs. You see uses of lazy seqs throughout the core API. Lazy seqs can be used to process data efficiently, but there are some gotchas. Learn how they work, how they work well, and what mistakes to avoid.
About the speaker: Programming language geek. Professional Clojure developer at Sonian. Working with big data in the cloud.
Distilling Java Libraries
The JVM gives us access to a wide array of powerful Java libraries. These libraries, however, are often layered with unnecessary abstractions and incidental complexity. Clojure can be a powerful tool for carving away this complexity, giving us access to the core functionality without all the ceremony.
This talk will explore the impedance mismatches between Java and idiomatic Clojure, and how these can be resolved through both careful design and some common implementation patterns.
About the speaker: Zach is eight feet tall and wears a serape woven out of two hundred transistor radios, all turned on and tuned to different stations. Just by looking at him you can hear Portland and Nogales, Mexico.
Beyond Ninjas: DOM manipulation with ClojureScript and Domina
ClojureScript is awesome. Unfortunately, applying that awesome to make pretty things happen on your website takes a little more work than just throwing up a script tag pointing to jquery.js. In this talk, I’ll introduce Domina (a new DOM manipulation library), and show how in combination with a few other useful libraries, you can write dynamic web code that will elevate you to new levels of mastery over the content of your apps and pages. You’ll never want to go back.
About the speaker: Luke VanderHart is a professional software developer and consultant, and co-author of Practical Clojure (Apress, 2010). He has extensive experience in large government and industry teams as well as small, agile and open-source projects. He is the author of Domina (a DOM manipulation library for ClojureScript), as well as being a contributor to Clojure and ClojureScript. He lives in Annapolis, MD, and is currently employed with Relevance Inc.
Building tools to help kids fight ADHD
About 3 kids per classroom are affected with ADHD or other forms of executive dysfunction and despite many talents, can struggle to learn how to succeed. They often face heightened conflict levels with frustrated teachers and parents. Ultimately 32% drop out.
Clinical experts and PhDs at the University of Utah have come together with technologists and are gaining ground on ADHD through novel treatment approaches. They are brewing a concoction of solid science and emerging tech using mobile apps, game mechanics, and a private social mentoring network. Picture kids having fun in school again, earning rewards on iPods and reinforced by parents in-the-know with push updates.
We'll dig through the system design and key components, and see how Clojure, CouchDB, iOS, and other pieces work in a distributed but coordinated effort to impact lives. We'll get an inside perspective of developers and designers who have tackled this while balancing day jobs and other responsibilities, and see if a good cause and the love of learning and applying great tech is enough to win.
About the speaker: In uniform, Alan is a former Fortune 500 CTO turned founder and architect at companies including Lead Media Partners and LeadTune where he works on predictive analytics with Clojure.
After dark, he dons the apparel of family guy, avid student, distance running nut, aspiring cinematographer, and light traveler.