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.
Edmund Jackson presented 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. He presented a series of increasingly complex and interesting examples as he progressed, ending in a complex example.
Cascalog is a data processing library for Clojure that 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!
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..
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 discussed 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, Stuart presented 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. He shared insights from his own experience applying these practices on a multi-year product effort undertaken in Clojure.
This talk discusses 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.
First: 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. Expect the talk changed therefore: surprise! :-)
Second (starts at minute 14:00): 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.
Third (starts at minute 24:00): 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.
Fourth (starts at minute 36:30): 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.
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.