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.
Thu, 15 Feb 2024 00:00:00 -0800
Ep 111: Loopify!
We throw our code in a loop, and it throws us for a loop.
Thu, 15 Feb 2024 00:00:00 -0800
Ep 110: Contextify!
Our downloads fail at random, but our dead program won't give us any answers.
Thu, 08 Feb 2024 00:00:00 -0800
Ep 109: Extractify!
We need to test our logic, but the I/O is getting in the way.
Thu, 01 Feb 2024 00:00:00 -0800
Ep 108: Testify!
We start testing our code only to discover we need the whole world running first!
Thu, 25 Jan 2024 00:00:00 -0800
Ep 107: Idempotify!
We discover when giving up is the way to get ahead.
Thu, 18 Jan 2024 00:00:00 -0800
Ep 106: Robustify!
We push our software to reach out to the real world and the real world pushes back.
Thu, 11 Jan 2024 00:00:00 -0800
Ep 105: Codify!
We grow beyond our REPL-driven pieces toward an end-to-end solution.
Thu, 04 Jan 2024 00:00:00 -0800
Ep 104: Assembleify!
We realize we're done exploring when all of the pieces fall into place.
Thu, 21 Dec 2023 00:00:00 -0800
Ep 103: Explorify!
We peruse APIs to uncover the data hidden beneath.
Thu, 14 Dec 2023 00:00:00 -0800
Ep 102: REPLify!
We find ourselves in a murky situation, so we go to our REPL-connected editor to shine some light on the details.
Thu, 07 Dec 2023 00:00:00 -0800
Ep 101: Sportify!
We tackle a new application, thinking it'll be an easy win—only to discover that our home run was a foul, and the real world is about to strike us out!
Thu, 30 Nov 2023 00:00:00 -0800
Ep 100: Thanks Overflow
We reflect on Clojure, the community, and how much we have to be thankful for.
Thu, 23 Nov 2023 00:00:00 -0800
Ep 099: REPL Your World
We free our REPL to explore and automate the world around us.
Thu, 16 Nov 2023 00:00:00 -0800
Ep 098: Composed Learnings
We reflect on keeping the necessary mess at the edges so our core can be composed together with beauty and simplicity.
Thu, 09 Nov 2023 00:00:00 -0800
Ep 097: Application of Composition
We get a handle on bringing I/O resources together in an application.
Thu, 02 Nov 2023 00:00:00 -0700
Ep 096: Gaming Data
We go back to start and play through a composition strategy to see where we land.
Thu, 26 Oct 2023 00:00:00 -0700
Ep 095: Composing Core
We venture toward the core of a solution.
Thu, 19 Oct 2023 00:00:00 -0700
Ep 094: Concrete Composition
We help our code through a breakup so it can find its true colors.
Thu, 12 Oct 2023 00:00:00 -0700
Ep 093: Waffle Cakes
We search for that sweet spot between full-featured mixes and simple ingredients when crafting your software recipes.
Thu, 05 Oct 2023 00:00:00 -0700
Ep 092: Freeing Limits
We bump into limiting constraints and learn to love their freedoms.
Thu, 28 Sep 2023 00:00:00 -0700
Ep 091: Combo Boost
We compose our thoughts on why Clojure expressiveness is so effective but can be so hard to learn.
Fri, 22 Sep 2023 00:00:00 -0700
Ep 090: Conditional Results
We devote some time to two functions that are indispensable when computations require variation.
Fri, 18 Dec 2020 08:00:00 -0700
Ep 089: Branching Out
We wander through the myriad ways of making decisions and listing choices in Clojure.
Fri, 20 Nov 2020 08:00:00 -0700
Ep 088: Do Dorun Run!
We eagerly discuss the times we need to interact with the messy world from our nice clean language.
Fri, 13 Nov 2020 08:00:00 -0700
Ep 087: Polymorphic Metal
We discuss polymorphism and how we tackle dynamic data with families of functions.
Fri, 23 Oct 2020 08:00:00 -0700
Ep 086: Let Tricks
Let us share some tricks to reduce nesting and make your code easier to understand.
Tue, 20 Oct 2020 08:00:00 -0700
Ep 085: For for the When
We talk about this data generating macro, while we remember situations when it was useful.
Fri, 25 Sep 2020 08:00:00 -0700
Ep 084: All Sorts
We lay out a list of ways to sort your data, ordered by their relative power.
Fri, 18 Sep 2020 08:00:00 -0700
Ep 083: Sift Sans Sort
We get a handle on big buckets of data by sifting elements into smaller buckets.
Fri, 04 Sep 2020 08:00:00 -0700
Ep 082: Filter and Friends
We talk about sifting data and marvel at the simple function that can turn two steps into one.
Fri, 07 Aug 2020 08:00:00 -0700
Ep 081: List No More
We talk about positive nothing and the proliferation of tuples.
Fri, 31 Jul 2020 08:00:00 -0700
Ep 080: Apply as Needed
We take time to unroll some examples of this function.
Fri, 24 Jul 2020 08:00:00 -0700
Ep 079: Compose Thyself
We create a whole episode by combining examples of useful uses of comp.
Fri, 03 Jul 2020 08:00:00 -0700
Ep 078: Impartial Thoughts
We cover some of the ways we use partial, without getting too literal.
Fri, 19 Jun 2020 08:00:00 -0700
Ep 077: Thread Some
We spend some time going through how these macros help keep our code nil-safe.
Fri, 12 Jun 2020 08:00:00 -0700
Ep 076: Multiple Views on Juxt
We take a turn with juxt, looking at all the ways it can help line up data.
Fri, 05 Jun 2020 08:00:00 -0700
Ep 075: Merge With Fun
We focus in on merge-with, a powerful function for aggregating data.
Fri, 22 May 2020 08:00:00 -0700
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.
Fri, 15 May 2020 08:00:00 -0700
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.
Fri, 17 Apr 2020 08:00:00 -0700
Ep 072: Sea of Sockets
We switch to using a component to manage our websockets, enabling ease of development and future growth.
Fri, 03 Apr 2020 08:00:00 -0700
Ep 071: Socket Synergy
We wander into the weeds, jumping through the myriad hoops required to deliver a simple notification.
Fri, 20 Mar 2020 08:00:00 -0700
Ep 070: Socket Circus
We talk about spontaneously sending data from the server to the client to address our users' insecurities.
Fri, 13 Mar 2020 08:00:00 -0700
Ep 069: Stuck in the Web
We examine our history writing web handlers and talk about all the ways we've broken them.
Fri, 28 Feb 2020 08:00:00 -0700
Ep 068: Static on the Line
We tease apart the layers involved in serving static assets and are surprised by how many we find.
Fri, 21 Feb 2020 08:00:00 -0700
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.
Fri, 14 Feb 2020 08:00:00 -0700
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.
Fri, 31 Jan 2020 08:00:00 -0700
Ep 065: Stuck in the Middle
We find that the middle is a very good place to start when almost everything is composed functions.
Fri, 24 Jan 2020 08:00:00 -0700
Ep 064: Put Ring on It
We focus on the bedrock abstraction for all Clojure web applications and marvel at its simplicity.
Fri, 17 Jan 2020 08:00:00 -0700
Ep 063: Web of Complexity
We launch a new series and immediately get tangled in the many layers that make up the web.
Fri, 10 Jan 2020 08:00:00 -0700
Ep 062: 2019 in Review
We look back at the past year and highlight our favorite episodes.
Fri, 03 Jan 2020 08:00:00 -0700
Ep 061: Transcendental Transformations
We unpack transducers and find a familiar pattern that enables freedom from collections.
Fri, 27 Dec 2019 08:00:00 -0700
Ep 060: Reduce Done Quick
We look at clojure.core.reducers and how it extracts performance by composing reducing functions.
Fri, 20 Dec 2019 08:00:00 -0700
Ep 059: Lining It Up
We examine the sequence abstraction and then ponder how it helps and hinders our data transformation.
Fri, 13 Dec 2019 08:00:00 -0700
Ep 058: Reducing It Down
We take a long hard look at reduce and find the first of many generally useful nuggets inside.
Fri, 06 Dec 2019 08:00:00 -0700
Ep 057: Clojure/Conj 2019 Recap
We go through our notes and recall the most memorable talks from the Conj last week.
Fri, 29 Nov 2019 08:00:00 -0700
Ep 056: Opt-in Complexity
We discuss complexity and try to come up with a simple explanation for why Clojurians avoid it so ruthlessly.
Fri, 22 Nov 2019 08:00:00 -0700
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.
Fri, 15 Nov 2019 08:00:00 -0700
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.
Fri, 08 Nov 2019 08:00:00 -0700
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.
Fri, 01 Nov 2019 08:00:00 -0700
Ep 052: Functions! Functions! Functions!
We wonder how we could function without these critical building blocks, so we catagorize their varied uses.
Fri, 25 Oct 2019 08:00:00 -0700
Ep 051: Maps! Maps! Maps!
We discuss maps and their useful features, including a key distinction that we couldn't live without.
Fri, 18 Oct 2019 08:00:00 -0700
Ep 050: Parentheses! Parentheses! Parentheses!
We defend the lowly parentheses, and discuss the benefits of having this stalwart shepherd dutifully organizing our code.
Fri, 11 Oct 2019 08:00:00 -0700
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.
Fri, 04 Oct 2019 08:00:00 -0700
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.
Fri, 27 Sep 2019 08:00:00 -0700
Ep 047: What Is "Nil Punning"?
We gaze into the nil and find a surprising number of things to talk about.
Fri, 20 Sep 2019 08:00:00 -0700
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.
Fri, 13 Sep 2019 08:00:00 -0700
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.
Fri, 06 Sep 2019 08:00:00 -0700
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.
Fri, 30 Aug 2019 08:00:00 -0700
Ep 043: What Is 'Faking' a Resource?
We talk about the virtues of faking and then outline several real techniques for getting work done.
Fri, 23 Aug 2019 08:00:00 -0700
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.
Fri, 16 Aug 2019 08:00:00 -0700
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.
Fri, 09 Aug 2019 08:00:00 -0700
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.
Fri, 02 Aug 2019 08:00:00 -0700
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.
Fri, 26 Jul 2019 08:00:00 -0700
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.
Fri, 19 Jul 2019 08:00:00 -0700
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.
Fri, 12 Jul 2019 08:00:00 -0700
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.
Fri, 05 Jul 2019 08:00:00 -0700
Ep 035: Lifted Learnings
Christoph and Nate lift concepts from the raw log-parsing series.
Fri, 28 Jun 2019 08:00:00 -0700
Ep 034: Break the Mold
Christoph finds exceptional log lines and takes a more literal approach.
Fri, 21 Jun 2019 08:00:00 -0700
Ep 033: Cake or Ice Cream? Yes!
Nate needs to parse two different errors and takes some time to compose himself.
Fri, 14 Jun 2019 08:00:00 -0700
Ep 032: Call Me Lazy
Christoph finds map doesn't let him be lazy enough.
Fri, 07 Jun 2019 08:00:00 -0700
Ep 031: Eager Abstraction
Nate finds that trouble comes in pairs.
Fri, 31 May 2019 08:00:00 -0700
Ep 030: Lazy Does It
Christoph's eagerness to analyze the big production logs shows him the value of being lazy instead.
Fri, 24 May 2019 08:00:00 -0700
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.
Fri, 17 May 2019 08:00:00 -0700
Ep 028: Fail Donut
Christoph has gigs of log data and he’s looking to Clojure for some help.
Fri, 10 May 2019 08:00:00 -0700
Ep 027: Collected Context
Nate and Christoph reflect on what they learned during the Twitter series.
Fri, 03 May 2019 08:00:00 -0700
Ep 026: One Call to Rule Them All
Christoph thinks goals are data, not function names.
Fri, 26 Apr 2019 08:00:00 -0700
Ep 025: Fake Results, Real Speed
Nate wants to experiment with the UI, but Twitter keeps getting the results.
Fri, 19 Apr 2019 08:00:00 -0700
Ep 024: You Are Here, but Why?
Christoph needs to test his logic, but he must pry it from the clutches of side effects.
Fri, 12 Apr 2019 08:00:00 -0700
Ep 023: Poster Child
Nate gets messy finding ingredients for his algorithm cake.
Fri, 05 Apr 2019 08:00:00 -0700
Ep 022: Evidence of Attempted Posting
Christoph questions his attempts to post to Twitter.
Fri, 29 Mar 2019 08:00:00 -0700
Ep 021: Mutate the Internet
Nate wants to tweet regularly, so he asks Clojure for some help.
Fri, 22 Mar 2019 08:00:00 -0700
Ep 020: Data Dessert
Christoph and Nate discuss the flavor of pure data.
Fri, 15 Mar 2019 00:00:00 -0800
Ep 019: Dazed by Weak Weeks
Nate wants to see more than data structures in a REPL.
Fri, 08 Mar 2019 00:00:00 -0800
Ep 018: Did I Work Late on Tuesday?
Christoph wants to teach filter some vocabulary.
Fri, 01 Mar 2019 00:00:00 -0800
Ep 017: Data, at Your Service
Nate finds it easier to get a broad view without a microscope.
Fri, 22 Feb 2019 00:00:00 -0800
Ep 016: When 8 - 1 = 6
Christoph discovers that time creates its own alternate universe.
Fri, 15 Feb 2019 00:00:00 -0800
Ep 015: Finding the Time
Nate spends some time figuring out how to track his time.
Fri, 08 Feb 2019 00:00:00 -0800
Episode 014: Fiddle With the REPL
Christoph gets some work done by fiddling around.
Fri, 01 Feb 2019 00:00:00 -0800
Episode 013: Connect the REPL
Nate continues to explore the REPL by gluing it to his editor to see what happens.
Fri, 25 Jan 2019 00:00:00 -0800
Episode 012: Embrace the REPL
Christoph complicated development by misunderstanding the REPL.
Fri, 18 Jan 2019 00:00:00 -0800
Episode 011: The Convention of Configuration
Nate is worried about the hardcoded credentials in the code.
Fri, 11 Jan 2019 00:00:00 -0800
Episode 010: From Mud to Bricks
Christoph can't stand the spaghetti mess in main. Time to refactor.
Fri, 04 Jan 2019 00:00:00 -0800
Episode 009: Channeling Re-Search
Nate can't decide what to watch on Twitter, and the app restarts are killing him.
Fri, 28 Dec 2018 00:00:00 -0800
Episode 008: Twitter, Plated
Christoph tries to figure out why Twitter stopped talking about Clojure.
Fri, 21 Dec 2018 00:00:00 -0800
Episode 007: Input Overflow
Nate just wants to print the tweets, but the input wants to take over.
Fri, 14 Dec 2018 00:00:00 -0800
Episode 006: All Wrapped Up in Twitter
Christoph tries to get a handle on his #clojure tweet-stream habit.
Fri, 07 Dec 2018 00:00:00 -0800
Episode 005: Tracking, for the Win
Nate tries to figure out who actually won this never-ending game of tic-tac-toe.
Fri, 30 Nov 2018 00:00:00 -0800
Episode 004: Atomic Curls
Christoph tries to make tic-tac-toe work over the Internet and discovers the power of the atom.
Fri, 23 Nov 2018 00:00:00 -0800
Episode 003: Tic-Tac-REPL
Nate tries to turn the tic-tac-toe game engine into a real application he can play with a friend.
Fri, 16 Nov 2018 00:00:00 -0800
Episode 002: Tic-Tac-Toe, State in a Row
Christoph tries to make tic-tac-toe and gets stuck on immutability.
Fri, 09 Nov 2018 00:00:00 -0800
Episode 001: Why, Oh Why?
Nate and Christoph try to figure out how to make a podcast.
Fri, 02 Nov 2018 00:00:00 -0800
