Beyond agentic coding
I'm generally pretty pro-AI with one major exception: agentic coding. My consistent impression is that agentic coding does not actually improve productivity and deteriorates the user's comfort and familiarity with the codebase. I formed that impression from: my own personal experiences Every time I use agentic coding tools I'm consistently unimpressed with the quality of the results. my experience
Introductory resources to type theory for language implementers
This post briefly tours resources that helped introduce me to type theory, because I’m frequently asked by others for resources on this subject (even though I never had a formal education in type theory). Specifically, these resources will focus more on how to implement a type checker or type inference algorithm. Also, my post will be biased against books, because I don’t tend to learn well from r
Applicatives should usually implement Semigroup and Monoid
The gist of this post is that any type constructor F that implements Applicative: instance Applicative F where … … should usually also implement the following Semigroup and Monoid instances: instance Semigroup a => Semigroup (F a) where (<>) = liftA2 (<>) instance Monoid a => Monoid (F a) where mempty = pure mempty … which one can also derive using the Data.Monoid.Ap type, which was created for th
The "return a command" trick
This post illustrates a trick that I’ve taught a few times to minimize the “change surface” of a Haskell program. By “change surface” I mean the number of places Haskell code needs to be updated when adding a new feature. The motivation I’ll motivate the trick through the following example code for a simple REPL: import Control.Applicative ((<|>)) import Data.Void (Void) import Text.Megaparsec (Pa
Optics are monoids
This post documents my favorite lens trick of all time. Also, this trick works for any optics package based on van Laarhoven lenses, like lens-family-core or microlens. This post assumes some familiarity with lenses, so if you are new to lenses then you might want to first read: Control.Lens.Tutorial The title is slightly misleading and the precise statement is that Folds are Monoids, and all of t
The golden rule of software quality
This post summarizes a rule of thumb that I commonly cite in software quality discussions, so that I can link to my own post to save time. I have taken to calling this the “golden rule of software quality” because the rule is succinct and generalizable. The golden rule is: Prefer to push fixes upstream instead of working around problems downstream … and I’ll explain implications of this rule for a
Record constructors
This is a short post documenting various record-related idioms in the Haskell ecosystem. First-time package users can use this post to better understand record API idioms they encounter in the wild. For package authors, I also include a brief recommendation near the end of the post explaining which idiom I personally prefer. The example I’ll use the following record type as the running example for
Dhall - Year in review (2019-2020)
The Dhall configuration language is now three years old and this post reviews progress in 2019 and the future direction of the language in 2020. If you’re not familiar with Dhall, you might want to visit the official website for the language. This post assumes familiarity and interest in the language. I would like to use this post to advertise a short survey you can take if you would like to provi
Haskell for all: Detailed walkthrough for a beginner Haskell program
This post walks through the development of a small Haskell program for aligning equals symbols in a block of text. This walkthrough targets a beginning programmer by describing several steps and concepts in extra detail. Note that this post describes how to author, compile, and run single-file Haskell programs for ease of experimentation and learning. For larger Haskell projects you will want to u
How I evaluate Haskell packages
This post summarizes the rough heuristics that I use for evaluating Haskell packages. Usually I use these rules of thumb when: choosing between multiple similar packages deciding whether to depend on a package at all Some of these guidelines work for other programming languages, too, but some of them are unique to Haskell. Even if you are a veteran programmer in another language you still might fi
The wizard monoid
Recent versions of GHC 8.0 provides a Monoid instance for IO and this post gives a motivating example for why this instance is useful by building combinable "wizard"s. Wizards I'll define a "wizard" as a program that prompts a user "up front" for multiple inputs and then performs several actions after all input has been collected. Here is an example of a simple wizard: main :: IO () main = do -- F
Dhall - Year in review (2017-2018)
The Dhall programmable configuration language is now one year old and this post will review progress over the last year and the future direction of the language in 2018. If you're not familiar with Dhall, you might want to visit the official GitHub project which is the recommended starting point. This post assumes familiarity with the Dhall language. Also, I want to use this post to advertise a sh
Semantic integrity checks are the next generation of semantic versioning
The Dhall configuration language just added support for "semantic integrity checks". This post explains what "semantic integrity check" means, motivates the new feature, and compares to semantic versioning. The problem I added this feature in response to user concerns about code injection in Dhall configuration files. We'll illustrate the problem using the following example.dhall configuration fil
Advice for Haskell beginners
This post summarizes advice that I frequently give to Haskell beginners asking how to start out learning the language First, in general I recommend reading the Haskell Programming from first principles book, mainly because the book teaches Haskell without leaving out details and also provides plenty of exercises to test your understanding. This is usually good enough if you are learning Haskell as
Type-driven strictness
I was recently trying to optimize Dhall's performance because the interpreter was performing poorly on some simple examples. For example, consider this tiny expression that prints 3000 exclamation marks: Natural/fold +3000 Text (λ(x : Text) → x ++ "!") "" The above Dhall expression takes over 14 seconds to evaluate to normal form, which is not acceptable: $ bench 'dhall <<< './exclaim' benchmarkin
Use Dhall to configure Bash programs
Dhall is a non-Turing-complete programming language for configuration files, and if you are new to Dhall you might want to read the Dhall tutorial which explains how to use Dhall and several of the language features. Dhall is currently adding support for new languages and file formats such as: Haskell Nix JSON and YAML ... and now Dhall supports Bash, too! I'm releasing the dhall-bash package whic
Dhall - A non-Turing-complete configuration language
I'm releasing a new configuration language named Dhall with Haskell bindings. Even if you don't use Haskell you might still find this language interesting. This language started out as an experiment to answer common objections to programmable configuration files. Almost all of these objections are, at their root, criticisms of Turing-completeness. For example, people commonly object that configura
Data is Code
The title of this post is a play on the Lisp aphorism: "Code is Data". In the Lisp world everything is data; code is just another data structure that you can manipulate and transform. However, you can also go to the exact opposite extreme: "Data is Code"! You can make everything into code and implement data structures in terms of code. You might wonder what that even means: how can you write any c
リリース、障害情報などのサービスのお知らせ
最新の人気エントリーの配信
j次のブックマーク
k前のブックマーク
lあとで読む
eコメント一覧を開く
oページを開く
Dynamic type errors lack relevance
Dhall - Year in review (2018-2019)