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).
My jobs involve the following responsibilities:
- Transforming a legacy software development team into a high-performing team or creating a high-performing team from scratch.
- Designing and implementing successful system architectures that evolve with the devices over the 10, 15 and more years of their lifetime.
- Developing complicated parts of the HMIs like communication with the machines, live animation of the machine operation, window manager, custom GUI libraries, remote support via VNC, OTA update, fast boot and secure boot.
In short, I help companies get higher-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 US Chip Ban Affect Your Business. It also contains links to my latest posts on embeddeduse.com and to interesting content around the web.
You’ll receive one episode on the 1st day of each month and one on the 15th of each month. I am looking forward to lively discussions with you by email or through the comment sections. I hope to welcome you as a reader soon.
Main Topic: Consequences of Choosing the Wrong HMI Terminal
My Content: KDAB Insights: Building a Smart User Interface – what’s really involved? (interview)
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.
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.
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.
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.
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
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.
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.
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
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.
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.
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).
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.
Developing a QML keypad with TDD; free smart machines from dumb user interfaces (UIs); alleviating chip shortage with cross-platform development; architecture decision records.
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.
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.
Pricing services: productised services, advisory retainers, workshops and trainings; estimating complexity.
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.
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.
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”.
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.
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.
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).
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.
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.
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.
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.
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.
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.
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.
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.
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.
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”.
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.
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.
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.
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.