Functional Design in Clojure

Functional Design in Clojure episodes:

• 01.10.2020

  Ep 063: Web of Complexity

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

  
• 01.03.2020

  Ep 062: 2019 in Review

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

  
• 12.27.2019

  Ep 061: Transcendental Transformations

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

  
• 12.20.2019

  Ep 060: Reduce Done Quick

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

  
• 12.13.2019

  Ep 059: Lining It Up

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

  
• 12.06.2019

  Ep 058: Reducing It Down

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

  
• 11.29.2019

  Ep 057: Clojure/Conj 2019 Recap

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

  
• 11.22.2019

  Ep 056: Opt-in Complexity

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

  
• 11.15.2019

  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.

  
• 11.08.2019

  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.

  
• 11.01.2019

  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.

  
• 10.25.2019

  Ep 052: Functions! Functions! Functions!

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

  
• 10.18.2019

  Ep 051: Maps! Maps! Maps!

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

  
• 10.11.2019

  Ep 050: Parentheses! Parentheses! Parentheses!

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

  
• 10.04.2019

  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.

  
• 09.27.2019

  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.

  
• 09.20.2019

  Ep 047: What Is "Nil Punning"?

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

  
• 09.13.2019

  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.

  
• 09.06.2019

  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.

  
• 08.30.2019

  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.

  
• 08.23.2019

  Ep 043: What Is 'Faking' a Resource?

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

  
• 08.16.2019

  Ep 042: What Does It Mean to Be 'Data-Oriented'?

  We merge together different aspects of Clojure's data orientation and specify which of those help make development more pleasant.

  
• 08.09.2019

  Ep 041: Why Do Clojurians Make Such a Big Deal About Immutability?

  We cover several practical side effects of immutability and why we've become such big fans of data that doesn't let us down.

  
• 08.02.2019

  Ep 040: Should I Use Lein, Boot, or Tools.deps?

  We assemble a list of build tool characteristics and talk about how each tool stacks up before giving our recommendations.

  
• 07.26.2019

  Ep 039: Why Use Clojure Over Another Functional Language?

  We examine the different categories of functional programming languages and distill out what differentiates Clojure and why we prefer it.

  
• 07.19.2019

  Ep 038: How Do I Convince My Coworkers to Use Clojure?

  We recall our own experiences evangelizing Clojure and give practical advice from the trenches.

  
• 07.12.2019

  Ep 037: What Advice Would You Give to Someone Getting Started With Clojure?

  We trade off giving practical tips for intrepid learners reminisce about our own paths into Clojure.

  
• 07.05.2019

  Ep 036: Why Do You Recommend Clojure?

  We take turns sharing our favorite reasons, and we can't help but have fun riffing on how enjoyable Clojure is to use.

  
• 06.28.2019

  Ep 035: Lifted Learnings

  Christoph and Nate lift concepts from the raw log-parsing series.

  
• 06.21.2019

  Ep 034: Break the Mold

  Christoph finds exceptional log lines and takes a more literal approach.

  
• 06.14.2019

  Ep 033: Cake or Ice Cream? Yes!

  Nate needs to parse two different errors and takes some time to compose himself.

  
• 06.07.2019

  Ep 032: Call Me Lazy

  Christoph finds map doesn't let him be lazy enough.

  
• 05.31.2019

  Ep 031: Eager Abstraction

  Nate finds that trouble comes in pairs.

  
• 05.24.2019

  Ep 030: Lazy Does It

  Christoph's eagerness to analyze the big production logs shows him the value of being lazy instead.

  
• 05.17.2019

  Ep 029: Problem Unknown: Log Lines

  Nate is dropped in the middle of a huge log file and hunts for the source of the errors.

  
• 05.10.2019

  Ep 028: Fail Donut

  Christoph has gigs of log data and he’s looking to Clojure for some help.

  
• 05.03.2019

  Ep 027: Collected Context

  Nate and Christoph reflect on what they learned during the Twitter series.

  
• 04.26.2019

  Ep 026: One Call to Rule Them All

  Christoph thinks goals are data, not function names.

  
• 04.19.2019

  Ep 025: Fake Results, Real Speed

  Nate wants to experiment with the UI, but Twitter keeps getting the results.

  
• 04.12.2019

  Ep 024: You Are Here, but Why?

  Christoph needs to test his logic, but he must pry it from the clutches of side effects.

  
• 04.05.2019

  Ep 023: Poster Child

  Nate gets messy finding ingredients for his algorithm cake.

  
• 03.29.2019

  Ep 022: Evidence of Attempted Posting

  Christoph questions his attempts to post to Twitter.

  
• 03.22.2019

  Ep 021: Mutate the Internet

  Nate wants to tweet regularly, so he asks Clojure for some help.

  
• 03.15.2019

  Ep 020: Data Dessert

  Christoph and Nate discuss the flavor of pure data.

  
• 03.08.2019

  Ep 019: Dazed by Weak Weeks

  Nate wants to see more than data structures in a REPL.

  
• 03.01.2019

  Ep 018: Did I Work Late on Tuesday?

  Christoph wants to teach filter some vocabulary.

  
• 02.22.2019

  Ep 017: Data, at Your Service

  Nate finds it easier to get a broad view without a microscope.

  
• 02.15.2019

  Ep 016: When 8 - 1 = 6

  Christoph discovers that time creates its own alternate universe.

  
• 02.08.2019

  Ep 015: Finding the Time

  Nate spends some time figuring out how to track his time.

  
• 02.01.2019

  Episode 014: Fiddle With the REPL

  Christoph gets some work done by fiddling around.