Haskell Weekly - podcast cover

Haskell Weekly

Taylor Fausakhaskellweekly.news
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

Interview Questions

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

Oct 19, 202032 minEp. 27

Recursive Monoids

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

Oct 13, 202019 minEp. 26

Strategic Deriving

Cameron Gera and Taylor Fausak discuss the pros and cons of various deriving strategies. https://kowainik.github.io/posts/deriving https://hacktoberfest.digitalocean.com https://dev.to/tfausak/how-to-define-json-instances-quickly-5ei7 https://www.parsonsmatt.org/2019/11/27/keeping_compilation_fast.html https://www.youtube.com/watch?v=pwnrfREbhWY...

Oct 08, 202033 minEp. 25

Haskell Survey

Jose Silvestri and Cameron Gera go over the 2019 State of Haskell Survey and encourage you to fill it out. https://haskellweekly.news/survey/2019.html https://taylor.fausak.me/2018/11/18/2018-state-of-haskell-survey-results/ https://taylor.fausak.me/2017/11/15/2017-state-of-haskell-survey-results/...

Nov 08, 20198 minEp. 24

Functional Reactive Programming

Jose Silvestri and Dustin Segers give a whirlwind tour of FRP, exploring what it is and why you might want to use it. https://begriffs.com/posts/2015-07-22-essence-of-frp.html https://www.seas.upenn.edu/~cis194/fall16/lectures/11-frp.html https://apfelmus.nfshost.com/blog/2011/05/06-frp-why-functors.html https://stackoverflow.com/questions/1028250/what-is-functional-reactive-programming https://wiki.haskell.org/FRP_explanation_using_reactive-banana https://wiki.haskell.org/Reactive-banana/Exampl...

Oct 30, 201920 minEp. 23

Refactoring Yahtzee

Cameron Gera and Taylor Fausak discuss using types to guide refactoring toward better design. http://h2.jaguarpaw.co.uk/posts/good-design-and-type-safety-in-yahtzee/

Oct 14, 201932 minEp. 22

Event Log

Cody Goodman and Taylor Fausak explore the event log that GHC can produce when compiling or running. https://www.well-typed.com/blog/2019/09/eventful-ghc/

Oct 07, 201915 minEp. 21

Polymorphic Rounding

Sara Lichtenstein and Taylor Fausak discuss converting between numeric types with polymorphic functions. https://typeclasses.com/featured/rounding

Sep 13, 201916 minEp. 20

Profunctor Optics

Cameron Gera and Andres Schmois talk about practical uses for profunctor lenses and optics. https://thomashoneyman.com/articles/practical-profunctor-lenses-optics/

Aug 20, 201919 minEp. 19

Inventing Monads

Cody Goodman and Taylor Fausak walk through inventing monads from scratch in JavaScript. https://blog.kabir.sh/posts/inventing-monads.html

Aug 13, 201917 minEp. 18

Haskell Phrasebook

Sara Lichtenstein and Andres Schmois discuss quickly learning Haskell by studying annotated examples. https://typeclasses.com/news/2019-07-phrasebook

Aug 06, 201914 minEp. 17

Game Development

Dustin Segers and Cody Goodman talk about developing video games using Haskell. https://linearity.itch.io/peoplemon http://jxv.io/blog/2018-02-28-A-Game-in-Haskell.html https://www.indiedb.com/games/nikki-and-the-robots/downloads https://github.com/FailWhaleBrigade/water-wars https://www.allureofthestars.com/ https://np.reddit.com/r/haskellgamedev https://mmhaskell.com/blog/2019/3/25/making-a-glossy-game-part-1 https://ocharles.org.uk/posts/2013-12-10-24-days-of-hackage-gloss.html http://andrew....

Jul 30, 201913 minEp. 16

Lazy Sharing

Cameron Gera and Taylor Fausak talk about how function calls are evaluated in Haskell with regards to non-strictness. https://treszkai.github.io/2019/07/13/haskell-eval

Jul 23, 201918 minEp. 15

Refinement Types

Andres Schmois and Cody Goodman talk about using the Refined library to turn runtime checks into types. https://danieljharvey.github.io/posts/2019-07-05-refined-types.html

Jul 16, 201915 minEp. 14

Why Haskell?

Cameron Gera and Taylor Fausak talk about why the Semantic team at GitHub decided to use Haskell. https://github.com/github/semantic/blob/eaf13783838861fe5eb6cd46d59354774a8eb88d/docs/why-haskell.md

Jun 10, 201925 minEp. 13

Formatting Code

Dustin Segers and Cody Goodman talk about formatting Haskell source code with automated tools like Ormolu. https://www.tweag.io/posts/2019-05-27-ormolu.html

Jun 03, 201917 minEp. 12

Profiling Performance

Sara Lichtenstein and Taylor Fausak talk about improving the performance of Haskell programs by profiling them. https://blog.jez.io/profiling-in-haskell/

May 27, 201919 minEp. 11

Functional Architecture

Cameron Gera and Taylor Fausak talk about how Haskell encourages you to use the ports and adapters architecture. https://blog.ploeh.dk/2016/03/18/functional-architecture-is-ports-and-adapters/

May 20, 201917 minEp. 10

Improving Haskell

Jason Fry and Cameron Gera talk about four small ways to improve Haskell as a language. https://medium.com/daml-driven/four-tweaks-to-improve-haskell-b1de9c87f816

May 06, 201922 minEp. 9

Best Practices

Cameron Gera and Cody Goodman talk about enforcing best practices with HLint and refactoring. https://medium.com/co-star-engineering/continuous-improvement-with-hlint-code-smells-e490886558a1

Apr 29, 201914 minEp. 8

Parser Combinators

Cameron Gera and Taylor Fausak talk about how regular expressions compare to parser combinators in Haskell. https://williamyaoh.com/posts/2019-04-11-cheatsheet-to-regexes-in-haskell.html

Apr 22, 201917 minEp. 7

Fast Feedback

Jason Fry and Taylor Fausak talk about getting fast feedback when developing Haskell by using ghcid. https://functor.tokyo/blog/2019-04-07-ghcid-for-web-app-dev

Apr 15, 201919 minEp. 6

Build Tools

Cameron Gera and Taylor Fausak talk about build tools in Haskell, including Stack and Cabal. https://sakshamsharma.com/2018/03/haskell-proj-struct/

Apr 08, 201915 minEp. 5

Boolean Blindness

Dustin Segers and Taylor Fausak talk about avoiding boolean blindness by using custom types. https://runtimeverification.com/blog/code-smell-boolean-blindness/

Apr 01, 201916 minEp. 4

Frontend Languages

Jason Fry and Taylor Fausak compare frontend and backend languages, including PureScript and Elm. https://www.parsonsmatt.org/2015/10/03/elm_vs_purescript.html

Mar 25, 201924 minEp. 3

Upgrading Elm

Sara Lichtenstein and Taylor Fausak talk about the good and bad of upgrading from Elm 0.18 to 0.19. https://engineering.itpro.tv/2019/03/01/upgrading-elm-to-v19/

Mar 18, 201915 minEp. 2

Handling Exceptions

Cody Goodman and Taylor Fausak talk about handling errors in Haskell by using exceptions. https://markkarpov.com/tutorial/exceptions.html

Mar 11, 201910 minEp. 1