Haskell Weekly

Follow Haskell Weekly
Share on
Copy link to clipboard

Haskell Weekly covers the Haskell progamming language. Listen to professional software developers discuss using functional programming to solve real-world business problems. Each episode uses a conversational two-host format and runs for about 15 minutes.

Taylor Fausak


    • Dec 6, 2021 LATEST EPISODE
    • every other week NEW EPISODES
    • 24m AVG DURATION
    • 57 EPISODES


    Search for episodes from Haskell Weekly with a specific topic:

    Latest episodes from Haskell Weekly

    2021 Survey Results

    Play Episode Listen Later Dec 6, 2021 34:57


    Thanks to everyone who filled out the 2021 State of Haskell Survey! This week Cameron and Taylor review the results. https://taylor.fausak.me/2021/11/16/haskell-survey-results/

    Monad Architecture

    Play Episode Listen Later Nov 15, 2021 23:35


    This week Cameron and Taylor answer our first listener question: How should you structure large applications? We compare ReaderT with MTL along with other approaches. https://join.slack.com/t/haskell-foundation/shared_invite/zt-mjh76fw0-CEjg2NbyVE8rVQDvR~0F4A

    GHC 9.2.1

    Play Episode Listen Later Nov 8, 2021 27:32


    We're back! After a month off, Cameron and Taylor get together to talk about what's new in the Haskell world. https://www.haskell.org/ghc/blog/20211029-ghc-9.2.1-released.html https://haskellweekly.news/survey/2021.html

    Loop Breaker

    Play Episode Listen Later Oct 4, 2021 21:11


    Cameron Gera and Taylor Fausak discuss Drew Olson's adventures in looping. What should you do if you want to loop forever, but break out of the loop early sometimes? https://blog.drewolson.org/adventures-in-looping

    Hash Flooding Aeson

    Play Episode Listen Later Sep 27, 2021 26:13


    Special guest Tom Sydney Kerckhove talks with Taylor Fausak about a denial of service vulnerability in Aeson, a Haskell library for JSON. https://cs-syd.eu/posts/2021-09-11-json-vulnerability https://hackage.haskell.org/package/sydtest-0.4.0.0 https://hackage.haskell.org/package/genvalidity-0.11.0.2 https://hackage.haskell.org/package/yamlparse-applicative-0.2.0.0

    Evoking Instances

    Play Episode Listen Later Sep 13, 2021 36:20


    Taylor Fausak talks with Cameron Gera about Evoke, Taylor's latest GHC plugin for deriving instances without generics or Template Haskell. https://taylor.fausak.me/2021/09/10/evoke/

    Dependent Haskell with Vladislav Zavialov

    Play Episode Listen Later Aug 23, 2021 56:15


    Curious about dependent types? Special guest Vladislav Zavialov from Serokell breaks it down for us. We discuss comparisons to refinement types, sigma and pi types, interactions with linear types, and much more! https://serokell.io/blog/developing-ghc-for-a-living https://twitter.com/int_index

    Our Tech Stack

    Play Episode Listen Later Aug 16, 2021 39:03


    Stack, HLint, and Brittany, oh my! Cameron Gera and Taylor Fausak go on a deep dive into the ACI Learning tech stack. https://www.acilearning.com

    Cast Values with Witch

    Play Episode Listen Later Aug 9, 2021 33:37


    Back from summer break, Cameron Gera discusses the Witch library with it's author, Taylor Fausak. Learn about the many motivations behind this simple library for converting values between various types. https://taylor.fausak.me/2021/07/13/witch/ https://hackage.haskell.org/package/say-my-name-0.1.0.0

    The Voids of Haskell

    Play Episode Listen Later Jun 8, 2021 30:12


    There's a lot to like about Haskell, but what is it missing? We explore Alexander Granin's post where he suggests some topics for books that https://github.com/graninas/The-Voids-Of-Haskell/blob/9b401e33af37f991dcb3ab2eedc023661237d845/README.md

    Simple Haskell Handbook with Marco Sampellegrini

    Play Episode Listen Later Jun 1, 2021 42:27


    Special guest Marco Sampellegrini talks with us about his recent book, The Simple Haskell Handbook. The book describes a project driven approach to Haskell development, using a continuous integration server as a motivating example. https://leanpub.com/simple-haskell-book

    Module Organization Guidelines

    Play Episode Listen Later May 24, 2021 26:13


    Should you organize modules vertically or horizontally? This week we take a look at another article by Gabriel Gonzalez, this time about organizing projects and packages. https://www.haskellforall.com/2021/05/module-organization-guidelines-for.html

    Avoiding Nested Errors

    Play Episode Listen Later May 10, 2021 18:55


    How can you avoid deeply nested error handling code? This week we review Gabriel Gonzalez’s trick for keeping error handling flat. https://www.haskellforall.com/2021/05/the-trick-to-avoid-deeply-nested-error.html

    Haskell Foundation with Andrew Boardman

    Play Episode Listen Later May 4, 2021 53:45


    Curious about the Haskell Foundation? This week we interview Andrew Boardman, its Executive Director. He explains the Foundation’s purpose and how you can help. https://haskell.foundation https://fpchat-invite.herokuapp.com https://funprog.zulipchat.com/login/ https://wiki.haskell.org/IRC_channel https://discourse.haskell.org https://twitter.com/myShoggoth https://myshoggoth.com

    Default Exception Handlers

    Play Episode Listen Later Apr 19, 2021 13:35


    What happens to exceptions when you don’t explicitly handle them? This week we review Taylor’s blog post about default exception handlers. https://taylor.fausak.me/2021/04/03/default-exception-handler-in-haskell/

    Async Exceptions

    Play Episode Listen Later Mar 29, 2021 29:15


    Special guest Cody Goodman walks us through an interesting PostgreSQL bug. Handling async exceptions properly is trickier than you might expect! https://www.parsonsmatt.org/2021/03/17/async_control_flow.html https://github.com/codygman/tech-roam/blob/master/20210326113249-haskell_persistent_issues_postgres_connections_are_returned_to_pool_too_quickly.org

    Unified Vector

    Play Episode Listen Later Mar 22, 2021 24:36


    Byte string, text, and vector, oh my! This week we review Michael Snoyman’s proposal to unify vector-like types. Learn about boxed versus unboxed values, pinned versus unpinned memory, and more. https://www.snoyman.com/blog/2021/04/haskell-base-proposal/

    Chat Wisely

    Play Episode Listen Later Mar 17, 2021 46:39


    Special guests Michael Litchard and Brian Hurt talk with us about their new social networking site Chat Wisely. We hear about their experience using Haskell not only on the backend but also on the frontend through GHCJS. https://www.chatwisely.com https://www.patreon.com/chatwisely

    Haskell Wingman with Sandy Maguire

    Play Episode Listen Later Mar 8, 2021 47:01


    Special guest Sandy Maguire talks with us about using Haskell Wingman for program synthesis, designing bulletproof abstractions with algebra, wrangling type level programming in Haskell, and managing effects with his Polysemy library. https://www.patreon.com/wingman_for_haskell https://leanpub.com/algebra-driven-design https://leanpub.com/thinking-with-types https://github.com/polysemy-research/polysemy https://reasonablypolymorphic.com https://sandymaguire.me

    GHC 9.0.1

    Play Episode Listen Later Feb 22, 2021 27:18


    Linear types finally landed in GHC 9.0.1! We talk through what that means along with other news from the Haskell Foundation and Tweag. https://discourse.haskell.org/t/haskell-foundation-executive-director-and-chief-technology-officer/1861 https://discourse.haskell.org/t/ghc-8-10-4-released/1847 https://discourse.haskell.org/t/ghc-9-0-1-released/1840 https://www.tweag.io/blog/2021-02-10-linear-base/

    Type Applications

    Play Episode Listen Later Feb 8, 2021 18:33


    Come @ me bro! In this episode we review Zac Wood’s post about the type applications language extension. https://zacwood.me/posts/haskell-type-application/

    Production Haskell with Matt Parsons

    Play Episode Listen Later Feb 1, 2021 32:53


    Special guest Matt Parsons talks to us about his upcoming book, Production Haskell. https://leanpub.com/production-haskell https://twitter.com/prodhaskell

    Maybe Either

    Play Episode Listen Later Jan 26, 2021 28:12


    Is Maybe problematic? Well, maybe. Robert Peszek thinks that Maybe is overused. Cameron Gera and Taylor Fausak break it down and consider alternatives. https://rpeszek.github.io/posts/2021-01-17-maybe-overuse.html

    Production Haskell

    Play Episode Listen Later Jan 22, 2021 26:04


    Christian Charukiewicz at Foxhound Systems wrote a list of reasons to prefer Haskell for building production systems. Cameron Gera and Taylor Fausak review the list and share their experience at ITProTV. https://www.foxhound.systems/blog/why-haskell-for-production/

    2020 Retrospective

    Play Episode Listen Later Jan 11, 2021 27:32


    Using Adam Wespiser’s blog post as a jumping off point, Cameron Gera and Taylor Fausak look back on a year of Haskell. https://wespiser.com/posts/2021-01-03-Lessons-Learned-From-A-Year-Of-Haskell.html

    Parser Combinators

    Play Episode Listen Later Dec 14, 2020 33:56


    Are you curious about how Parsec is implemented behind the scenes? Cameron Gera and Taylor Fausak follow Antoine Leblanc’s walkthrough. https://hasura.io/blog/parser-combinators-walkthrough/ http://dev.stephendiehl.com/fun/002_parsers.html

    Simplify Deriving

    Play Episode Listen Later Nov 16, 2020 27:32


    Can Haskell’s deriving mechanism be simplified? Cody Goodman, Cameron Gera, and Taylor Fausak walk through the changes that Matt Parsons suggested. -

    Type Safety

    Play Episode Listen Later Nov 9, 2020 24:25


    Newtypes let you give things names, but is that type safety? Andres Schmois, Cameron Gera, and Taylor Fausak explore a blog post by Alexis King. - - -

    Bad Parts

    Play Episode Listen Later Nov 2, 2020 21:12


    Even well-designed languages have rough edges. Cameron Gera and Taylor Fausak review some of the bad parts of Haskell. - -

    GHC 2021

    Play Episode Listen Later Oct 26, 2020 22:16


    Does the idea of -XGHC2021 excite you? Cameron Gera and Taylor Fausak work through this proposed set of language extensions. - https://np.reddit.com/r/haskell/comments/je1t82/does_the_idea_of_xghc2021_excite_you/ - https://github.com/ghc-proposals/ghc-proposals/pull/372 - https://hacktoberfest.digitalocean.com - https://github.com/kowainik/learn4haskell

    Interview Questions

    Play Episode Listen Later Oct 19, 2020 31:33


    Learn how to answer common technical interview questions with Haskell. Cameron Gera and Taylor Fausak discuss Chris Penner's blog post. - https://chrispenner.ca/posts/interview - https://hacktoberfest.digitalocean.com - https://github.com/kowainik/learn4haskell

    Recursive Monoids

    Play Episode Listen Later Oct 13, 2020 18:51


    Sara Lichtenstein, Cameron Gera, and Taylor Fausak get recursively drunk on semigroups and monoids. - https://dev.to/sshine/getting-recursively-drunk-with-monoids-2jek

    Strategic Deriving

    Play Episode Listen Later Oct 8, 2020 33:05


    Cameron Gera and Taylor Fausak discuss the pros and cons of various deriving strategies.

    Haskell Survey

    Play Episode Listen Later Nov 8, 2019 7:57


    Jose Silvestri and Cameron Gera go over the 2019 State of Haskell Survey and encourage you to fill it out.

    Functional Reactive Programming

    Play Episode Listen Later Oct 30, 2019 20:18


    Jose Silvestri and Dustin Segers give a whirlwind tour of FRP, exploring what it is and why you might want to use it.

    Refactoring Yahtzee

    Play Episode Listen Later Oct 14, 2019 31:41


    Cameron Gera and Taylor Fausak discuss using types to guide refactoring toward better design.

    Event Log

    Play Episode Listen Later Oct 7, 2019 14:46


    Cody Goodman and Taylor Fausak explore the event log that GHC can produce when compiling or running.

    ghc event log
    Polymorphic Rounding

    Play Episode Listen Later Sep 13, 2019 15:49


    Sara Lichtenstein and Taylor Fausak discuss converting between numeric types with polymorphic functions.

    Profunctor Optics

    Play Episode Listen Later Aug 20, 2019 18:56


    Cameron Gera and Andres Schmois talk about practical uses for profunctor lenses and optics.

    Inventing Monads

    Play Episode Listen Later Aug 13, 2019 16:41


    Cody Goodman and Taylor Fausak walk through inventing monads from scratch in JavaScript.

    Haskell Phrasebook

    Play Episode Listen Later Aug 6, 2019 13:56


    Sara Lichtenstein and Andres Schmois discuss quickly learning Haskell by studying annotated examples.

    Game Development

    Play Episode Listen Later Jul 30, 2019 12:54


    Dustin Segers and Cody Goodman talk about developing video games using Haskell.

    Lazy Sharing

    Play Episode Listen Later Jul 23, 2019 18:13


    Cameron Gera and Taylor Fausak talk about how function calls are evaluated in Haskell with regards to non-strictness.

    Refinement Types

    Play Episode Listen Later Jul 16, 2019 15:18


    Andres Schmois and Cody Goodman talk about using the Refined library to turn runtime checks into types.

    Why Haskell?

    Play Episode Listen Later Jun 10, 2019 25:08


    Cameron Gera and Taylor Fausak talk about why the Semantic team at GitHub decided to use Haskell.

    Formatting Code

    Play Episode Listen Later Jun 3, 2019 16:37


    Dustin Segers and Cody Goodman talk about formatting Haskell source code with automated tools like Ormolu.

    Profiling Performance

    Play Episode Listen Later May 27, 2019 19:12


    Sara Lichtenstein and Taylor Fausak talk about improving the performance of Haskell programs by profiling them.

    Functional Architecture

    Play Episode Listen Later May 20, 2019 16:37


    Cameron Gera and Taylor Fausak talk about how Haskell encourages you to use the ports and adapters architecture.

    Improving Haskell

    Play Episode Listen Later May 6, 2019 21:52


    Jason Fry and Cameron Gera talk about four small ways to improve Haskell as a language.

    Best Practices

    Play Episode Listen Later Apr 29, 2019 14:20


    Cameron Gera and Cody Goodman talk about enforcing best practices with HLint and refactoring.

    Parser Combinators

    Play Episode Listen Later Apr 22, 2019 17:29


    Cameron Gera and Taylor Fausak talk about how regular expressions compare to parser combinators in Haskell.

    Claim Haskell Weekly

    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