はてなブックマーク

This is a story about how some bad API design on my part caused some ugly race conditions that were very tricky to break down. I’m writing this story as a word of warning to others! The code itself was written in Haskell, but the lessons apply to anyone working with Unix-style processes. Introducing typed-process I maintain both the process library in Haskell, which is the standard way of launchin

We’re big fans of safety-focused languages at FP Complete. As our previous blog post comparing Rust and Haskell made clear, we think both of these are great languages. A recurring theme we have for both internal and client projects is: which language should we use? The general guidelines in that blog post apply: If there’s a specific requirement (e.g., hard realtime) that prefers avoiding garbage

In the past few months, and in particular in the past two weeks, I’ve gotten a number of people asking me the question: Is Rust a functional programming language? This makes sense: I’m a big advocate of functional programming, I work at a company with FP in its name, my primary programming language is Haskell, and yet I use and enjoy Rust. So is Rust consistent with everything else in my FP-centri

One fantastic aspect of Haskell is that it offers various tools that allow different development workflows. In this blog post, we are going to focus on four different workflows to develop Haskell. These are techniques that the FP Complete team themselves use regularly and we wanted to share them with our readers. Auto-compile on save via stack --file-watch This workflow is the simplest one you can

Since I seem to be a one-trick pony, I decided to write yet again to compare streaming data in Haskell and Rust. This was inspired by a cool post I saw on Reddit about converting characters in the Latin alphabet into look-alikes in the Cyrilic alphabet. When reviewing the original code, I noticed that it was reading the full contents of the input into memory. Since I’m somewhat obsessed with strea

Deploying rust with Docker and Kubernetes Hello! My name is Chris Allen and I’m going to use a tiny Rust app to demonstrate deploying Rust with Docker and Kubernetes. Rust and Haskell apps are deployed in similar ways. Much of this is because the compilers for both languages generate native binary executables. Here are the technologies we’ll be using and why: The programming language will be Rust.

I’m pleased to announce the release of a Haskell library for connecting to SQL Server databases via ODBC. Features The library is very simple, but what it does support should be high quality: Correct Unicode handling. All text is handled through the Text type. The test suite randomly generates Unicode to send to the server and query back in a roundtrip. A very simple API: simply connect, execute o

This is a short and non-technical blog post demonstrating why the Haskell programming language is a good choice for building cryptocurrencies. Cryptocurrencies are not your average software Cryptocurrencies are different from other programs in one key way: One mistake in the code can result in the instantaneous loss of all value of all users. This is not often the case with other software. In conv

We launched our monthly webinar series on Wednesday, April 11th with our first webinar on How to Handle Asynchronous exceptions in Haskell. This webinar was the first in what will be a monthly series covering topics in Haskell Programming, DevOps, Cloud Computing, Cryptocurrencies, FinTech, Medical Device Software, DataOps, and all the other great things we do. Webinar series launch is a huge succ

One aspect of Haskell that many new users find difficult to get a handle on is operators. Unlike many other languages, Haskell gives a lot of flexibility to developers to define custom operators. This can lead to shorter, more elegant code in many cases. For example, compare these three equivalent pieces of code: v1 = mappend (mappend "hello " "there ") "world" v2 = "hello " `mappend` "there " `ma

I was recently doing a minor cleanup of a Haskell codebase. I started off with some code that looked like this: runConduitRes $ sourceFile fp .| someConsumer This code uses Conduit to stream the contents of a file into a consumer function, and ResourceT to ensure that the code is exception safe (the file is closed regardless of exceptions). For various reasons (not relevant to our discussion now),

Haskell is—perhaps infamously—a lazy language. The basic idea of laziness is pretty easy to sum up in one sentence: values are only computed when they’re needed. But the implications of this are more subtle. In particular, it’s important to understand some crucial topics if you want to write memory- and time-efficient code: Weak head normal form (WHNF) versus normal form (NF) How to use the seq an

For the past few years, Francesco Mazzoli and I have discussed issues around monad transformers—and the need to run their actions in IO—on a fairly regular basis. I wrote the monad-unlift library a while ago to try and address these concerns. But recent work I did in Stack on the extensible snapshots branch demonstrated some of the shortcomings Francesco had mentioned to me. This is also in line w

Streaming data is a problem domain I’ve played with a lot in Haskell. In Haskell, the closest we come to built-in streaming data support is laziness-by-default, which doesn’t fully capture streaming data. (I’m not going into those details today, but if you want to understand this better, there’s plenty of information in the conduit tutorial.) Real streaming data is handled at the library level in

This is a debugging story told completely out of order. In order to understand the ultimate bug, why it seemed to occur arbitrarily, and the ultimate resolution, there’s lots of backstory to cover. If you’re already deeply familiar with the inner workings of the monad-control package, you can probably look at a demonstration of the bad instance and move on. Otherwise, prepare for a fun ride! As us

This blog post came out of two unrelated sets of questions I received last week about usage of the resourcet library. For those unfamiliar with it, the library is often used in combination with the Conduit streaming data library; basically every conduit tutorial will quickly jump into usage of the resourcet library. Instead of just teaching you how to use the library, this post will demonstrate wh

Often times I’ll receive or read questions online about “design patterns” in Haskell. A common response is that Haskell doesn’t have them. What many languages address via patterns, in Haskell we address via language features (like built-in immutability, lambdas, laziness, etc). However, I believe there is still room for some high-level guidance on structuring programs, which I’ll loosely refer to

The exceptions package provides three typeclasses for generalizing exception handling to monads beyond IO: MonadThrow is for monads which allow reporting an exception MonadCatch is for monads which also allow catching a throw exception MonadMask is for monads which also allow safely acquiring resources in the presence of asynchronous exceptions For reference, these are defined as: class Monad m =>

Applied Haskell is a commercial training program focusing on teaching intermediate Haskell. The goal is to help someone move from knowing Haskell basics to being able to write commercial software, with enough knowledge to pick up any new skills needed on demand. If you're new to Haskell, please check out our learning page for introductory material. The content below is freely available. If you're

Many common programming languages today eschew manual memory management in preference to garbage collection. While the former certainly has its place in certain use cases, I believe the majority of application development today occurs in garbage collected languages, and for good reason. Garbage collection moves responsibility for many memory issues from the developer into the language’s runtime, m