Haskell Weekly

Issue 76

Welcome to another issue of Haskell Weekly! Haskell is a safe, purely functional programming language with a fast, concurrent 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

  • scalendar: Time management in Haskell

    This is the kind of problem that scalendar approaches — namely, managing availability over time for a set of identifiers (which represent resources), where the availability varies according to the state of a calendar that is affected by the history of reservations previously performed.

  • Comparing Persistent with Ecto and ActiveRecord

    I saw this article comparing Ecto and ActiveRecord. I thought I would track alongside that post and show what the equivalent code looks like if you’re using the Persistent Haskell library.

  • Why do our programs need to read input and write output?

    I wrote this post to challenge basic assumptions that people make about software architecture, which is why I chose a deliberately provocative title. You might not agree with all the points that I am about to make, but I do hope that this post changes the way that you think about programming.

  • Performance debugging in Aeson

    Ideally, whether we are using Template Haskell or Generics, we would like automatically derived code to be as fast as code we could have written and optimized manually. To understand what it takes to achieve such a result, I’ve recently started to work on the performance of Aeson, a JSON library in Haskell.

  • Tool subsumption and silver bullets

    We gain some useful things when we have referential transparency. And what do we lose? When I started doing functional programming, I assumed there must be some trade-offs, because trade-offs in programming are so common.

  • Using Servant to orchestrate LXD containers

    This blog post explains how the Servant libraries are used to create a non-trivial type-safe HTTP/WebSockets client and discusses the efforts involved.

  • Serve it up with Servant

    We’ll construct our API using the Servant library. Servant involves some advanced type level constructs, so there’s a lot to wrap your head around. There are definitely simpler approaches to HTTP servers than what Servant uses. But I’ve found that the power Servant gives us is well worth the effort.

  • Writing a concatenative programming language

    Yes, this is a yet another “write you a language”. But this one is a little bit different. First, the language I’m going to implement is rather different from languages you used to see in such tutorials. Second, I have little experience in creating programming languages, so a lot of things will be new to me as well.

  • Functor-oriented programming

    With functor oriented programming, one divides data structures into layers of functors that, when composed together, form the data structures that your program operates on. Instead of writing transformations between data structures, one writes natural transformations between functors.

  • if-then-else, case expressions, and guards! Oh my!

    Haskell is quite a bit different when it comes to control structures for directing your program flow. In this post, I want to focus on the difference between if-then-else, case expressions, and guards.

Jobs

  • Haskell Full Stack Developer (ad)

    We need someone with a strong Haskell background to help maintain and develop new features across our PostgreSQL-Haskell-React stack. We have a stable backend written in Haskell, that interfaces with PostgreSQL using hpqtypes, with a dash of Java for manipulating PDFs. Scrive is the Nordic market-leading provider of electronic signatures.

In brief

Package of the week

This week’s package of the week is hasql, an efficient PostgreSQL driver and a flexible mapping API.

Call for participation

Events