Latest Episodes

48. List Comprehension with clojure.core/for
Published 15 July 19

A small macro with a lot of power! We start with a quick recap of Clojure’s looping constructs, and then go over the various features and use cases of for, backed by examples taken directly from popular open source projects.

47. Interceptors, part 1, concepts
Published 26 February 19

The Interceptor pattern was originally introduced by Pedestal, but has since been adopted by several other projects in the Clojure world. It’s an extremely useful design tools to be familiar with, and while they may seem a bit strange at first, Interceptors are suprisingly straightforward.

This episode introduces the interceptor concept, including the context map, queue, and stack. Clojure’s persistent queues are explored, and to round off we look at how interceptors deal with error handling.

46. À la Carte Polymorphism, part 2
Published 06 November 18

With the basics of multimethods out of the way it’s time to look at some of the more advanced uses. This episodes explores in depth Clojure’s keyword hierarchy features, some little known aspects of the isa? and type functions, and closes off with some examples that demonstrate the flexibility Clojure provides when modeling data and behavior.

45. À la Carte Polymorphism, part 1Freebie
Published 30 October 18

Clojure provides polymorphism through protocols and multimethods. Protocols were covered in depth in episode 24. This episode provides a brief recap, then looks at multimethod basics. If you are already familiar with multimethods then you might want to skip to the second part, which covers some of lesser known aspects.

44. Data Science with Kixi.stats, part 2
Published 12 September 18

After some exploration and analysis of the data it’s time to create a predictive model. In this episode you’ll discover several new chart types, learn how to evaluate the correlation between variables, how to create a simple linear model, and how to evaluate the fitness of the model.

Collections

8 episodes
Learn how to build reactive user interfaces based on ClojureScript and React.js. These episodes gradually build up your knowledge. You start by building a small app using React directly, then move on to using Reagent, a popular wrapper library. Finally you learn how to give your Reagent apps a more coherent structure based on re-frame.
10 episodes
All free Lambda Island episodes in one place. Enjoy!
8 episodes
In this series, core aspects of Clojure are taken apart and put together again, to see what exactly makes them tick. Seq, records, protocol, core functions and essential libraries. Level up now!
2 episodes
Datomic is an immutable database from Cognitect, the makers of Clojure. It has some powerful features and integrates nicely with Clojure's functions and data structures. This series teaches you about the architecture and data model of Datomic, as well as providing a practical tutorial to get up to speed quickly.
4 episodes
An extensive test suite is essential when maintaining a non-trivial code base over time. This series of episodes looks at various aspects of testing in Clojure, as well interesting libraries to add to your toolbox.
4 episodes
To manage the lifecycle of an application, it's become common practice to divide the system up into components, with dependencies between them. Stuart Sierra's Component library was the first to popularize this concept and can still be considered the reference implementation. The pattern is simple enough, but it does require some knowledge of Clojure's types and records functionality, so those are introduced first. This series also covers the System library, a handy collection of reusable components.
5 episodes
The Ring library forms the core of Clojure web development. If you're not sure where to start then this is the series for you. It will give you a solid foundation of the core abstractions involved. It also introduces the Compojure routing library, providing an easy way to start building real apps.
5 episodes
ClojureScript has revolutionized frontend development. The initial learning curve can be steep, but once you're over that initial hump the payoff is great. Learn how to tame the ClojureScript compiler, and how to bridge the gap between your functional ClojureScript code and the wild world of JavaScript.