Skip to content

Newsletter: Better Built By Burkhard

As a solopreneur, I specialise in usage-centred human-machine interfaces (HMIs) for embedded devices (see My Mission). My marquee projects are the driver terminals for the ROPA sugar beet harvesters and for the KRONE forage harvesters, and the infotainment system for the FiatChrysler cars (see My Portfolio). I help companies get high-quality software into the hands of their customers faster. 

In this newsletter, I share my hands-on experience about system architecture, team topologies, continuous delivery, test-driven development (TDD), refactoring, continuous integration, FOSS licensing, SoM and SoC selection, running a solo business, etc. I explain what works, what doesn’t and why.

Every episode of the newsletter contains an original post about a topic: e.g., Do You Have to Pay for Qt, What Software Should Soc/SoM Makers Provide, How Does the EU Cyber Resilience Act Affect Your Business. It also contains links to my latest posts on and to interesting content around the web.

You’ll receive one episode on the 3rd Monday of each month. I am looking forward to lively discussions with you by email or through the comment sections. I hope that you join the 600+ readers of my newsletter soon.

Past Issues

Episode 50 (19 February 2024)

Main Topic: The Server Side of Over-the-Air Updates.

Episode 49 (15 January 2024)

Main Topic: The Client Side of Over-the-Air Updates.

Episode 48 (4 December 2023)

Main Topic: User Products under LGPL-3.0.

My Talks at Qt Greece: Ports-and-Adapters Architecture for Embedded HMIs; Using Qt under LGPL-3.0.

Episode 47 (6 November 2023)

Main Topic: The EU Cyber Resilience Act: Manufacturer Perspective.

Episode 46 (4 October 2023)

Main Topic: Measuring the Productivity of Developers. McKinsey: Yes, you can measure software developer productivity; Part 1: Response by Gergely Orosz and Kent Beck; Part 2: Response by Gergely Orosz and Kent Beck.

Episode 45 (8 September 2023)

Main Topic: Think Slow, Act Fast. Review of book “How Big Things Get Done” by Bent Flybjerg and Dan Gardner.

My Content: Ports-and-Adapters Architecture: The Pattern.

Episode 44 (7 August 2023)

Main Topic: 10 Years of Solo Consulting (Part 3).

Episode 43 (8 July 2023)

Main Topic: 10 Years of Solo Consulting (Part 2).

Episode 42 (1 June 2023)

Main Topic: 10 Years of Solo Consulting.

Episode 41 (1 May 2023)

Main Topic: Qt for Memory-Constrained Devices.

My Content: Reference Image: Verdin iMX8M Plus, Yocto 4.0, Qt 6.5.

Around the Web: Valentina Cupać (Optivem Journal): Hexagonal Architecture – The Why. Luca Ceresoli (Bootlin):Yocto: sharing the sstate cache and download directories. Ivan Solovev (The Qt Company): Qt CAN Bus API extensions.

Episode 40 (15 April 2023)

Main Topic: Doing TDD with I/O-Free Tests.

My Content: Interview with Crossware about Embedded World 2023.

Episode 39 (1 April 2023)

Main Topic: Embedded World 2023 – Round-Up. Toradex: Towards Solutions on Modules (SoMs); Kontron: AMD Ryzen as Super ECU; Slint: A Qt Competitor?; Comparing Qt, Slint and Flutter.

My Content: Accessing Private Git Repositories from Docker Containers.

Episode 38 (16 March 2023)

Main Topic: Metrics for Continuous Delivery. Metrics: change failure rate, failure recovery time, deployment frequency, lead time for changes.

Episode 37 (1 March 2023)

Main Topic: Consequences of Choosing the Wrong HMI Terminal

My Content: KDAB Insights: Building a Smart User Interface – what’s really involved? (interview)

Episode 36 (15 February 2023)

Main Topic: A Basic Continuous Delivery Pipeline for Embedded HMIs.

My Content: Compatibility between Yocto and Qt 6 Versions. Building Qt 6.2 For Old Yocto Versions.

Around the Web: The Top 100 QML Resources by KDAB. Why doesn’t my Qt Creator find my files anymore. Understanding qAsConst and std::as_const.

Episode 35 (1 February 2023)

Main Topic: Architecture Decision Records

My Content: Architecture of Qt Embedded Systems: Getting Started. My Talk “Hexagonal Architecture: The Standard for Qt Embedded Applications” at Meeting Embedded 2021.

Around the Web: Architecture Decision Record (ADR). Scaling the Practice of Architecture, Conversationally.

Episode 34 (16 January 2023)

Main Topic: Illegal License Combinations.

My Content: Using Qt 6 under LGPLv3. Talk: Using Qt under LGPLv3. Introduction to the SAE J1939 Standard.

Around the Web: What’s New in Qt 6.5: New CanBus Classes. Defending the CAN bus. IoT is Broken: It Won’t Scale.

Episode 33 (1 January 2023)

Main Topic: Why TDD is a Main Driver for High Performance

My Content: Applying TDD to Classes Accessing Files. Applying TDD to HAL Drivers with Memory-Mapped I/O. QML Engine Deletes C++ Objects Still In Use – Revisited with Address Sanitizers.

Around the Web – TDD Bashing: I have complicated feelings about TDD. Why I Don’t do TDD. The Little Things: My ?radical? opinions about unit tests.

Episode 32 (15 December 2022)

Main topic: My Favourite Books of 2022 – Enabling Continuous Delivery

  • Matthew Skelton, Manuel Pais: Team Topologies – Organizing Business and Technology Teams for Fast Flow
  • Dave Farley: Continuous Delivery Pipelines – How to Build Better Software Faster
  • Esther Derby: 7 Rules for Positive Productive Change – Micro Shifts, Macro Results
  • Colin Bryar, Bill Carr: Working Backwards – Insights, Stories and Secrets from Inside Amazon
  • Joyce Nilsson Orsini (Editor): The Essential Deming – Leadership Principles from the Father of Quality

Episode 31 (1 December 2022)

Main topic: Electronica 2022 Roundup

My Content: The Key Principles of Continuous Delivery, Can We Use Trunk-Based Development for Legacy Software?, Casting a negative float to an unsigned int.

Around the Web: Qt Marketplace License Abandoned, Minimum Viable CD, Comparing 2 approaches of refactoring untested code.

Episode 30 (15 November 2022)

Main topic: The Board-Support Package Is Not Enough!

My Content: Setting Up Yocto Projects with kas. Installing Linux Images on Toradex Verdin Boards. Creating A Custom Yocto Layer.

Around the Web: Till Adam: Choosing a CPU Is the i.MX 8 Right for Your Project? Tim Ottinger: Story Points: Why is this so hard? Joshua Kerievsky: Stop Using Story Points.

Episode 29 (1 November 2022)

Main topic: Do you have to pay for Qt?

My Content: Critique: Guide to the Total Cost of Ownership of Open-Source Software, Parking at Munich Airport: An Awful Experience, Visualising the Architecture of Qt Embedded Systems: Context and Container Diagrams

Around the Web: Expert Talk with Adam Tornhill: Code Refactoring, Bryan Finster: 5 Minute DevOps: SAFe Isn’t, Blair Enns: The Innoficiency Problem

Episode 28 (5 April 2022)

Visualising the Architecture of Qt Embedded Systems: Context and Container Diagrams; Qt roadmap for 2022; Scaling Agile @ Spotify with Tribes, Squads, Chapters & Guilds; Would you like architects with your architecture?; How to move the default /var/lib/docker to another directory for Docker on Linux.

Episode 27 (7 March 2022)

Visualising Module Dependencies with CMake and GraphViz; mock QCanBusDevice for TDD; review of the book “Team Topologies” by Matthew Skelton and Manuel Pais; Simon Brown’s C4 model for visualising software architecture; Peugeot, Citroen, DS and Opel use Qt in their infotainment systems; WEINIG uses OPC UA for their wood processing machines.

Episode 26 (7 February 2022)

Smart machines require smart user interfaces (UIs); simplified Qt Commercial licensing; trunk-based development; accessing private Git repositories from Docker containers; mutually exclusive CMake options; two-way property bindings in QML; Qt Quick script compiler (qmlsc).

Episode 25 (3 January 2022)

How Apple is organised for innovation; migrating a harvester HMI from Qt 5.12 to Qt 6.2; most viewed posts in 2021; property bindings in Qt 6.2; OpenAPI generator; fake function framework; 32 book recommendations; Italian court rules on GPLv3.

Episode 24 (6 December 2021)

Developing a QML keypad with TDD; free smart machines from dumb user interfaces (UIs); alleviating chip shortage with cross-platform development; architecture decision records.

Episode 23 (8 November 2021)

Hexagonal architecture: the standard for Qt embedded applications; self-learning car navigation; scaling QML applications; OTA updates with RAUC, SWUpdate and Mender; multi-part introduction into CMake.

Episode 22 (4 October 2021)

Setting up Yocto projects with kas; header included from extern “C” is compiled as C++; IoT architecture of parking meters; QML modules in Qt 6.2; ten guidelines for using TDD.

Episode 21 (8 September 2021)

Pricing services: productised services, advisory retainers, workshops and trainings; estimating complexity.

Episode 20 (2 August 2021)

A successful architecture for Qt embedded systems; pricing services: hourly billing, value pricing; portable C++ development environment with Docker; ports and adapters pattern (hexagonal architecture); composition root pattern; TDD all the things including teams; don’t use mocking frameworks.

Episode 19 (5 July 2021)

Architecture: single vs. multiple GUI applications; Forrester study: smarter products need smarter development; Qt on Apple Silicon; OTA updates with OSTree; Toyota thrives despite chip shortage; technical debt is a strategic lever; getting sponsorship for large scale refactorings.

Episode 18 (7 June 2021)

Architecture: operating conditions; good, right and successful architectures; book review “Design It! From Programmer to Software Architect”; book review “Fundamentals of Software Architecture”; book review “Just Enough Software Architecture: A Risk-Driven Approach”; is design dead?; book review “Evolutionary Architectures: Support Constant Change”.

Episode 17 (3 May 2021)

Using Qt 5.15 and Qt 6 under LGPLv3; effective decision making; Froglogic acquired by The Qt Company; 2021 embedded product planning and requirements guide; how you can tell whether Qt is right for your project; new CMake features in QtCreator 4.15; signal/slot connection throttlers.

Episode 16 (1 April 2021)

How to set up QtCreator for cross-compilation with CMake in 5 minutes; Qt Embedded Days 2021; top-7 shortcuts in QtCreator; calling C code from C++ with extern “C”; testing superpowers: using CLion to add tests easily; making the date.

Episode 15 (28 February 2021)

Showing Wayland compositor fullscreen in portrait orientation; book review “The Art of Readable Code”; Linux kernel GPIO user space interface; GPIO programming with libgpiod (a 9-part series).

Episode 14 (31 January 2021)

Migrating a harvester HMI from Qt 5.12 to Qt 6.0; FOSS-North podcast: LGPL with Burkhard Stubert; cross-compiling Qt applications with QtCreator and CMake; a deep-dive into Qt CAN bus; LoRaWAN and Bluetooth Low Energy development kits; secure firmware updates; production programming for Linux; defensive programming – friend or foe?; all about code review.

Episode 13 (31 December 2020)

Determining the architecture of Qt embedded systems (50+ questions); my most viewed posts in 2020; Qt 6 special: Qt 6.0 released, Qt 6 in OpenEmbedded and Yocto, C++ property bindings in C++, porting from Qt 5 to Qt 6 using Qt5Compat, new features in QtCreator 4.14 and CMake 3.19.

Episode 12 (30 November 2020)

Cross-compiling Qt embedded applications with QtCreator and CMake; book review “Pricing Freelance Projects”; patterns and anti-patterns for layout of QWidgets; containers on embedded Linux; OpenEmbedded and Yocto project best practices; optimising power consumption in battery-powered devices.

Episode 11 (31 October 2020)

Book review “A Philosophy of Software Design”; Qt Marketplace; QList changes in Qt 6; approval tests; bringing up embedded Linux on 10 low-cost boards; what’s wrong with MQTT?; field guide to CoAP.

Episode 10 (30 September 2020)

Breaking dependency cycles in Qt applications; Gartner study (2020): hype cycle for embedded software and systems; ARM acquired by NVIDIA; cost of rework avoidance; trunk-based development vs. Git Flow; building the perfect customer testimonial.

Episode 9 (31 August 2020)

CppDepend: a C++ dependency analyser; leveraging usage rights for IP creation; why I failed to upgrade the Raspberry Pi 3B from Yocto 2.6 to Yocto 3.1; stopping bugs: seven layers of defence; 9 useful tricks of git branch; projects vs. retainers; pricing retainer fees without knowing scope; machine learning in agriculture.

Episode 8 (31 July 2020)

Building embedded applications from QtCreator with Docker; Book review “A Philosophy of Software Design”; anatomy of race conditions; five premises of TDD; how to undo almost anything with git.

Episode 7 (30 June 2020)

Building a Qt SDK with Yocto; CMake resources; license track from FOSS-North (4 episodes); introducing project QtiPi; how C++ lambdas make your code better; embedded C/C++ unit testing with mocks; Qt for Automation renamed into Qt M2M protocols.

Episode 6 (31 May 2020)

My thoughts on 7 years as a solo consultant; building a Linux image with Yocto; book review “Accelerate”; building an app with Qt for MCUs on FreeRTOS; getting started with Yocto and embedded Linux (Boot2Qt); using modern CMake with Qt; introduction to Qt Quick 3D; Qt for WebAssembly; certified medtech products with Qt; licensing FUD.

Episode 5 (30 April 2020)

Docker builds from QtCreator; FOSS Qt releases possibly delayed by up to 12 months; book “Professional CMake: A Practical Guide” (the Qt chapter); mastering embedded Linux (4-part series about buildroot); patterns for managing source code branches; C++ standards support in GCC and Clang; book review “Accelerate”.

Episode 4 (31 March 2020)

Creating simple installers with CPack; license Qt for Small Business; revival of ARM9 chips; respectful and constructive code review feedback; the Matthew test: 15 steps to better embedded software; performance benefits of final classes; in-class member initialisation; trusted execution environment and ARM’s TrustZone; CMake resources: book “Professional CMake”, effective Modern CMake, effective CMake, modern CMake patterns, my articles about CMake.

Episode 3 (29 February 2020)

Less love for FOSS Qt users; benefits of relocatable Qt; Webkit port for embedded Qt; Tesla electronics 6 years ahead of Toyota and VW; manual update for 30,000 VW ID.3; questions to ask about software architecture, design and coding; is high quality software worth the cost?; technical inflation not just technical debt; software estimation.

Episode 2 (31 January 2020)

QML engine deletes C++ objects still in use; introduction to the SAE J1939 standard; Qt license changes; what TDD is and isn’t; TDD guided by ZOMBIES; hexagonal architecture (ports and adapters); prototyping for portability: lightweight architectural strategies; color theory for designers; color contrast for interface design.

Episode 1

Safe-guarding the (L)GPL future of Qt; find, fix and test firmware bugs without hardware; interview with Barbara Liskov; git on the command line in 5 minutes; Git Flow branching vs. trunk-based development; switching between different GCC versions.