162 episodes

An off-the-cuff stream of Functional Programming ideas, skills, patterns, and news from Functional Programming expert Eric Normand.

Thoughts on Functional Programming Podcast by Eric Normand Eric Normand

    • How To

An off-the-cuff stream of Functional Programming ideas, skills, patterns, and news from Functional Programming expert Eric Normand.

    Lisp: A language for stratified design

    Lisp: A language for stratified design

    In this first episode of season 3, we analyze a great paper called Lisp: A language for stratified design.

    • 1 hr
    Year-end update 2019

    Year-end update 2019

    I'm taking a break to retool for Season 3, which will start in the new year. I also give an update on Grokking Simplicity. I am working on Chapter 7.

    • 12 min
    Are monads practical?

    Are monads practical?

    Bruno Ribeiro asked a great question about the practical uses of monads. Are they useful? Why are they used so much in Haskell? In this episode, we briefly go over the history of monads in Haskell and how they allow you to do imperative programming in a pure functional language.

    • 22 min
    Where does structural similarity come from?

    Where does structural similarity come from?

    In a recent episode, I said structural similarity comes from the algebraic properties of the relationships between things. But that's not the case. Rotislav mentioned in the comments that it actually comes from the structure in the relationships. I explore that idea in this episode.

    • 9 min
    Do you need immutability for functional programming?

    Do you need immutability for functional programming?

    Of course immutable data structures are great, but are they necessary for FP? Short answer is: no. There's a lot of functional ideas and perspectives that can be applied even if you don't have them. And you can always make things immutable through discipline. In this episode, we explore those two ideas.

    • 10 min
    Algebra is about composition

    Algebra is about composition

    When we look at the definitions of algebraic properties, we often see that we are defining how things compose. This is one of the main advantages of using algebraic properties to constrain our operations. If we define how they should compose before we implement them (as a unit test, for instance) we can guarantee that things will compose.

    • 9 min

Customer Reviews

Austin D. Davis ,

A good introduction to FP so far

Coming from an imperative/OOP background in JavaScript and C++, I always found function programming to be completely foreign, both in its paradigm and its terminology. This podcast has helped me bridge some of the gaps in my mind.

To be honest, I had to do a lot of reading and watching videos about basic category/type theory in order to really understand what was going on. I’m not sure there is any way around that. It’s difficult to approach if you don’t have a strong foundation in math.

However, Eric does a good job of explaining some fundamental concepts in a way I could easily comprehend. Listen to this if you want to bridge your gap knowledge gap and step into the world of FP.

newswim-on-twitter ,

Dig it

I really like the format and topics Eric tends to extrapolate on. Nice small pieces of insight from a really talented software engineer. Thanks!!

autotopism ,

Inaccurate but good pedagogy

The positives are that this podcasts is presented with extraordinary attention to good teaching— modest pace, repetition, stick to one topic, and assignments.

The negatives however include inaccurate information, e.g. the dialog confuses associativity commutativity and idempotence and fails to observe for the listener when certain claims are the result of theses effects in concrete not individually. E.g. most of the claims on commutativity fail if the operation is not also associative.

Perhaps more concerning is that the lesson focus on saying a word and describe an example of an abstraction it represents. But they do not add any thing new. E.g. it is claimed at the start that the listener will know how to make things have some abstraction when in fact the lesson given is to observe something in your code base already has a behavior and then label it that way. There is no guidance to pull in abstraction from well studied and optimized libraries which is where the power of these observations lives.

Frankly time is best spent listening to experts however tough they present there topics. But perhaps this will improve.

Top Podcasts In How To

Listeners Also Subscribed To