- 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.
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
The best part of the team playbook exercise is that most outrageous things really are not. Strangely enough, when you support others, others will support you.
- 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
I treasure disagreements. I find 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