Functional Design in Clojure

Follow Functional Design in Clojure
Share on
Copy link to clipboard

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

Christoph Neumann and Nate Jones


    • Jun 27, 2024 LATEST EPISODE
    • monthly NEW EPISODES
    • 26m AVG DURATION
    • 118 EPISODES


    Search for episodes from Functional Design in Clojure with a specific topic:

    Latest episodes from Functional Design in Clojure

    Ep 118: Pure Parts

    Play Episode Listen Later Jun 27, 2024 28:28


    We look at pure data models we've created and see what they have in common.

    Ep 117: Pure Understanding

    Play Episode Listen Later May 23, 2024 25:13


    We find a clear and pure heart in our application, unclouded by side effects.

    Ep 116: The Main Focus

    Play Episode Listen Later May 16, 2024 22:44


    We turn our attention to the frontend, and our eyes burn from the complexity.

    Ep 115: The Main Event

    Play Episode Listen Later May 9, 2024 28:42


    We look for a suitable place to dig into the code and find an entry point.

    Ep 114: Brand New, Again

    Play Episode Listen Later May 2, 2024 16:08


    We find ourselves staring at code for the first time—even though we wrote some of it!

    Ep 113: Highlightify!

    Play Episode Listen Later Feb 29, 2024 27:13


    We highlight the highlights of the Sportify! series.

    Ep 112: Purify!

    Play Episode Listen Later Feb 22, 2024 33:20


    We loop back to our new approach and find more, and less, than we expected!

    Ep 111: Loopify!

    Play Episode Listen Later Feb 15, 2024 28:54


    We throw our code in a loop, and it throws us for a loop.

    Ep 110: Contextify!

    Play Episode Listen Later Feb 8, 2024 23:22


    Our downloads fail at random, but our dead program won't give us any answers.

    Ep 109: Extractify!

    Play Episode Listen Later Feb 1, 2024 26:35


    We need to test our logic, but the I/O is getting in the way.

    Ep 108: Testify!

    Play Episode Listen Later Jan 25, 2024 22:42


    We start testing our code only to discover we need the whole world running first!

    Ep 107: Idempotify!

    Play Episode Listen Later Jan 18, 2024 31:53


    We discover when giving up is the way to get ahead.

    Ep 106: Robustify!

    Play Episode Listen Later Jan 11, 2024 30:37


    We push our software to reach out to the real world and the real world pushes back.

    Ep 105: Codify!

    Play Episode Listen Later Jan 4, 2024 25:42


    We grow beyond our REPL-driven pieces toward an end-to-end solution.

    Ep 104: Assembleify!

    Play Episode Listen Later Dec 21, 2023 35:03


    We realize we're done exploring when all of the pieces fall into place.

    Ep 103: Explorify!

    Play Episode Listen Later Dec 14, 2023 32:15


    We peruse APIs to uncover the data hidden beneath.

    Ep 102: REPLify!

    Play Episode Listen Later Dec 7, 2023 28:11


    We find ourselves in a murky situation, so we go to our REPL-connected editor to shine some light on the details.

    Ep 101: Sportify!

    Play Episode Listen Later Nov 30, 2023 17:03


    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!

    Ep 100: Thanks Overflow

    Play Episode Listen Later Nov 23, 2023 35:29


    We reflect on Clojure, the community, and how much we have to be thankful for.

    Ep 099: REPL Your World

    Play Episode Listen Later Nov 16, 2023 25:28


    We free our REPL to explore and automate the world around us.

    Ep 098: Composed Learnings

    Play Episode Listen Later Nov 9, 2023 26:12


    We reflect on keeping the necessary mess at the edges so our core can be composed together with beauty and simplicity.

    Ep 097: Application of Composition

    Play Episode Listen Later Nov 2, 2023 28:33


    We get a handle on bringing I/O resources together in an application.

    Ep 096: Gaming Data

    Play Episode Listen Later Oct 26, 2023 26:39


    We go back to start and play through a composition strategy to see where we land.

    Ep 095: Composing Core

    Play Episode Listen Later Oct 19, 2023 17:37


    We venture toward the core of a solution.

    Ep 094: Concrete Composition

    Play Episode Listen Later Oct 12, 2023 15:29


    We help our code through a breakup so it can find its true colors.

    Ep 093: Waffle Cakes

    Play Episode Listen Later Oct 5, 2023 14:22


    We search for that sweet spot between full-featured mixes and simple ingredients when crafting your software recipes.

    Ep 092: Freeing Limits

    Play Episode Listen Later Sep 28, 2023 17:02


    We bump into limiting constraints and learn to love their freedoms.

    Ep 091: Combo Boost

    Play Episode Listen Later Sep 22, 2023 12:00


    We compose our thoughts on why Clojure expressiveness is so effective but can be so hard to learn.

    Ep 090: Conditional Results

    Play Episode Listen Later Dec 18, 2020 25:00


    We devote some time to two functions that are indispensable when computations require variation.

    Ep 089: Branching Out

    Play Episode Listen Later Nov 20, 2020 38:47


    We wander through the myriad ways of making decisions and listing choices in Clojure.

    Ep 088: Do Dorun Run!

    Play Episode Listen Later Nov 13, 2020 26:40


    We eagerly discuss the times we need to interact with the messy world from our nice clean language.

    Ep 087: Polymorphic Metal

    Play Episode Listen Later Oct 23, 2020 29:55


    We discuss polymorphism and how we tackle dynamic data with families of functions.

    Ep 086: Let Tricks

    Play Episode Listen Later Oct 20, 2020 32:49


    Let us share some tricks to reduce nesting and make your code easier to understand.

    Ep 085: For for the When

    Play Episode Listen Later Sep 25, 2020 29:27


    We talk about this data generating macro, while we remember situations when it was useful.

    Ep 084: All Sorts

    Play Episode Listen Later Sep 18, 2020 27:07


    We lay out a list of ways to sort your data, ordered by their relative power.

    Ep 083: Sift Sans Sort

    Play Episode Listen Later Sep 4, 2020 24:26


    We get a handle on big buckets of data by sifting elements into smaller buckets.

    Ep 082: Filter and Friends

    Play Episode Listen Later Aug 7, 2020 27:55


    We talk about sifting data and marvel at the simple function that can turn two steps into one.

    Ep 081: List No More

    Play Episode Listen Later Jul 31, 2020 26:05


    We talk about positive nothing and the proliferation of tuples.

    Ep 080: Apply as Needed

    Play Episode Listen Later Jul 24, 2020 22:14


    We take time to unroll some examples of this function.

    Ep 079: Compose Thyself

    Play Episode Listen Later Jul 3, 2020 27:40


    We create a whole episode by combining examples of useful uses of comp.

    Ep 078: Impartial Thoughts

    Play Episode Listen Later Jun 19, 2020 25:33


    We cover some of the ways we use partial, without getting too literal.

    Ep 077: Thread Some

    Play Episode Listen Later Jun 12, 2020 23:10


    We spend some time going through how these macros help keep our code nil-safe.

    Ep 076: Multiple Views on Juxt

    Play Episode Listen Later Jun 5, 2020 30:08


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

    views juxt
    Ep 075: Merge With Fun

    Play Episode Listen Later May 22, 2020 26:08


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

    Ep 074: Deploy, They Said. It'll Be Fun, They Said.

    Play Episode Listen Later May 15, 2020 27:35


    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

    Play Episode Listen Later Apr 17, 2020 38:19


    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

    Play Episode Listen Later Apr 3, 2020 32:11


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

    Ep 071: Socket Synergy

    Play Episode Listen Later Mar 20, 2020 29:10


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

    Ep 070: Socket Circus

    Play Episode Listen Later Mar 13, 2020 29:43


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

    Ep 069: Stuck in the Web

    Play Episode Listen Later Feb 28, 2020 28:50


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

    Ep 068: Static on the Line

    Play Episode Listen Later Feb 21, 2020 24:20


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

    Claim Functional Design in Clojure

    In order to claim this podcast we'll send an email to with a verification link. Simply click the link and you will be able to edit tags, request a refresh, and other features to take control of your podcast page!

    Claim Cancel