2021 Survey Results
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/
Dec 06, 2021•35 min•Ep. 57
Haskell Weekly
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.
Episodes
Monad Architecture
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
Nov 15, 2021•24 min•Ep. 56
GHC 9.2.1
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
Nov 08, 2021•28 min•Ep. 55
Loop Breaker
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
Oct 04, 2021•21 min•Ep. 54
Hash Flooding Aeson
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...
Sep 27, 2021•26 min•Ep. 53
Evoking Instances
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/
Sep 13, 2021•36 min•Ep. 52
Dependent Haskell with Vladislav Zavialov
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
Aug 23, 2021•56 min•Ep. 51
Our Tech Stack
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
Aug 16, 2021•39 min•Ep. 50
Cast Values with Witch
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
Aug 09, 2021•34 min•Ep. 49
The Voids of Haskell
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 could benefit the Haskell community. https://github.com/graninas/The-Voids-Of-Haskell/blob/9b401e33af37f991dcb3ab2eedc023661237d845/README.md
Jun 08, 2021•30 min•Ep. 48
Simple Haskell Handbook with Marco Sampellegrini
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
Jun 01, 2021•42 min•Ep. 47
Module Organization Guidelines
Should you organize modules vertically or horizontally? This week we take a look at another article by Gabriella Gonzalez, this time about organizing projects and packages. https://www.haskellforall.com/2021/05/module-organization-guidelines-for.html
May 24, 2021•26 min•Ep. 46
Avoiding Nested Errors
How can you avoid deeply nested error handling code? This week we review Gabriella Gonzalez’s trick for keeping error handling flat. https://www.haskellforall.com/2021/05/the-trick-to-avoid-deeply-nested-error.html
May 10, 2021•19 min•Ep. 45
Haskell Foundation with Andrew Boardman
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 https://joyofhaskell.com/posts/2021-02-24-why-stm.html...
May 04, 2021•54 min•Ep. 44
Default Exception Handlers
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/
Apr 19, 2021•14 min•Ep. 43
Async Exceptions
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...
Mar 29, 2021•29 min•Ep. 42
Unified Vector
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/
Mar 22, 2021•25 min•Ep. 41
Chat Wisely
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
Mar 17, 2021•47 min•Ep. 40
Haskell Wingman with Sandy Maguire
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...
Mar 08, 2021•47 min•Ep. 39
GHC 9.0.1
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/...
Feb 22, 2021•27 min•Ep. 38
Type Applications
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/
Feb 08, 2021•19 min•Ep. 37
Production Haskell with Matt Parsons
Special guest Matt Parsons talks to us about his upcoming book, Production Haskell. https://leanpub.com/production-haskell https://twitter.com/prodhaskell
Feb 01, 2021•33 min•Ep. 36
Maybe Either
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
Jan 26, 2021•28 min•Ep. 35
Production Haskell
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/
Jan 22, 2021•26 min•Ep. 34
2020 Retrospective
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
Jan 11, 2021•28 min•Ep. 33
Parser Combinators
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
Dec 14, 2020•34 min•Ep. 32
Simplify Deriving
Can Haskell’s deriving mechanism be simplified? Cody Goodman, Cameron Gera, and Taylor Fausak walk through the changes that Matt Parsons suggested. https://www.parsonsmatt.org/2020/11/10/simplifying_deriving.html
Nov 16, 2020•28 min•Ep. 31
Type Safety
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. https://lexi-lambda.github.io/blog/2020/11/01/names-are-not-type-safety/ https://www.youtube.com/watch?v=MEmRarBL9kw https://np.reddit.com/r/haskell/comments/jnwg7i/haskell_foundation_ama/...
Nov 09, 2020•24 min•Ep. 30
Bad Parts
Even well-designed languages have rough edges. Cameron Gera and Taylor Fausak review some of the bad parts of Haskell. https://www.snoyman.com/blog/2020/10/haskell-bad-parts-1 https://haskellweekly.news/survey/2020.html
Nov 02, 2020•21 min•Ep. 29
GHC 2021
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...
Oct 26, 2020•22 min•Ep. 28