Latest Episodes

43. Data Science with Kixi.stats, part 1
Published 13 August 18

With the knowledge of transducers under your belt, it’s time to start analyzing some data. This episode provides a first introduction to the Kixi.stats statistical toolkit, by analyzing a data set and its distribution, with the goal of creating a predictive model through linear regression.

42. Inside Transducers
Published 26 June 18

Clojure allows processing data in a way that is composable, reusable, and performs well, all through the power of Transducers. Episode 38 provided a general overview of what’s in the box, the transducers and transducing contexts provided by clojure.core. This episode digs deeper into the internals of transducers and reducing functions, and looks at some powerful libraries for real-world data processing and statistics.

41. Using React Components with Reagent
Published 23 May 18

React’s component based approach means you don’t have to reinvent the wheel, there are literally thousands of building blocks freely available.

When using React components from Reagent there are a few things to watch out for, this episode will show you how to use some popular React components from Reagent, and point out useful constructs and patterns.

You’ll also get to see some of the new cljs.main feature that landed in ClojureScript 1.10.

40. The Ultimate Dev SetupFreebie
Published 01 April 18

This one tool will transform how you program. It’s time to raise your standards!

39. Integrant
Published 15 March 18

Integrant is a “micro-framework for data-driven architecture”. It manages the lifecycle of your application, and the dependencies between components, similar to Component or Mount, but with some very different design decisions.

Integrant forms the foundation for Duct, a Clojure web framework by James Reeves, aka Weavejester.

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.