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.

Ep 056: Opt-In Complexity

We discuss complexity and try to come up with a simple explanation for why Clojurians avoid it so ruthlessly.

Ep 055: Sets! What are they good for?

We examine one of the lesser used data structures in Clojure and talk about its unique characteristics and uses.

Ep 054: The Forest in the Trees

We discuss three powerful libraries (Specter, Spectacles, and clojure.walk) and where they might fit into our Clojure programs.

Ep 053: How can I save my data from serialization?

We record our thoughts on the many trade-offs we have encountered preserving our data when it leaves our programs.

Ep 052: Functions! Functions! Functions!

We wonder how we could function without these critical building blocks, so we catagorize their varied uses.

Ep 051: Maps! Maps! Maps!

We discuss maps and their useful features, including a key distinction that we couldn't live without.

Ep 050: Parentheses! Parentheses! Parentheses!

We defend the lowly parentheses, and discuss the benefits of having this stalwart shepherd dutifully organizing our code.

Ep 049: Keywords! Keywords! Keywords!

We examine all the fascinating properties of keywords, how to use them, and why they're so much better than strings and enums.

Ep 048: Help! How do I fix my REPL?

We catalog the many ways we've broken our REPLs and talk through our strategies for getting back on track.

Ep 047: What is "nil punning"?

We gaze into the nil and find a surprising number of things to talk about.

Ep 046: When is Clojure not the right tool for the job?

We look at the varied forms that Clojure can assume and consider where it might not fit.

Ep 045: Why have derived fields in data when I can just calculate derived data as needed with a function?

We take a focused look at the balance of using functions or derived fields and where each is preferable.

Ep 044: What's so different about Clojure's REPL?

We evaluate what a REPL really is and show that it's much more about the developer experience than simply calculating values.

Ep 043: What is 'faking' a resource?

We talk about the virtues of faking and then outline several real techniques for getting work done.