Bits and pieces

Advent of Code 2020 in Haskell - Part 1

In the last days of this year, I decided to solve the Advent of Code 2020. To make it even more of a challenge, I decided to solve the puzzles in a (for me) new programming language: Haskell. Why on Earth Haskell? I am curious about the type system and want to improve my functional programming, so what better way to stop reading about it and dive into it?

In this series of posts, I will cover my experience in learning Haskell and using it to solve the puzzles. At the end of the series, I will go back and apply what I learned to my solutions.

Making a shooting board

Just wanted to show my first woodworking project since a while, a shooting board. In case you have no idea what it is: a shooting board is a simple jig to straighten the end-grain of wood, possibly under an angle.

Getting rusty

A few weeks ago I started to create my own custom C++ project template for embedded projects. It would be great. I would build it from the ground up and know exactly how it works. Dive into the nitty-gritty details and tune it to my liking. Integrate the latest tools, to monitor binary size and relate changes to specific commits, have nice code coverage statistics, a linter, and various static analyzer tools available at a single command. I would extend it gradually, adding the features as I see fit and mould it to fit my way of working. There was a small example application to show how it works. I determined and documentation relevant compiler and linker flags for GCC, Clang, and MSVC. All, such that I could have a single point from where to compile my embedded application for target or compile unit-tests on my PC. And from there build other, larger, more sophisticated applications within my workflow. Did I mention it would be great?

And then I decided to scrap it.

Why? Because it was not fun anymore. The more time I spend on it, the less I enjoyed working on it, becoming less motivated to work on it. I realized I was mimicking a production environment, which is not what I set out to do. I do these kinds of projects for myself, to learn, to explore, and to challenge myself and to have a bit of fun while I am at it. So, I went back to a simple question: what do I want?

For now, I decided to pick up something I have had on my wanting to learn list for some time: learning Rust. Over the last years, I started reading the Rust book a few times, but never actually made it past the first few chapters. Nor made anything. Why? I think because I missed a goal.

So, I have set myself the challenge to create my first embedded Rust application and properly understand it. So, not just combining a few libraries and be done with it. The application itself would be relatively simple, a data collector for an IMU development board that has been collecting dust on my desk for months.

From there on, I will use that data collector to experiment with some IMU related algorithms and estimation theory. But more on that later, for now, I take it one step at a time.

Why I like PlantUML

PlantUML is a tool to generate UML diagrams from plain text files. Sounds easy right? Now it’s not a fancy tool, no code generation, no model verification. Instead, the tool comes with a basic user interface and the diagram style is rather simple. It does one thing: generating UML diagrams. And I think it does that one thing very well.

This post is a short write-up of how I integrated this tool within my development process.

Reducing the size of my Docker images

I recently started using Docker images to hold specific toolchains in a controlled environment. With the end goal to set up a portable and reproducible build system. In a recent post, I described my base image with an ARM Cortex-M toolchain. After creating my ARM toolchain image, I started to expand to other toolchains and compilers. In this post, I will apply some best practices I came across to improve my images and reduce their size in the process.

Compiling a bare metal application with a Docker image

Recently I started to set up an automated build system for my code projects. One of the elements in there is utilizing Docker images for self-containing build environments and creating reproducible builds. Here, I focus on the creation of the image itself and how to use it to compile for bare metal ARM (Cortex-M in my case.)

Reading list - August

Interesting articles I came across in August.

Reading list - July

Interesting articles I came across in July.

Book review: Real-Time C++

Recently I picked up a copy of Real-Time C++ by Christopher Kormanyos to determine its suitability for teaching a few new colleagues embedded software development with C++. This post is my review of the book.

Representing money in Python

I am working on a personal project to create a financial budgeting system. One of the first challenges is how to represent and perform operations on money.