Overview of the course
Names and Namespaces
Concurrency, State and Time; Protocols, Types, Records
Advanced Topics: Macros, ClojureScript, JVM
Life on the JVM
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.
Your background is in OOP languages and you have become intrigued by Clojure. You know that things are different, and that continuing to design your programs in the same way you did in the past is likely going to cause problems. In this session, we will take a look at concepts that are likely to be familiar to you, such as encapsulation, type and class hierarchies, modularization, and domain modeling, and show what the analogies in idiomatic Clojure are. We will also take a look at some of the additional tools Clojure offers that go way beyond what you are used to — hopefully setting you off on your way to become a great Clojure programmer.
by Max Weber
Most of today’s software uses the current state to store its application state. This is often regrettable since you lose a lot of valuable information and therefore a competitive advantage on the business side. However, the event sourcing pattern uses a different approach and stores all events that have led to the current state. At first sight it might seem more complicated than the classical current state based CRUD architecture, but you will see that almost everything gets easier with event sourcing.
This talk introduces you to the new open source framework eve, which combines the (eve)nt sourcing approach with the simplicity and power of the Clojure programming language. Furthermore, you will learn about the CQRS architectural pattern, which can be combined with event sourcing and helps you to build scalable systems.
I will present an introduction to core.logic from the ground up – e.g. what is logic?, why do you care? – to the nuts and bolts – e.g. fresh, unify and conde – to striking new ground – e.g. new goals. I will present a series of increasingly complex and interesting examples as I progress, ending in a complex example.
by Zoltan Varju
Although there are excellent nlp libraries, like the SNLTK (Scheme Natural Language Toolkit) or NLTK (Natural Language Toolkit) for Python, in real world applications speed matters and you should use OpenNLP, GATE or StanfordCore NLP. Clojure’s Java interoperability means you can use power tools, in addition you have lists, the ‘secret weapon of nlp and Lisp’ at your hands.
Clojure is an ideal tool for natural language processing. Java interoperability means one can use tools like the OpenNLP, Incanter provides us R-like statistical capabilities, with the help of core.logic we can approach parsing from a very expressive angle. We present two distinct approaches to Natural Language Processing: using OpenNLP from Clojure and building a simple parser with core.logic.
Cascalog is a data processing library for Clojure. Cascalog mixes functional and logic programming. It makes data processing code very concise, easier to grasp and reason about.
Being just a Clojure library, all of Clojures’ features are just a keystroke away – no need to learn another custom language (like Pig or Hive). This also allows for powerful abstraction and composition capabilities.
Although Hadoop being its major use case, Cascalog can be used for local data crunching as well. The talk will mainly focus on how Cascalog leverages logic programming, but real-life experience with Hadoop clusters will be mixed in as well.
Live Demo – Parens abound!
by Håkan Råberg and Jon Pither
In December 2011, a small ragtag group of men from around all of Europe started to introduce Clojure in a remote corner of an investment bank.
This is their story. Reconstructed from torn index cards, corrupted IRC chat logs, broken builds – and hearts...
by Zach Tellman
When an event occurs, it comes from outside the normal linear flow of execution. Trying to fit these events into sequential code can be an exercise in frustration, making your code more complex and difficult to reason about.
But with the right primitives, this same property can be enormously powerful; events that describe the execution of your code can be combined and correlated, allowing disparate pieces of code to be understood as a coherent whole.
This talk will discuss approaches for both the instrumentation of Clojure code and the analysis of the resulting streams of data.
Search is not only an exciting topic, but also a great fit for Clojure. The problem domain is well suited to the functional programming methodology that is idiomatic in Clojure and thanks to the plethora of excellent Java libraries that are available you never have to reinvent the wheel. This will be a very practical session. Theory will be kept to a minimum so we can focus on actual code. Thankfully, we can let libraries like Apache Lucene do the hard work for us, so we won’t have to worry about the deeper mechanics.
After a quick overview of the topic we will dive into the code for the different components you need for a search engine: a data gathering mechanism, indexing and of course the actual search process. There will be a healthy amount of data wrangling as we parse the source material with Enlive, examine and possibly modify it and finally feed it into a Lucene index.
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.
by Rich Hickey
This talk will discuss the design of Datomic, and the connections to the ideas behind Clojure.
Homoiconicity is great, it’s an easy way to metaprogramming. However homoiconicty is a subtle lie — a curse even! — and this curse poisons the life of tools writers.
In this talk I cover how homoiconicity is a liability for tooling and what can be done to work around that.
The reader discards way more than spaces and comments making the read -> transform -> pprint pipeline unable to roundtrip most source code.
Thus bringing a basic tool (such as one which maintains the ns form or project.clj) state from prototype to reliable is hard. Hard because at some point you have to shift the underlying abstraction away from sexprs. This has the detestable effect of reducing the toolsmiths population while it could be as large as macro-writing population.
I’ll discuss how one can tackle this problem and specifically the solution which seems the more promising to me.
The sequence abstraction is a very powerful tool. However one has to clearly differentiate between sequences and data structures like lists or vectors. Adding laziness to the mix makes things even more complex. I will give an historic view on the roots of the sequence abstraction and how laziness was added. Finally I will discuss why I think that a lazy sequence actually isn’t a sequence at all.
Clojure’s focus on immutable data and sequences have been the inspiration for building new data tools for uSwitch.com: treating everything as data and building many tools that operate on the same data.
It has helped us build monitoring, debugging and analytical tools (many of which are written using Clojure) that help us understand how people are interacting with our websites and provides an open-source, open-schema environment for our data that encourages both consumption and production.
As a versatile, dynamic language Clojure lends itself well to digital artworks where brevity and flexibility allow visual ideas and designs to be quickly coded, tested and revised as part of the overall creative process. Clojure’s Java interoperability allows it to leverage existing visual coding environments.
We’ll look at Quil, in which Clojure hijacks the Java-based Processing environment used by digital artists the world over, and at Field, a Java- and Python-based live coding meta-environment used for installation art and performance visuals (most recently at Sadler’s Wells) and which can call out into Clojure, allowing for some curious hybrid Clojure/Python designs.
Both Processing and Field are essentially imperative, so we’ll examine how animation lends itself – or not – to working in a purely functional Clojure style, especially when hosted in a non-functional environment, and how functional programming in general, and Clojure in particular, influence the structure of time-based installations.
We’ll look at live coding on the Clojure side, touch on some fiddly details of Java and Python interoperability, and briefly present some aspects of visual programming – scene-graphs and shaders – showing how Clojure talks to them.
http.async.client by Hubert Iwaniuk: Simultaneously fetching a lot of data over HTTP, consuming HTTP stream, or just needing as painless interface as curl at you REPL – async.http.client is for you. It is lightweight, fast, asynchronous HTTP client.
Journeys with Maps by Robert Rees: moving from Object-Orientated languages with a strong emphasis on typing to a functional style with a duck-typing approach
Canon fodder by Chris Ford: Musical canons employ a base melody accompanied by one or more ‘imitations’ – transformations of the original melody. Clojure lends itself to describing canons because the transformations can be represented by pure functions. This talk will use the Overtone audio environment to explore the canonic form, from ‘Row, Row, Row Your Boat’ to Johann Sebastian Bach.
Riemann by Sam Newman: Riemann is a Clojure stream processing server based on the c10k server Netty. Capable of processing a large number of concurrent events, using its elegant stream processing functions it is possible to collect large amounts of data from disparate clients.
The way Clojure libraries use sequences, maps and vectors makes it very easy to combine data from multiple sources.
Incanter is a powerful library for statistical computing in Clojure. While this might seem only useful to people who need to do scientific computing it is very useful for the everyday programmer.
The purpose of this talk is to show you how you can use Clojure to tear through databases, json, xml and logfiles and then Incanter to analyse the resulting data structures to help you understand what is going on without needing a degree in mathematics.
This presentation will show how easy it is to create web services with REST in Clojure using compojure-rest. Once we’ve created these services we’ll consume them from a browser with ClojureScript.
With a growing number of adopters (Twitter, EMI, GoGrid, paper.li, and more) and 2 years of intense development, Pallet, an open source fresh look at DevOps, is ready for prime time. With Pallet you can automate your cloud infrastructure from end to end, from server infrastructure management, service setup and configuration, to operating clusters of servers in a coordinated manner. All aspects are covered in a single package.
This talk is an introduction to Pallet focusing on key aspects where it differs from the current mainstream DevOps tooling. It will cover some of the abstractions in Pallet that make it distinct from Puppet or Chef, and we will illustrate this with some real world use cases for these.
Robert Rees: On the 20th of July 2009 a small group of people inspired by a JVM Lisp going by the name of Clojure got together to try and sort and score poker hands. In 2010 those same people started to write an adventure game together called Clork and were so bad at Clojure coding they spent an entire year doing it.
The London Clojure Dojo has grown from a handful of people to regular meetings of thirty to forty tackling all manner of different problems: making music, graphics and nonsensical stories. Along the way it has spawned a user group and more formal talks and two monthly hack days.
This talk is a brief history of the group and how it formed the nucleus of all manner of Clojure networking and activity.
Devin Walters: I’ve been a member of the Clojure community for quite awhile now. I first got interested in late 2008. Our community is a special one, and we need to preserve it, care for it, build it. Why? How? What?
I’ll talk about my experience starting a Clojure meetup group in Madison, WI, the time it’s taken to get there, the hurdles I’ve experienced along the way, and some general advice for people who want a local Clojure community to meet, collaborate, and learn with.
by Sam Newman
What is it? Why would you care? Riemann is an awesome Clojure-based event stream processing server built on top of Netty. I'll talk about how to use it, and how Clojure is at the heart of the extreme awesomeness. Did I mention it was awesome?
This will be a *short* 10 min overview.
Discover how to set up and effectively manage Emacs, so you can focused all your time on learning Clojure itself and have a great tool to help you learn.
Emacs has much untapped power that developers new to this world are not aware of, but Emacs needs a little bit of configuration to be a (perfect? clojure environment). With great language support for Clojure & ClojureScript (and everything else) it can easily be the best environment for most developers when configured to give a familiar experience of Eclipse, Netbeans and IntelliJ.
21st–25th May 2012