Slides can be found here: http://fergalbyrne.github.io/fergbyrne-euroclojure2014.pdf
(Audio gets better after the first minute and 20 seconds).
The goal of the talk is to introduce Jeff Hawkins' theories as a basis for intelligent computing; to describe how Clortex can be used for both research and development of new applications of Machine Intelligence, and finally to describe some of the key design decisions made in developing a large cortical information processor in Clojure. The attendee will learn about a new vision for understanding how the brain works; a system for developing genuinely intelligent software and hardware based on neuroscience, and how to use the Clojure ecosystem to address large-scale design and development issues.
The presentation will begin with a 3-minute demo of Clortex in action. The demo consists of:
A visual example of Clortex processing and intelligently responding to a real-world problem.
A simultaneous set of visualisations showing the inner workings of the neural regions inside Clortex.
Live manipulation of the algorithms used, and a demonstration of how this affects learning and performance in Clortex.
The first section is a crash course in understanding the neocortex: the seat of intelligence in the brain.
The next section will briefly introduce Jeff Hawkins' theories of Hierarchical Temporal Memory and the Cortical Learning Algorithm, with the key principles of how the neocortex identifies spatial patterns in data and learns sequences of those patterns.
Following this is a brief history of efforts to implement systems based on HTM/CLA, including Numenta's NuPIC, Dileep George's Vicarious, CEPT's Cortical Engine for Text Processing, and a number of hardware projects currently in development at Sandia Labs etc.
Slides can be found here: http://stuartsierra.com/download/2014-06-27-components-euroclojure.pdf
Functional programming with immutable values is wonderful, but sooner or later every program has to deal with stateful, imperative tasks. A large program may need to manage dozens of stateful services: database connections, thread pools, network services, scheduled tasks, and caches. How do we do this in a functional programming model? All too often we fall back, almost by accident, into global mutable state, promiscuous sharing, and imperative spaghetti code.
To escape this quagmire, we need to recall some basic principles of both functional and object-oriented programming: referential transparency, immutable values, message-passing, encapsulation, and interface contracts. The Component pattern and its library implementation offer a minimal way to structure the stateful dependencies of a functional program.
This talk will cover the motivation for the Component pattern, its benefits and downsides, comparisons with other approaches, and how to use it in Clojure programs.
Slides can be found here: https://dl.dropboxusercontent.com/u/48303527/malcolmsparks-euroclojure-presentation.pdf
By its emphasis on integration via data rather than code, Clojure reduces the integration effort required by library users, thereby enabling the production of a vast number of small independent libraries. Freed from the responsibility of designing a good API integration API, library authors can focus on doing 'one thing well'.
However, there are currently few well-established idioms for assembling applications from this wealth of functionality. As Clojure adoption matures, Clojure systems are becoming larger, more complex and dependent on a greater number of libraries. So the question of how to assemble applications becomes more pertinent.
This talk will begin by introducing Stuart Sierra's component library, demonstrating some examples of its use. It will then show how integration points between components can be created using Clojure's protocols.
The talk will go on to explain the concept of modularity and describe a series of patterns, built upon these protocol-based integration points, for dynamically assembling systems, and configuring them for multiple environments.
It will then demonstrate these patterns using the familiar example of protecting a web-page from unauthorised access. This is an important example because the approach demonstrated addresses the problem of web security raised by Aaron Bedra and this year's ClojureWest conference. The solution will be composed in such a way as to preserve modularity, making it straight-forward to re-configure for different environments or to disable altogether. But more importantly, by creating from a set of re-usable components, such components can be improved in collaboration with other community developers, and thus reach a higher level of quality in comparison with bespoke code.
The talk will conclude by presenting the opportunity to rapidly assemble reliable systems out of re-usable parts, but crucially improving flexibility, choice and quality.
Slides can be found here: https://dl.dropboxusercontent.com/u/2875427/Gergely-Nagy-EuroClojure-presentation.pdf
While on one hand, we have the features of the language itself and the many libraries and applications that were developed over the years, on the other hand, we have a topic we rarely talk about: how Clojure helps in areas where it isn't even there. Is it important to care about the world outside of Clojure? If so, why? And in what ways, how does Clojure and its community inspire others to do great things, even without the use of Clojure itself? In this talk, I would like to tell a little story of a language called Hy, which is a Lisp that compiles to Python AST - a different syntax for Python, with some syntactic sugar, if you wish. The tale would tell how Clojure - the language, the community, the tools and libraries around it - influenced Hy and some of the neat little things written in it.
This would be a cultural exploration, rather than a talk about deep technicalities or methods, although a few interesting - or twisted - bits of the deep internals could be explained, for educational purposes, and for comparing how Clojure accomplishes similar things. The presentation would also touch on the differences, and the "why"s behind them, to answer questions like "why isn't Hy a ClojureScript backend?", because the answers are mostly non-technical, and as such, a good fit into the presentations theme.
Slides can be found here: http://www.slideshare.net/annapawlicka/reactive-data-visualisations-with-om
Generate a resource that can be used in a route and use it to pull data for visualisations
Create core.async channels and use them communicate user clicks and selections between those components, e.g. selection on a checkbox component triggers reloading of data on a chart component.
The talk will be a practical guide to building small web applications and will be accessible to Clojurians with a basic knowledge of Clojure and HTML.