Ep 076: Multiple Views on Juxt

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

Ep 075: Merge With Fun

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

Ep 074: Deploy, they said. It'll be fun, they said.

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

Ep 073: Silent Sockets

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.

Ep 072: Sea of Sockets

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

Ep 071: Socket Synergy

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

Ep 070: Socket Circus

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

Ep 069: Stuck in the Web

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

Ep 068: Static on the Line

We tease apart the layers involved in serving static assets and are surprised by how many we find.

Ep 067: Handling Handler's Handles

We manage to find a way to get our handlers the resources they need to get real work done.

Ep 066: Compose the Codec

We reinvent the wheel, and along the way discover a few reasons why you might want to do so as well.

Ep 065: Stuck in the Middle

We find that the middle is a very good place to start when almost everything is composed functions.

Ep 064: Put Ring on It

We focus on the bedrock abstraction for all Clojure web applications and marvel at its simplicity.

Ep 063: Web of Complexity

We launch a new series and immediately get tangled in the many layers that make up the web.

Ep 062: 2019 in Review

We look back at the past year and highlight our favorite episodes.

Ep 061: Transcendental Transformations

We unpack transducers and find a familiar pattern that enables freedom from collections.

Ep 060: Reduce Done Quick

We look at clojure.core.reducers and how it extracts performance by composing reducing functions.

Ep 059: Lining It Up

We examine the sequence abstraction and then ponder how it helps and hinders our data transformation.

Ep 058: Reducing it Down

We take a long hard look at reduce and find the first of many generally useful nuggets inside.

Ep 057: Clojure/Conj 2019 Recap

We go through our notes and recall the most memorable talks from the Conj last week.