Git Snapshots Revisited

A great way to approach Git, I believe, is to explore its inner workings. To do that, let’s take a closer look at an analogy I made up previously, and create some useful graphs from real repositories. [Read More]

KNX Link-Layer Ack: A brief analysis.

KNX is a two-wire bus for building automation. It operates at a pretty low bitrate, which makes it a good candidate for analyzing communications using a cheap logic analyzer. This article is about the Acknowlegement procedure at the KNX Link Layer. [Read More]

Software Design Challenges: Embedded vs. Web

Sometimes, Embedded is considered a very special field of Software Engineering. It’s all about microcontrollers and complex devices, connected via a plethora of different bus systems – carefully orchestrated using only the C programming language. Let’s go and find out what’s so special about Embedded, and what our discipline has... [Read More]

Git in a nutshell: Commit, Checkout, Reset

We’re going to talk about three basic git commands in this episode: commit, checkout and reset. Instead of making up any abstractions or metaphors, we will focus straight on how these commands modify your repository’s internal state. [Read More]

3 Practical Uses of void Pointers in the C Language (part 1/3)

Probably every beginner’s book on C programming has a section on pointers. Usually, there are also one or two paragraphs on the topic of void pointers. Have you ever asked yourself what they can actually be used for? In this article, we will explore some practical uses for pointers of... [Read More]

Embedded Programming: Loose Coupling Best Practices (Part 1/3)

When creating Embedded Software, system complexity that grows over lifetime makes it increasingly harder to reason about certain behaviors of the program. As always in engineering, it helps to divide one big problem into several smaller problems in order to be able to eventually solve it. This is what this... [Read More]

Git: Compare feature branches to master (Part 2/2)

In the previous article we’ve seen how to ask Git for changes introduced by a particular branch. This time, instead of changes, we would like to know which commits were introduced by a branch – that is, the hashes assigned to them. [Read More]

Debugging on the Command Line

Do you use a GUI debugger? Chances are that it is backed by the GNU Debugger, gdb, somehow. Wouldn’t it be great to use that backend directly? In this article, we are going to highlight some strengths of gdb’s command-line interface over GUI frontends. [Read More]

Stand-alone TDD monitor using 'entr'

Have you ever thought of something that continuously monitors your project’s source tree and triggers a unit test build upon file changes? You want it to be independent of the editor or IDE you use? Then maybe this is for you. [Read More]

Fixing Typos while Writing -- Two Ideas

Here are some thoughts on text editing. No matter what kind of text you write – source code, articles, to-do lists, books – there’s always a chance you get a single letter wrong at one point. Depending on your touch typing skills, this might not happen very often. But when... [Read More]

C Bitshift Operator Revisited

Recently someone asked me about C’s bitwise shift operator, specifically about what it does to signed integers. To be honest, until then I haven’t even considered applying the left or right shift operator to anything else than unsigned numbers. So let’s figure out what this is about. [Read More]

Undo Feature Using Git Plumbing Commands

Have you ever thought about adding an undo feature to your application? This blog article is an attempt to approach that task by utilizing some internals of the Git version control system together with the Memento design pattern. But please, don’t take this too seriously :-). [Read More]

Hex Parser

This article is about creating a parser for HEX files, a format that is often used as an intermediate step for programming microcontrollers. Although there are – of course – implementations out there already, I would like to use this as a welcome opportunity to play around with some interesting... [Read More]

From Subversion to Git: Snapshots

What does it mean that we talk about snapshots of our Git repository, while in Subversion we think in terms of file changes? For me at least, the key to understanding Git is that every commit is, in fact, a snapshot of the entire project. Not a list of patches.... [Read More]

Bash Job Control

When working on the command line, you may sometimes find yourself in a situation where you’d like to start a new program while another long-running process (e.g. an editor) is blocking the current terminal. In the course of this article we are going to find out how to achieve quick... [Read More]

Introduction To Readline

When developing command line applications, you will most certainly want to have bash-like line-editing features. For that, an excellent choice is the GNU readline library. We will see in this article how to use its features from out own programs in order to provide a user experience similar to that... [Read More]

Non-Interactive Text Editing in Vim

The Vim text editor has its roots in the traditional line-based editors of the early days. Due to that heritage, it supports a set of impressively powerful Ex commands that act on individual lines. In this article, we will see how to create a script composed of these commands and... [Read More]

Vim Errorformat Challenge

The Vim text editor provides built-in support for parsing compiler output. It has quite a broad understanding of the concept of a compiler though: You can call just any command and let the editor parse its output. For this to work correctly, format strings need to be specified, matching the... [Read More]

Discovering Refactoring Needs

This article is about creating a plot of complexity over change rate for a given set of source code files. According to an idea I’ve seen on twitter last week, this might help us finding spots in the code that have an influence on how well a project goes. Here... [Read More]

Maintaining A Clean History In Centralized Git Workflows

Git is a powerful tool for versioning (not only) source code files. It is decentralized by design but also works perfectly for setups that rely on a central server. By using a standard pull/push workflow though, the central history can grow complex pretty fast. In this article we will look... [Read More]

Linux Shebang Insights

In Linux, you can execute an interpreted script file in exactly the same way as you would execute a compiled binary: by setting the ‘executable’ attribute and just run it. A special sequence of characters at the beginning of the script makes this possible. In this article we will explore... [Read More]

The Shell And The Whitespace

When writing conditionals in shell scripts, have you ever wondered whether that whitespace right after the opening bracket is really necessary for the expression to evaluate correctly? You might be surprised by the answer we’ll discover in the course of this short article. [Read More]

What Makes A Unit Of Code Falsifiable

In his recent book about Software Architecture, Robert C. Martin a.k.a. Uncle Bob describes programming as a discipline of science, rather than mathematics. In one of the first chapters of the book he talks about Structured Programming and how it enables us to produce – according to the scientific method... [Read More]

Test-driven 7-Segment Decoder

This article is about creating a 7-segment display decoder in software. While this is probably considered a rather trivial task, it will serve as a good example for the discipline of Test-Driven Development (TDD). The motivation for a test-driven approach in this case is simple: being able to refactor later... [Read More]

The bash debugger: an example

Sometimes you may find yourself in a situation where you need to actually debug a shell script you're currently writing. Especially in the initial phase of development, features like single-stepping feel quite handy. I this article we are going to look at two situations where the bash debugger (bashdb) is... [Read More]

AVR sleep mode for fun and profit (part 2)

In the first part of this article we managed to put the AVR into power-down mode and were thereby able to lower the current consumption in idle mode to 0.0 mA. While this is great compared to the 22 mA before any optimization, there is no way to wake up... [Read More]

AVR sleep mode for fun and profit

Today's blog article is about how to optimize the power consumption of an AVR microcontroller running on batteries. We're going to explore one of the ATmega32's sleep modes and how it affects power consumption. We will eventually reach a state where it actually makes sense to power the device from... [Read More]

Passing heavy C++ objects by value

Big objects are traditionally passed to methods by reference. Some weeks ago I talked to a colleague about that and decided to investigate a bit further. As a result of my research I must admit that, starting with C++11, things have indeed changed. Depending on what happens inside the body... [Read More]

Background make execution in Vim 8

Version 8 of the Vim text editor introduced a great new feature for executing processes asynchronously. In this article I'm going to show you a plugin that makes use of these async jobs and how I utilize them to build a C++ project in the background. [Read More]

Test-driving the MCP2515 CAN Controller (Part 2)

It turns out the device driver design established previously has a serious drawback. While the SpiDriver interface enables unit testing, the cost of polymorphism has to be paid also in production code. In this article you are going to see how high that cost is, i.e. how much extra code... [Read More]

Test-driving the MCP2515 CAN Controller (Part 1)

So you are pretty much into Test-Driven Development (TDD)? You love to practice it on your development machine but think it might be quite a hassle when it comes to writing code for small microcontrollers? In this blog article we are going to take a journey to Embedded TDD using... [Read More]