We devote some time to two functions that are indispensable when computations require variation.

We wander through the myriad ways of making decisions and listing choices in Clojure.

We eagerly discuss the times we need to interact with the messy world from our nice clean language.

We discuss polymorphism and how we tackle dynamic data with families of functions.

Let us share some tricks to reduce nesting and make your code easier to understand.

We talk about this data generating macro, while we remember situations when it was useful.

We lay out a list of ways to sort your data, ordered by their relative power.

We get a handle on big buckets of data by sifting elements into smaller buckets.

We talk about sifting data and marvel at the simple function that can turn two steps into one.

We talk about positive nothing and the proliferation of tuples.

We take time to unroll some examples of this function.

We create a whole episode by combining examples of useful uses of comp.

We cover some of the ways we use partial, without getting too literal.

We spend some time going through how these macros help keep our code nil-safe.

We take a turn with juxt, looking at all the ways it can help line up data.

We focus in on merge-with, a powerful function for aggregating data.

We survey the myriad ways we've used to launch our code into production, and laugh about the various complexities we've found.

We worry about the health of our websockets and, after looking for help from the standards bodies, roll up our sleeves and handle it ourselves.

We switch to using a component to manage our websockets, enabling ease of development and future growth.

We wander into the weeds, jumping through the myriad hoops required to deliver a simple notification.

We talk about spontaneously sending data from the server to the client to address our users' insecurities.

We examine our history writing web handlers and talk about all the ways we've broken them.