Posts

• The love-hate relationship between SELECT and GROUP BY in SQL

  A clear explanation of the relationship between SELECT and GROUP BY in SQL guided by examples.

• Scripting the Hell out of Trello with Haskell

  Want to use Haskell for something real but don't want to risk it at work? This is how I do it.

• Advent of Code 2020

  Let's code the shit out of the Advent of Code together, shall we?

• How would I do it in Haskell?

  Here's a couple of examples where I contaminated Ruby with functional intuitions.

• Make Your Tests Fail Randomly (and Profit)

  Using random values in automated tests to improve readability and the likelihood of failures in the presence of bugs or wrong mental models.

• How to Terminate Legacy Code without Getting Stuck

  Embracing the inversion principle with legacy code: don't try to make it perfect; just make it less awful for the next round of changes.

• Vanilla JavaScript vs. RxJs

  Tackling problems from different angles: imperative against declarative, or "push" vs. "pull."

• The Simplest Most Powerful Trick–Verification Steps

  Verification steps don't come with a 100% save-ass guarantee, but the list of benefits is long, and it's not limited to finding bugs.

• How to Deal with (Your) Unsatisfying Code

  In the past, I committed the crime of adding a "Refactor Feature X" ticket to the cemetery (aka backlog). Luckily, there are better ways.

• From Zero to RxJs via Knowledge Transfer

  When I'm exposed to a new concept close to a dense area of my knowledge graph, I can approach it from multiple angles using different mental models.

• 10 Knowledge Transfers that Make me Thrive with Legacy Code

  I don't have to relearn anything from scratch; I only transfer knowledge over from past experiences and fill the blanks.

• From Temporary Knowledge to Permanent Knowledge

  By disregarding practices and principles, we are condemned to start from scratch and re-learn at every context switch.

• Making an Endpoint 13 Times Faster

  Down to 900 milliseconds. In other words, more than 13 times faster in the worst case (before it took 12 seconds) and infinitely faster in the best case (no more crashes).

• How to Investigate Performance Issues in a Web App with a Simple Script

  If only I could simulate a user but faster. Wait a second! A person clicking things in a browser just sends HTTP requests to the server.

• 99 Percent Done

  After several weeks of work, we are still 99% percent done. Or maybe I should say 99.9% done. Math is awesome, there's always room to add yet another nine to make it right.

• How to Tame Your Reading List to Support Your Goals

  While busy trying to fit all that content in our heads, we forget that reading is just the easy part.

• How to Tame Complexity Into Simplicity with a Shake List

  The trick is in minimizing the feedback loop. Ideally, you want to be told at each turn if you are wrong, not drive for days just to realize you were heading the opposite direction.

• Code Quality is Free (if You Do it Right)

  The secret is simple: the first version of the code must be as close to perfection as possible. Here's how to do it.

• How to Conjure Your Team Magic with a few Stickies and the Playbook Exercise

  When you support others, others will support you and your outrageous wishes.

• Elm Tricks from Production–From Angular v1 to Elm in 4 Days

  A solid plan and some patience is all you need to migrate an entire application to a different technology (while it continues to run).

• The Three-Step Recipe to Success with Legacy Code without Getting Overwhelmed

  The secret to successfully surviving legacy code is to build momentum. We need to focus on the solution not on the problems. In other words, we need to keep in mind that our goal is a successful project not perfect code.

• Elm Tricks from Production–Automated Testing is Just Another Tool

  Our take on unit testing and how we approached testing Elm code in AirCasting.

• Elm Tricks from Production–Adding Event Listeners to DOM Nodes that do not yet Exist

  How to use `setTimeout` and the DOM mutation observer API to attach callbacks to DOM nodes that do not yet exist.

• Naming Things Made Easy

  Naming things belongs to the editing phase not the writing one. Doing it too early is unproductive and dangerous. Here's why and how to fix it easily.

• Elm Tricks from Production–Declarative, Bug-Free User Interfaces with Custom Types

  How to use custom types to keep the interface declarative and avoid bugs.

• Can I be Completely Honest? – A Short Mentoring Story

  I bombed it. I knew as soon as Grzester started the feedback session with those words. But this was great news. I wasn't looking for a pat in the back, I wanted to improve.

• Elm Tricks from Production–Migrating from Angular v1 to Elm

  How we managed to migrate AirCasting from Angular v1 to Elm while still delivering value

• Grateful for the Opportunity of Working on Legacy Code

  In the end it's my choice. I can be lazy, fixate on the small details and waste time. Or I can use some discipline, focus on the big picture and accept the challenge.

• Elm Tricks from Production–Intro

  How Elm enabled fast iterations, cutting costs and keeping everybody happy in one of our projects at work—AirCasting

• The Secret to Getting Unstuck when Investigating a Bug

  When Radek asked me to pair on investigating a bug I was skeptical. But I had something he lacked: ignorance.

• Decomposing Features into Pipelines

  Code and pray when devising a solution is not the best approach. The exploration needs to start in problem space.

• Why Good Solutions Block Better Ones

  What is the Einstellung (set) effect, why it reduces problem solving skills and how to mitigate it

• Homebrew Brewfile Dump with Haskell

  This script creates a Brewfile using `brew bundle dump` and adds to that all the apps from `/Applications` that can be installed via Homebrew as casks.

• Starting from the Problem not the Solution

  I spent most of the day in solution space. The wrong solution space. In fact, I was solving a problem that didn't exist.

• Crossposting to Medium via Command Line

  Using a Haskell script to crosspost to Medium a blog post with a frontmatter as used in Jekyll markdown files

• Measuring Disagreement with Standard Deviation

  Friction is essential to team work. Discussing agreements, on the other hand, is a waste of time.

• Custom Markdown in Pandoc

  Transforming Pandoc's AST to implement custom Markdown syntax.

• Asking Why to Uncover Assumptions

  Laddering up from solution space to problem space can save a ton of money (and timezones).

• RecordDotSyntax in Haskell

  Records in Haskell are troublesome but the Dot (syntax) is coming soon

• From Silly Questions to Innovation

  At first an idea could be raw, maybe even silly. However, by thinking outside the box, it may turn into something innovative.

• Production Drafts for Hakyll Posts

  Publish hidden drafts to production with a boolean flag in the metadata

• It's Called Mistake, Not Bug

  Why I decided to stop using the b-word and started taking ownership instead

• Adding `published` to Hakyll Posts

  Control which posts to publish with a boolean flag in the metadata

• On Living Together as a Team

  Washing dishes and cooking meals as only a great team can do

• Rewriting to Haskell–Errors

  Returning the correct JSON error when parsing fails

• On Productivity

  Personal Productivity vs Generativity – the difference between your team's outcomes with you, vs without you

• Rewriting to Haskell–Parsing Query Params, Again

  Wrapping URL query params in their own types without using FromHttpApiData

• On the Scout Rule

  The Scout Rule by itself is a scam, context is needed

• Rewriting to Haskell–Parsing Query Params

  Wrapping URL query params in their own types using FromHttpApiData

• On Learning at Work

  Learning shiny new things in a commercial project is a bad idea, here's a better way

• Rewriting to Haskell–Linting

  Using HLint to improve the code in Stream

• Rewriting to Haskell–Testing

  Using HSpec to test Stream through its endpoints

• Rewriting to Haskell–Making GHC More Nitpicky

  Enabling GHC compiler warnings to enforce better code

• Rewriting to Haskell–Standing on the shoulders of Rails

  Using Rails as a handrail to keep our iteration small

• Rewriting to Haskell–Configuration

  Using yaml to configure a Servant application

• Rewriting to Haskell–Automatic Formatting

  Using Ormolu to keep code pretty and stop once for all discussions on cosmetics

• Rewriting to Haskell–Deployment

  Everything needed to deploy and run Stream (Servant) on the server side

• Rewriting to Haskell–Project Setup

  Setting up Servant and CI for Stream

• Rewriting to Haskell–Intro

  Hidden in the Functional Programming basement at Lunar Logic we want to have fun, enable newcomers to approach Haskell and creating future options for the company

• Staring at ($), (<$>), (<*>) and (>>=)

  Differences and similarities between function application, Functor's `fmap`, Applicative Functor's sequential application and Monad's `bind`

• Why Monad Composes Operations Sequentially

  A deeper look at Monad's bind (i.e. >>=) to understand why the type signature implies sequential composition

• From Kanbanery to Trello

  Using a Haskell script to migrate a Kanbanery board to Trello

• Crossposting to DevTo via command line

  Using a Haskell script to crosspost a blog post with a frontmatter as used in Jekyll markdown files

• Tweeting a Blog Post via command line

  Using a Haskell script to post a tweet about a blog post with a frontmatter as used in Jekyll markdown files

• Scaffolding a Blog Post

  Using a Haskell script to bootstrap a file from a template

• Playing with Fmt

  Using Fmt to format stuff

• Parsing CSV in Haskell

  Using Cassava to parse a CSV file

• Refactoring the Mars Rover Kata in Haskell

  Refactoring our deployed-to-Mars rover

• Mars Rover Kata in Haskell

  Moving a rover on Mars type-safely

• Fun with Typeclasses

  Ever heard of `Enum`, `Bounded`, `BoundedEnum` and `CyclicEnum`?

• Merging IO and Either into one monad

  How to simplify code by merging two monads into one

• Building a Blog in Haskell with Yesod–Giving Back

  In this post I'm celebrating becoming a contributor to Yesod

• Building a Blog in Haskell with Yesod–JSON API

  In this post we are going to see how to transform our Yesod blog into a JSON API (including authentication)

• Building a Blog in Haskell with Yesod–Returning JSON

  In this post we are going to see how to return JSON in our Yesod blog

• Building a Blog in Haskell with Yesod–Authorization

  In this post we are going to take care of authorization in our Yesod blog

• Building a Blog in Haskell with Yesod–Authentication

  In this post we are going to add authentication to our Yesod blog

• Building a Blog in Haskell with Yesod–Using a Database

  In this post we are going to hook up our Yesod blog to a database

• Building a Blog in Haskell with Yesod–The Basic Structure

  In this post we are going to develop the basic structure of our Yesod blog

• Scripting in Haskell and PureScript

  Writing scripts with Haskell and PureScript is a good way of doing some functional programming at work

• A Parser Combinator in PureScript (part 2/2)

  Implementing and using a parser combinator

• A Parser Combinator in PureScript (part 1/2)

  Implementing and using a parser combinator

• A State Monad in PureScript

  Implementing and using the State Monad

• Folding Trees in PureScript

  Transforming the structure of a tree by employing recursive functions, the Foldable typeclass and the State Monad

• Game of Life in PureScript

  Interactive Programming in PureScript

• Nim in PureScript

  Interactive Programming in PureScript

• Hangman in PureScript

  Interactive Programming in PureScript

• Adding Twitter Cards to Hakyll Posts

  Make your Hakyll posts look better in Twitter

• A Useless Compiler in PureScript

  Dipping a toe in compilers land

• Functors Compose, Monads Do Not

  The title says it all 😅

• Testing Bank Kata in PureScript

  Unit testing monadic functions

• Bank Kata in PureScript

  Purely functional state mutations in PureScript