Newsletter: Burkhard on Qt Embedded Systems

Topics of Past Issues

I discontinued my newsletter after 28 episodes.

Episode 28

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.

Episode 26

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

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

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

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

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

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

Episode 20

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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.