Rickard Lindberg

Jan 13, 2025 ∞

Today’s realization is that you can get important things done by consistently working on them for 15 minutes at the start of every day.

By doing it at the start of the day, you ensure that it gets done. And the rest of the day you don’t need to be stressed about not working on your important thing, because you already have.

Jan 12, 2025 ∞

Newsletter December 2024: Advent of Code

December is the month of Advent of Code. I had told myself not to participate this year because I know I get completely consumed by the problems and it has a negative impact on the rest of my life. It worked. Until December 15th. More on that later.

Code Editor Update

Last month I started working on a new code editor. It is a mix of a text editor and a structured editor. It is all text, but parsers and pretty printers allow you to work with a tree structure and not think too much about syntax.

I continued working on it this month. The big achievement was that I added support for another language in addition to JSON. The other language is rlmeta. Here is a screenshot showing the parser opened in the editor:

A screenshot of releditor editing the parser of
rlmeta.

This is a big achievement because it ties everything together. You define a parser and a pretty printer for your language. That gives you all editing capabilities. However, you can also write a code generator, and now you have a full blown programming language with editing support “for free”. This potentially provides an environment to quickly experiment with new programming languages.

Conceptually, I’m quite happy with this achievement. However, there are many things to work on before this is “production ready”. First of all, the performance is pretty horrible because of the constant parsing and pretty printing. Second of all, I need to see if a tree based editor can actually become better than a regular text editor.

Advent of Code

I couldn’t help myself but to participate this year as well. The experience was not as stressful as last year. I still got consumed by the problems, but the feeling was mostly positive. I managed to complete all but 3 problems. Right now, the interest to complete them is pretty low. I might take a look at other solutions to see if I can learn something from that.

My approach to solving the problems is that I try to solve them in order, and I don’t look at others' solutions until I have solved both parts. However, I’m out of ideas to try on the last problems, and I think the competition part is over by now. I might learn something for next year if I look at solutions now.

This year I also practiced object oriented design. So my solutions involve many small objects interacting with each other to produce a solution. It was mostly a success I think. One of my favorite solutions is for day 11.

This year I also think that I got the hang of Dijkstra and A*. (I found Introduction to the A* Algorithm from Red Blob Games really helpful.)

You can find all my solutions on GitHub.

Dec 8, 2024 ∞

Newsletter November 2024: A New Project

Compared to last month, this month I did some programming in my spare time. I had fewer commitments, and my mind started thinking about various programming projects. We also got the first snowfall of the season and I got to enjoy a run in it:

Me running in a snow-covered landscape with the
sun setting in the background.

A New Code Editor

The programming project that I started working on is code editor that is a mix of a text editor and a structured editor. It is all text, but parsers and pretty printers allow you to work with a tree structure and not think too much about syntax. The code is available on GitHub, and here is what it looks like when editing a JSON document:

Screenshot of rledit editing a JSON document with a
selection.

I got the idea for this project when trying out Black. Black automatically formats Python code for you so that you don’t have to think about it. I’ve been interested in structured editors for some time, but my feeling is that they are not user friendly because they limit what you can type. Then I came up with this idea of an editor that constantly parses what you type. If the parse is successful, it pretty prints it for you and provides you with edit operations on the AST. But it is all still just text, so you can type whatever. In the worst case, the parse fails and you have to fix it manually.

So far, it looks quite promising. And most importantly, I’m having fun experimenting. The most likely scenario is that the project will not be a success, but I will learn something and have fun doing so. But you never know. One day, one of these projects just might turn into something that is invaluable.

TDD

This month I also watched a presentation by Kent Beck called TDD: Theme & Variations. For me, it was a nice refresher on the origins of TDD.

One thing that I appreciate with TDD, that I partially had forgotten, is how it reduces anxiety. Kent reminded me of it in the presentation. When all tests are passing and you can’t think of any more tests to write, you are done, and you know that it works. That reduces anxiety a lot.

Dec 4, 2024 ∞

Today I ran part of the way to work. It was a cold, beautiful winter morning in Stockholm.

Me running with water and Stockholm City Hall in the background.

Nov 28, 2024 ∞

Sometimes, I solve programming problems by coding on paper. A few days ago, it looked like this:

A piece of paper with source code written on it with annotations.

Nov 28, 2024 ∞

I’ve started working on a code editor that is a mix of a text editor and a structured editor. It is all text, but parsers and pretty printers allow you to work with a tree structure and not think too much about syntax. It is a work in progress. Code is here.

Screenshot of rledit editing a JSON document with a selection.

Nov 23, 2024 ∞

We got some more snow. I like running in the winter. Especially when there is snow and the sun is shining.

Me running in a snow-covered landscape with the sun setting in the background.

Nov 20, 2024 ∞

I needed to submit some heic photos to a service that only accepted jpg. I didn’t know about the heic format, but a little searching gave me a solution:

$ heif-convert
bash: heif-convert: command not found...
Install package 'libheif' to provide command 'heif-convert'? [N/y] y
...
$ find . -iname '*.heic' -exec heif-convert -q 100 {} {}.jpg \;

Nov 20, 2024 ∞

Today was the first day of snow this season. Not much. I’m looking forward to many more runs on a white trail.

Me running on a trail with a little snow.

Nov 16, 2024 ∞

I was researching how to run Black (and possibly other formatters) from Vim and found Ergonomic mappings for code formatting in Vim. It was very helpful.

Nov 3, 2024 ∞

How would you improve this code?

def update_r_users(service)
    r_users = []
    for user in service.get_all_users():
        if "r" in user:
            r_users.append(user)
    service.set_users_in_group("users_with_r_in_name", r_users)

Find out what I did it in my latest newsletter.

Nov 3, 2024 ∞

Newsletter October 2024: Primitive Obsession?

Normally I do something related to programming in my spare time every month. I read something that I find interesting and want to share. Or I have some thought related to programming that I want to share. This is the first month since I started these monthly updates in June 2019 that I’ve got nothing of that. I’ve been occupied with other things, and I’ve also done quite a bit of programming at work. Perhaps that has satisfied my interest for programming.

One thing that I’ve done a lot at work this month is wrapping simple data structures in classes. Instead of passing around lists and dictionaries, I’ve created classes holding that data and only serialized it at the edges of the application. Every time I have done this, I wish I had done it sooner. It’s so good. And in nine times out of ten, those classes have attracted some functionality that fits perfectly. They have provided one place to put functionality instead of scattering it throughout the codebase.

What am I talking about? Let me give an example.

Imagine that we talk to a user service that has an API something like this:

service.get_all_users() -> ["user1", "user2"]
service.set_users_in_group("group1", ["user1", "user2"]) -> OK

The API works with users represented as list of strings. Now we want to write a function that applies some domain logic to assign users to groups. It is so easy and tempting to write something like this:

def update_r_users(service)
    r_users = []
    for user in service.get_all_users():
        if "r" in user:
            r_users.append(user)
    service.set_users_in_group("users_with_r_in_name", r_users)

One problem with this code is that it mixes calls to the user service with domain logic, so is is difficult to test domain logic without invoking the service. It’s also more difficult to reason about.

What if we instead did this:

def update_r_users(service)
    service.set_users_in_group(
        "users_with_r_in_name",
        Users.from_service(service.get_all_users()).filter_name("r").serialize()
    )

class Users:

    @classmethod
    def from_service(cls, users):
        return cls(users)

    def __init__(self, users):
        self.users = users

    def filter_name(self, text):
        return Users([
            user
            for user in self.users
            if text in user
        ])

    def serialize(self):
        return self.users

This is what I mean by wrapping simple data structures in classes. Why is this better?

First of all, I think update_r_users now reads a lot better. The filtering logic is no longer mixed with the calls to the service.

This comes at the cost of writing the Users class which is quite long for the relative functionality that it provides. In the beginning, I often find it hard to motivate myself to write these classes. It feels like a lots of boilerplate code for not much benefit. However, I often find that these sort of classes attract functionality, at which point they start to become more useful.

Another thing that they do is encapsulate the data format from the user service. Say that the API of the service changes. There is now more information about users:

service.get_all_users() -> [{"name": "user1", "age": 21}, {"name": "user2", "age": 43}]
service.set_users_in_group("group1", ["user1", "user2"]) -> OK

We can update the User class accordingly:

class Users:

    @classmethod
    def from_service(cls, users):
        return cls(users)

    def __init__(self, users):
        self.users = users

    def filter_name(self, text):
        return Users([
            user
            for user in self.users
            if text in user["name"]
        ])

    def serialize(self):
        return [user["name"] for user in self.users]

The update_r_users stays the same. We control the API of Users. Our application can safely depend on it. And we can change the internals.

I couldn’t find a name for this sort of pattern. My first though was that it was a way to avoid primitive obsession. And it is. But it feels like more than that. Bill suggested that it might be just “good old encapsulation”. Dan said that it depends on the context and that it could be an anti-corruption layer in DDD terms. What would you call it?

Anyway, I’ve been doing this sort of thing a lot this month, and I thought it was worth sharing.

Nov 2, 2024 ∞

Today I learned about the Rison data serialization format. I wrote a function to convert a Python value to Rison format. It was an elegant recursive function with partial support for the format.

Nov 2, 2024 ∞

I’ve used testing without mocks quite extensively now. I’ve also used it in a work project for more than a year. My experience is that it’s the best testing strategy that I’ve ever used. I’ve never felt more confident that my code works. I refactor code without fear of it breaking. It’s so good.

Oct 28, 2024 ∞

It’s getting dark. It gives variation to the running.

Oct 16, 2024 ∞

Various things have kept me from running for a while. Today I had enough. I just had to go for a short run. It was the first run with warmer clothes. The weather was nice. I reclaimed some energy.

Oct 14, 2024 ∞

Newsletter September 2024: Bash Redirects and Reading

This month I read How to Use a Zettelkasten to Write Stories Packed with Emotion. It inspired me to write something using that technique. The topic that came to mind was Bash redirects. It resulted in the blog post Bash Redirects Explained.

I also started reading How Children Learn by John Holt. He says that children are naturally interested in exploring the world. I started thinking about what environments kill exploration. I though that fear of doing something wrong will discourage exploration. Then I made a parallel to a common practice in software development: pull requests. I thought that pull requests discourage experiments because changes can only propagate after approval, and the idea behind pull requests is to only approve “good” changes. First of all, the learning opportunities of mistakes are gone. Second of all, you might loose interest in experimenting because you are afraid of making a mistake. You build a culture of discouraging making mistakes. I though that a better approach is to focus on making the cost of mistakes small so that we can do lots of them and learn from them.

I also read Debugging Teams by Ben Collins-Sussman and Brian Fitzpatrick. They talk about the myth of the genius programmer and that all great things are built by teams. I believe that is true, but sometimes I have a hard time to acknowledge it because I also enjoy working by myself.

Sep 5, 2024 ∞

Pull requests discourage experiments because changes can only propagate after approval. The idea behind PRs is to only approve “good” changes.

First, the learning opportunities of mistakes are gone. Second, you might loose interest in experimenting because you are afraid of making mistakes.

Sep 5, 2024 ∞

Today I just needed to run. I had not run since I hurt my achilles tendon almost a month ago. I wanted to see if it still hurt. I felt something, but not too much. I think I still need to take it easy with running, but man it felt good moving again.

Sep 5, 2024 ∞

If you want to know how to implement a Bash-like shell, with support for redirects, in only 31 lines of Python, you should check out my latest blog post Bash Redirects Explained.