Haskell Weekly

Issue 71

Welcome to another issue of Haskell Weekly! Haskell is a safe, compiled, purely functional programming language with a fast, concurrent, garbage-collected runtime. This is a weekly summary of what’s going on in its community.

Want to see something featured in Haskell Weekly? We love contributions! Tweet us at @HaskellWeekly or open a pull request.

Featured

  • Let’s make a GTK video player with Haskell

    We remade the application using the software libraries GTK+ and GStreamer. By using GTK+ and GStreamer, the application remains as portable as the Electron version. Movie Monad can now handle large video files and comes with all of the standard controls one would expect.

  • Monads, monoids, and categories

    There is no good place to end a book on category theory. There’s always more to learn. Category theory is a vast subject. At the same time, it’s obvious that the same themes, concepts, and patterns keep showing up over and over again.

  • Tracking performance over the entire software lifecyle

    In this post I’ll show you how to see the performance of your software project improve over the entire lifetime of the project. For that, you’ll need to systematically track and store benchmark results over time.

  • Combining Brick and Haskeline

    I started to look for alternatives to rlwrap and settled on Brick for handling the terminal user interface and Haskeline for providing the command-line functionality. However, Haskeline needed some coaxing to play nice with Brick.

  • Modeling music

    Inspired by my recent forays into learning more mathematics, I’ve had an (obvious) insight into how to learn things, and that’s to model them in systems I already understand. I’m pretty good at functional programming, so it seemed like a pretty reasonable approach.

  • Visualizing graphs in Haskell

    Dependency graphs are everywhere in computing. This article will show how you how to: Construct a graph by reading folders and files from disk; Render the graph into a .dot file; Render the .dot file into an image.

  • Static binaries for Haskell: A convoluted approach

    Today’s post isn’t about how easy it is to do this with Go, however, it’s actually about how easy it was (or wasn’t, I’ll let you decide) to do this with Haskell.

  • Overcoming the record problem

    Records are, morally speaking, maps from strings to values, so let’s just do that. We’re going to dig into the highly unsafe and somewhat hilarious record library I wrote. Along the way, we’re going to learn about some neat type level tricks.

    Editor’s note: Press s to view speaker notes.

  • Type level merge sort

    I guessed that the current type level insertion sort (which is O(n^2) in worst case complexity) was at fault. This turned out to be wrong, but I still implemented a more efficient merge sort at type level and would like to share the journey as it was quite fun.

  • How the list monad helped me better understand NP time complexity

    This short post will show how a basic understanding of the list monad helped me (and can therefore help you as well) building an intuition on how a non-deterministic Turing machine behaves, and how you can get a feel of how it would be to program one such computer, thanks to Haskell.

Jobs

Sadly we aren’t currently aware of any Haskell job openings. Are you looking to hire a Haskell developer? If so, consider advertising with us!

In brief

Package of the week

This week’s package of the week is Dhall, an explicitly typed configuration language that is not Turing complete. Despite being Turing incomplete, Dhall is a real programming language with a type-checker and evaluator.

Call for participation

Events