Functional Design in Clojure

Functional Design in Clojure
Each week, we discuss a software design problem and how we might solve it using functional principles and the Clojure programming language.

Ep 054: The Forest in the Trees
Nov 8 • 21 min
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?
Nov 1 • 30 min
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!
Oct 25 • 37 min
We wonder how we could function without these critical building blocks, so we catagorize their varied uses.
Ep 051: Maps! Maps! Maps!
Oct 18 • 28 min
We discuss maps and their useful features, including a key distinction that we couldn’t live without.
Ep 050: Parentheses! Parentheses! Parentheses!
Oct 11 • 27 min
We defend the lowly parentheses, and discuss the benefits of having this stalwart shepherd dutifully organizing our code.
Ep 049: Keywords! Keywords! Keywords!
Oct 4 • 25 min
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?
Sep 27 • 27 min
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”?
Sep 20 • 28 min
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?
Sep 13 • 25 min
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?
Sep 6 • 20 min
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?
Aug 30 • 28 min
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?
Aug 23 • 23 min
We talk about the virtues of faking and then outline several real techniques for getting work done.
Ep 042: What Does It Mean to Be ‘Data-Oriented’?
Aug 16 • 26 min
We merge together different aspects of Clojure’s data orientation and specify which of those help make development more pleasant.
Ep 041: Why Do Clojurians Make Such a Big Deal About Immutability?
Aug 9 • 27 min
We cover several practical side effects of immutability and why we’ve become such big fans of data that doesn’t let us down.
Ep 040: Should I Use Lein, Boot, or Tools.deps?
Aug 2 • 28 min
We assemble a list of build tool characteristics and talk about how each tool stacks up before giving our recommendations.
Ep 039: Why Use Clojure Over Another Functional Language?
Jul 26 • 25 min
We examine the different categories of functional programming languages and distill out what differentiates Clojure and why we prefer it.
Ep 038: How Do I Convince My Coworkers to Use Clojure?
Jul 19 • 24 min
We recall our own experiences evangelizing Clojure and give practical advice from the trenches.
Ep 037: What Advice Would You Give to Someone Getting Started With Clojure?
Jul 12 • 25 min
We trade off giving practical tips for intrepid learners reminisce about our own paths into Clojure.
Ep 036: Why Do You Recommend Clojure?
Jul 5 • 19 min
We take turns sharing our favorite reasons, and we can’t help but have fun riffing on how enjoyable Clojure is to use.
Ep 035: Lifted Learnings
Jun 28 • 27 min
Christoph and Nate lift concepts from the raw log-parsing series.
Ep 034: Break the Mold
Jun 21 • 26 min
Christoph finds exceptional log lines and takes a more literal approach.
Ep 033: Cake or Ice Cream? Yes!
Jun 14 • 21 min
Nate needs to parse two different errors and takes some time to compose himself.
Ep 032: Call Me Lazy
Jun 7 • 27 min
Christoph finds map doesn’t let him be lazy enough.
Ep 031: Eager Abstraction
May 31 • 22 min
Nate finds that trouble comes in pairs.
Ep 030: Lazy Does It
May 24 • 30 min
Christoph’s eagerness to analyze the big production logs shows him the value of being lazy instead.
Ep 029: Problem Unknown: Log Lines
May 17 • 35 min
Nate is dropped in the middle of a huge log file and hunts for the source of the errors.
Ep 028: Fail Donut
May 10 • 16 min
Christoph has gigs of log data and he’s looking to Clojure for some help.
Ep 027: Collected Context
May 3 • 33 min
Nate and Christoph reflect on what they learned during the Twitter series.
Ep 026: One Call to Rule Them All
Apr 26 • 29 min
Christoph thinks goals are data, not function names.
Ep 025: Fake Results, Real Speed
Apr 19 • 25 min
Nate wants to experiment with the UI, but Twitter keeps getting the results.
Ep 024: You Are Here, but Why?
Apr 12 • 34 min
Christoph needs to test his logic, but he must pry it from the clutches of side effects.
Ep 023: Poster Child
Apr 5 • 31 min
Nate gets messy finding ingredients for his algorithm cake.
Ep 022: Evidence of Attempted Posting
Mar 29 • 33 min
Christoph questions his attempts to post to Twitter.
Ep 021: Mutate the Internet
Mar 22 • 22 min
Nate wants to tweet regularly, so he asks Clojure for some help.
Ep 020: Data Dessert
Mar 15 • 28 min
Christoph and Nate discuss the flavor of pure data.
Ep 019: Dazed by Weak Weeks
Mar 8 • 29 min
Nate wants to see more than data structures in a REPL.
Ep 018: Did I Work Late on Tuesday?
Mar 1 • 28 min
Christoph wants to teach filter some vocabulary.
Ep 017: Data, at Your Service
Feb 22 • 28 min
Nate finds it easier to get a broad view without a microscope.
Ep 016: When 8 - 1 = 6
Feb 15 • 29 min
Christoph discovers that time creates its own alternate universe.
Ep 015: Finding the Time
Feb 8 • 26 min
Nate spends some time figuring out how to track his time.
Episode 014: Fiddle With the REPL
Feb 1 • 29 min
Christoph gets some work done by fiddling around.
Episode 013: Connect the REPL
Jan 25 • 32 min
Nate continues to explore the REPL by gluing it to his editor to see what happens.
Episode 012: Embrace the REPL
Jan 18 • 25 min
Christoph complicated development by misunderstanding the REPL.
Episode 011: The Convention of Configuration
Jan 11 • 28 min
Nate is worried about the hardcoded credentials in the code.
Episode 010: From Mud to Bricks
Jan 4 • 28 min
Christoph can’t stand the spaghetti mess in main. Time to refactor.
Episode 009: Channeling Re-Search
Dec 28, 2018 • 26 min
Nate can’t decide what to watch on Twitter, and the app restarts are killing him.
Episode 008: Twitter, Plated
Dec 21, 2018 • 23 min
Christoph tries to figure out why Twitter stopped talking about Clojure.
Episode 007: Input Overflow
Dec 14, 2018 • 26 min
Nate just wants to print the tweets, but the input wants to take over.
Episode 006: All Wrapped Up in Twitter
Dec 7, 2018 • 25 min
Christoph tries to get a handle on his #clojure tweet-stream habit.
Episode 005: Tracking, for the Win
Nov 30, 2018 • 26 min
Nate tries to figure out who actually won this never-ending game of tic-tac-toe.
Episode 004: Atomic Curls
Nov 23, 2018 • 22 min
Christoph tries to make tic-tac-toe work over the Internet and discovers the power of the atom.
Episode 003: Tic-Tac-REPL
Nov 16, 2018 • 23 min
Nate tries to turn the tic-tac-toe game engine into a real application he can play with a friend.
Episode 002: Tic-Tac-Toe, State in a Row
Nov 9, 2018 • 20 min
Christoph tries to make tic-tac-toe and gets stuck on immutability.
Episode 001: Why, Oh Why?
Nov 2, 2018 • 13 min
Nate and Christoph try to figure out how to make a podcast.