TopPodcast.com
Menu
  • Home
  • Top Charts
  • Top Networks
  • Top Apps
  • Top Independents
  • Top Podfluencers
  • Top Picks
    • Top Business Podcasts
    • Top True Crime Podcasts
    • Top Finance Podcasts
    • Top Comedy Podcasts
    • Top Music Podcasts
    • Top Womens Podcasts
    • Top Kids Podcasts
    • Top Sports Podcasts
    • Top News Podcasts
    • Top Tech Podcasts
    • Top Crypto Podcasts
    • Top Entrepreneurial Podcasts
    • Top Fantasy Sports Podcasts
    • Top Political Podcasts
    • Top Science Podcasts
    • Top Self Help Podcasts
    • Top Sports Betting Podcasts
    • Top Stocks Podcasts
  • Podcast News
  • About Us
  • Podcast Advertising
  • Contact
Not in our directory?
Add Show Here
Podcast Equipment
Center

toppodcastlogoOur TOPPODCAST Picks

  • Comedy
  • Crypto
  • Sports
  • News
  • Politics
  • True Crime
  • Business
  • Finance

Follow Us

toppodcastlogoStay Connected

    View Top 200 Chart
    Back to Rankings Page
    Technology

    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.

    Advertise

    Copyright: © 2018-2019, Christoph Neumann and Nate Jones

    • Apple Podcasts
    • Google Play
    • Spotify

    Latest Episodes:
    Ep 059: Lining It Up Dec 13, 2019
    Show notes

    Each week, we discuss a different topic about Clojure and functional programming.

    If you have a question or topic you'd like us to discuss, tweet @clojuredesign, send an email to feedback@clojuredesign.club, or join the #clojuredesign-podcast channel on the Clojurians Slack.

    This week, the topic is: "Sequences." We examine the sequence abstraction and then ponder how it helps and hinders our data transformation.

    Selected quotes:

    • "There is only one filter, map, and reduce. They need to be able to interpret all collections."
    • "Primitives only take you so far."
    • "The first thing is the first thing!"
    • "The seq abstraction is foundational to Clojure core."
    • "The into function pours a sequence back into a concrete data structure."

    Ep 058: Reducing It Down Dec 06, 2019
    Show notes

    Each week, we discuss a different topic about Clojure and functional programming.

    If you have a question or topic you'd like us to discuss, tweet @clojuredesign, send an email to feedback@clojuredesign.club, or join the #clojuredesign-podcast channel on the Clojurians Slack.

    This week, the topic is: "Reduce and reducing functions" We take a long hard look at reduce and find the first of many generally useful nuggets inside.

    Selected quotes:

    • "Parentheses are a joy, they are hugs around your code."
    • "You want to boil it down into a result, so you use reduce."
    • "We've taken ahold of the cooking metaphors and are just running with it!"
    • "Reducing functions are a backbone of functional programming, because we don't have mutation."
    • "Understanding reduce is really important for understanding functional programming."

    Related episodes:

    • 002: Tic-Tac-Toe, State in a Row

    Ep 057: Clojure/Conj 2019 Recap Nov 29, 2019
    Show notes

    Each week, we discuss a different topic about Clojure and functional programming.

    If you have a question or topic you'd like us to discuss, tweet @clojuredesign, send an email to feedback@clojuredesign.club, or join the #clojuredesign-podcast channel on the Clojurians Slack.

    This week, the topic is: "Clojure/Conj 2019 Recap" We go through our notes and recall the most memorable talks from the Conj last week.

    Selected quotes:

    • "Cold climate, warm people."
    • "Learn skills that transfer."
    • "The future is about immutability and composability."
    • "YAML! YAML! YAML! The names of an episode we have not done, and probably will not do."
    • "If you can make solving problems easier by using Clojure, then there is a lot of incentive to learn and use Clojure."
    • "You can't get rid of bias, even when you know you have it. All you can do is change how you work."
    • "The Conj has become less about Clojure and more about solving problems."

    Talks:

    • Defeating the Four Horsemen of the Coding Apocalypse - Mark Bastian
    • Follow the Data: Product Development in Clojure - Derek Troy-West
      Application: Operatr
    • Love Letter To Clojure: And A Datomic Experience Report - Gene Kim
      New book: The Unicorn Project
    • Goodbye YAML: Infrastructure as Code in Clojure - Eno Compton & Tyler van Hensbergen
    • Interactive Programming for Artificial Intelligence - Dragan Djuric
      Libraries: uncomplicate.org, Blog: dragan.rocks, Books: aiprobook.com
    • Probabilistic Record Linkage of Hospital Patients - Chris Oakman
    • Rapid Prototyping for Software Development - Sara Kimmich
    • (Architecture) Diagrams as Data - Avi Flax
    • The Hitchhikers Guide to Multiparadigm Programming - Ariel Ortiz
    • A Racket Perspective on Research, Education, and Production - Matthew Flatt
      Site: racket-lang.org
    • Composable Tools - Alex Miller
    • Sherlock Holmes, Consulting Developer - Stuart Halloway

    Ep 056: Opt-in Complexity Nov 22, 2019
    Show notes

    Each week, we discuss a different topic about Clojure and functional programming.

    If you have a question or topic you'd like us to discuss, tweet @clojuredesign, send an email to feedback@clojuredesign.club, or join the #clojuredesign-podcast channel on the Clojurians Slack.

    This week, the topic is: "Opt-In Complexity" We discuss complexity and try to come up with a simple explanation for why Clojurians avoid it so ruthlessly.

    Selected quotes:

    • "Abstraction: the thing that creates more complexity while making you feel like you have less."
    • "Clojure people seem to be allergic to complexity."
    • "Frameworks are the breeding ground for complexity."
    • "Complexity is the enemy of long lived code bases."
    • "Each part of the application is in its own vault of isolation, and they only get to come together and interact in the lobby."
    • "You can't be afraid of something that hasn't scared you yet."
    • "It's very difficult to say no once you've said yes."

    Links:

    • Simple Made Easy
    • Luminus
    • Hoplon
    • Pedestal

    Ep 055: Sets! What Are They Good For? Nov 15, 2019
    Show notes

    Each week, we discuss a different topic about Clojure and functional programming.

    If you have a question or topic you'd like us to discuss, tweet @clojuredesign, send an email to feedback@clojuredesign.club, or join the #clojuredesign-podcast channel on the Clojurians Slack.

    This week, the topic is: "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.

    Selected quotes:

    • "Sets aren't going to get top billing."
    • "Sets are really about uniqueness."
    • "Sets let us calculate differences cheaply."
    • "Clever is a word I used to like when I was a younger programmer."
    • "Clever now equals hours of suffering!"

    Ep 054: The Forest in the Trees Nov 08, 2019
    Show notes

    Each week, we discuss a different topic about Clojure and functional programming.

    If you have a question or topic you'd like us to discuss, tweet @clojuredesign, send an email to feedback@clojuredesign.club, or join the #clojuredesign-podcast channel on the Clojurians Slack.

    This week, the topic is: "Working with heavily nested trees." We discuss three powerful libraries (Specter, Spectacles, and clojure.walk) and where they might fit into our Clojure programs.

    Selected quotes:

    • "Tree manipulation is like surgery, you need to get down to the right level before you start making changes."
    • "I've seen people come up with novel and interesting solutions to problems that other people just don't have."
    • "Spec is a structural type checker, instead of a name-based type checker, which is far more useful."
    • "Every time you reach for a tool, you're inviting its complexity into your project."
    • "The structure of your data will lead you toward a particular tool."

    Related episodes:

    • 020: Data Dessert - Summary episode for the time log series

    Links:

    • clojure.walk
    • Specter
    • Spectacles

    Ep 053: How Can I Save My Data From Serialization? Nov 01, 2019
    Show notes

    Each week, we answer a different question about Clojure and functional programming.

    If you have a question you'd like us to discuss, tweet @clojuredesign, send an email to feedback@clojuredesign.club, or join the #clojuredesign-podcast channel on the Clojurians Slack.

    This week, the question is: "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.

    Selected quotes:

    • "Clojure has the best data structures on the planet."
    • "One of the reasons why JSON is so popular is because XML was so overbearingly hard."
    • "XML decided that trees aren't dimensional enough, so they added another dimension in attributes."
    • "Serialization formats aren't for humans, Nate, what are you talking about?!"
    • "EDN isn't horrible to look at because it's just Clojure data structures."
    • "We don't want freezer burn!"

    Related episodes:

    • 014: Fiddle with the REPL

    Links:

    • EDN
    • Transit
    • Nippy
    • Fressian
    • fress: Fressian for Clojure(Script) AND WASM!

    Ep 052: Functions! Functions! Functions! Oct 25, 2019
    Show notes

    Each week, we discuss a different topic about Clojure and functional programming.

    If you have a question you'd like us to discuss, tweet @clojuredesign, send an email to feedback@clojuredesign.club, or join the #clojuredesign-podcast channel on the Clojurians Slack.

    This week, our topic is: "Functions! Functions! Functions!" We wonder how we could function without these critical building blocks, so we catagorize their varied uses.

    Selected quotes:

    • "Functions put the fun in functional."
    • "Each function category has a different mindset."
    • "Programming is more fun when you're only thinking about the problem in front of you."
    • "Naming bits of computation helps you understand an abstraction without having to dip into it."
    • "So you don't want the function to be called 'write-or-fetch-or-sleep-or-return!'?"
    • "Side effecting functions shouldn't think. They are grunts."
    • "The I/O fairy hands you data, and you get it all transformed with pure functions, and then you hand it back to the I/O fairy."
    • "That Twitter use case, that has a lot more side effects."

    Related episodes:

    • 002: Tic-Tac-Toe, State in a Row
    • 024: You Are Here, But Why?

    Ep 051: Maps! Maps! Maps! Oct 18, 2019
    Show notes

    Each week, we discuss a different topic about Clojure and functional programming.

    If you have a question you'd like us to discuss, tweet @clojuredesign, send an email to feedback@clojuredesign.club, or join the #clojuredesign-podcast channel on the Clojurians Slack.

    This week, our topic is: "Maps! Maps! Maps!" We discuss maps and their useful features, including a key distinction that we couldn't live without.

    Selected quotes:

    • "Working with Clojure makes you feel like you're living in the future!"
    • "Maps are bags of dimensions."
    • "The namespace of the key is the entity, the name is the attribute, and the value is the value."
    • "Flatter maps make it so you end up writing less code."

    Related episodes:

    • Time Log series:
      • 015: Finding the Time
      • 016: When 8 - 1 = 6
      • 017: Data, at Your Service
      • 018: Did I Work Late on Tuesday?
      • 019: Dazed by Weak Weeks
      • 020: Data Dessert
    • 049: Keywords! Keywords! Keywords!

    Links:

    • Love Letter To Clojure (Part 1) - Gene Kim

    Code sample:

    ;; Player records: one nested, one with rich keys.
    
    (def players-nested
      [{:player {:id 123
                 :name "Russell"
                 :position :point-guard}
        :team {:id 432
               :name "Durham Denizens"
               :division :eastern}}
       {:player {:id 124
                 :name "Frank"
                 :position :midfield}
        :team {:id 432
               :name "Durham Denizens"
               :division :eastern}}])
    
    (def players-rich
      [{:player/id 123
        :player/name "Russell"
        :player/position :point-guard
        :team/id 432
        :team/name "Durham Denizens"
        :team/division :eastern}
       {:player/id 124
        :player/name "Frank"
        :player/position :midfield
        :team/id 432
        :team/name "Durham Denizens"
        :team/division :eastern}])
    
    
    ;; Extract player and team id, along with team name
    
    ; Nested
    (defn extract
      [player]
      (let [{:keys [player team]} player]
        {:player (select-keys player [:id])
         :team (select-keys team [:id :name])}))
    
    #_(map extract players-nested)
    ; ({:player {:id 123}, :team {:id 432, :name "Durham Denizens"}}
    ;  {:player {:id 124}, :team {:id 432, :name "Durham Denizens"}})
    
    ; Rich
    #_(map #(select-keys % [:player/id :team/id :team/name]) players-rich)
    ; ({:player/id 123, :team/id 432, :team/name "Durham Denizens"}
    ;  {:player/id 124, :team/id 432, :team/name "Durham Denizens"})
    
    
    ;; Sort by team name and then player name
    
    ; Nested
    #_(sort-by (juxt #(-> % :team :name) #(-> % :player :name)) players-nested)
    ; ({:player {:id 124, :name "Frank", :position :midfield},
    ;   :team {:id 432, :name "Durham Denizens", :division :eastern}}
    ;  {:player {:id 123, :name "Russell", :position :point-guard},
    ;   :team {:id 432, :name "Durham Denizens", :division :eastern}})
    
    ; Rich
    #_(sort-by (juxt :team/name :player/name) players-rich)
    ; ({:player/id 124,
    ;   :player/name "Frank",
    ;   :player/position :midfield,
    ;   :team/id 432,
    ;   :team/name "Durham Denizens",
    ;   :team/division :eastern}
    ;  {:player/id 123,
    ;   :player/name "Russell",
    ;   :player/position :point-guard,
    ;   :team/id 432,
    ;   :team/name "Durham Denizens",
    ;   :team/division :eastern})

    Ep 050: Parentheses! Parentheses! Parentheses! Oct 11, 2019
    Show notes

    Each week, we discuss a different topic about Clojure and functional programming.

    If you have a question you'd like us to discuss, tweet @clojuredesign, send an email to feedback@clojuredesign.club, or join the #clojuredesign-podcast channel on the Clojurians Slack.

    This week, our topic is: "Parentheses! Parentheses! Parentheses!" We defend the lowly parentheses, and discuss the benefits of having this stalwart shepherd dutifully organizing our code.

    Selected quotes:

    • "I'm converting my visual cues into audio information."
    • "Parentheses are like dust bunnies that have stacked up over time."
    • "Pounds of parentheses."
    • "The parenthesis is greatly misunderstood."
    • "Parentheses make the grammar of the language incredibly simple."
    • "I've never seen that in math, at least not in normal math."
    • "If you have 15 close parentheses, you might have to do some refactoring."
    • "Parentheses are the hugs your program needs."
    • "Peace, Love, Parentheses."

    Previous 1 5 6 7 8 9 12 Next

    Related Podcasts

    Reply All

    1

    Reply All Games & Hobbies
    Inside VR & AR

    2

    Inside VR & AR Gadgets
    Note to Self

    3

    Note to Self News
    BrainStuff

    4

    BrainStuff Natural Sciences
    This Week in Tech (Audio)

    5

    This Week in Tech (Audio) News
    Hands-On Tech (Audio)

    6

    Hands-On Tech (Audio) Technology
    footer-logo

    Contact Us

    Toll Free: 844-670-7747

    Links

    • Home
    • Top Charts
    • Networks
    • Apps
    • Independents Podcasts
    • Podcast Advertising
    • Podcast News
    • Contact Us
    • About Us
    • Analytics & Insights

    Stay Connected

      Privacy, Terms of Use & Our Code of Ethics Protecting Content Creators Copyrights