Accomplishments

Summary

I am a senior software engineer who has spent my career taking applications from requirements to delivery: first in non-destructive testing (NDT) inspection systems, then in business and ISP applications, and today in modern C++/Qt 6 with a fully self-provisioned build and delivery chain. This document describes what I actually accomplished, in the areas where my own focus was, and not everything the systems around me involved.

Technically, I modernize and I make delivery reproducible. I recreated a legacy C++98/GDI jet-engine inspection application in Qt 6 for Linux and Windows, with unit tests and coverage reporting, Docker-based cross-platform builds, and distribution through an APT repository and Winget. I run my own GitLab and Nexus, so builds stay reproducible and independent of third parties. Organizationally, I make work traceable. At two employers I organized document traceability for a whole company of 35+ people, because document chaos hindered my work.

At a glance

Modernization and upskilling: C++98/GDI to modern C++, Qt 6 and OpenGL, cross-platform on Linux amd64, Linux aarch64 and Windows.
Quality: unit testing with Catch2 and CTest, gcovr coverage reporting, clang-format enforcement.
Reproducible delivery: Docker builder images, shared cmake-lib, Python build.py, GitLab CI/CD, Nexus, APT repository and Winget.
Independence: self-provisioned services, so pipeline outcomes stay consistent over time.
Traceability: company-wide document archives and records policies at AIMS-NDT and Hoogovens/NUSON.
Inspection systems: UT/ET inspection software, customer training and field work abroad.
Full-lifecycle ownership: sole developer of the in-house framework and SaaS applications at Domussoft, and framework, label websites, order management and recurring invoicing at Cambrium.
Embedded: build and development environment (CMake, shared bash scripts, remote debugging) and Scrum bug fixing at Vialis.

Document Traceability & Organization

Not all of my accomplishments are code. Some of the most valuable work I did was making a whole company's documents findable and traceable, because document chaos got in the way of my own work.

What I did

At AIMS-NDT and at Hoogovens Technical Services / NUSON I organized document traceability for a whole company of 35+ people.
I did it because I could not do my engineering work properly while documents, versions and decisions were scattered. Fixing it for myself meant fixing it for everyone.
The CV records this as developing and overseeing the policies and procedures for managing the organization's records throughout their life-cycle.

The approach I keep using

The current form of this approach is written down in my own wiki (../wiki/Doctrine/Organize):

One logical, traceable archive structure. Documents that go out to third parties and internal departments live in a clearly structured archive, with relevant e-mails (for example, decisions by external stakeholders) archived alongside.
Templates for every new document. Each document starts from a template, so tasks are transferable to others and communication is structured.
Traceable references, a single source and frozen published versions. A published document does not silently change, and there is one place to find the truth.
Quality-management mindset. The archive is written as the start of a QMS in the context of ISO 9001:2015, to reduce miscommunication between parties inside and outside the company.
Transferable work. My rule of thumb is that work is not done when the software works but when the work can be transferred to other developers through its documentation.

Carrying it forward

At Vialis I applied the same mindset on a smaller scale by documenting procedures and conventions for developers in the wiki (see Embedded & Traffic Control).
In my own projects, I keep a wiki with coding standards, naming and Git conventions (../wiki/Doctrine/Software), and a local search engine to find information in the wiki and project documentation.

Sources: CV (AIMS-NDT, Hoogovens Technical Services), docroot/wiki/Doctrine/Organize/*, docroot/wiki/Doctrine/Software/*.

Modernizing a Legacy Inspection Application (Qt 6)

Since 2019 at Scanframe BV, I have been recreating a past jet-engine parts inspection application in Qt 6. The original was built with Borland C++ Builder (C++98) on the Windows GDI. The goal of the project is to keep learning and to adopt contemporary development practice. My focus here is modernization and upskilling, not showing off architecture.

Upskilling and modernizing

I moved from C++98 and Windows-only GDI to modern C++ (14/17/20), Qt 6 and cross-platform deployment on Linux amd64, Linux aarch64 (Raspberry Pi 5) and Windows amd64.
I build the Qt 6 libraries from source for each of these targets and keep them in my own Nexus repository, so the application does not depend on whatever Qt build a third party provides.
I am modernizing a legacy OpenGL 2.x graphics implementation to OpenGL 4.x by writing a C++ wrapper library that uses templates to simplify the pure C OpenGL API. Related experiments include a single shared OpenGL render context with dockable Qt windows, and rendering DXF drawings in OpenGL.
I replaced hand-made practices with tool-enforced ones: a clang-format Git pre-commit hook plus a check script in the first job of the pipeline, and Doxygen API documentation generated through CMake.

Unit testing with coverage reporting

I introduced unit and integration testing with Catch2 driven by CTest.
I added gcovr coverage reporting, produced both during development and in the CI/CD pipelines through CMake, so test quality is visible and not just assumed.
The reusable test project shows Catch2 and GoogleTest integration, Doxygen and coverage through the shared build module, so every new project starts with this in place.

Cross-platform builds with Docker

I created Docker containers and a script to build and test the application the same way for developers and in the CI/CD pipelines.
The Qt 6 builder image is built for Linux x86_64 and aarch64. The Qt library is built three times (Linux x86_64, Linux aarch64 and native Windows) and stored in a versioned layout.
Windows builds are also run on Linux through Docker and Wine. The same build.py command pattern (native, Wine, or Docker) is used for every toolchain.
Cygwin with a Git repository of scripts and an auto-installer PowerShell script lets the same Linux shell tooling build natively on Windows.

Distribution: APT repository and Winget

Linux: the application is packaged with CPack (Debian packages) and distributed through an APT repository hosted on my own Nexus.
Windows: I created a portable Winget package and worked through its constraints, such as executables that need DLLs in their own directory when started from a symbolic link (../discovery/372-winget-portable-problem.md).
Results: a developer or tester can install a tested build with the native package tools of each platform.

Build, Delivery & Reproducible Infrastructure

The common thread of my infrastructure work is reproducible builds and independence from third parties. I run all services myself, so pipeline outcomes stay consistent over time.

Self-provisioned services

GitLab for source control and CI/CD: automated build, test and deployment pipelines driven by CMake.
Sonatype Nexus as a repository for Docker images, the Qt libraries and the application distribution through APT. This includes an Apache/SSL proxy and package routing.
Docker builder images that I rebuild from a base image in my own registry, including the Qt library, for several architectures, from my own sf-docker-runner repository. Because a build image is versioned and stored, an old release can be rebuilt with the same toolchain later.
Ansible (run through a Docker container) to automate updates of the LXC containers hosting my services. I treat this as a small supporting tool that I learned on my own systems.
A local search engine to find information in the wiki and project documentation.

Shared build tooling

cmake-lib, a shared Git submodule used between projects: toolchains, CMake presets, Qt discovery, test and coverage integration, Doxygen and CPack packaging. A new project gets one common build interface instead of recreating platform-specific logic.
build.py, a Python script around the CMake presets. It configures, builds, tests, packages and runs for native, Docker and Wine toolchains, with a dynamically loaded subcommand design so the script stays maintainable.
A boilerplate test project that exercises the entire path from checkout to tested, versioned packages in Nexus.

Operational tooling

Python tools to clean up failed GitLab pipeline jobs and obsolete Docker image blobs in Nexus, including a Docker image that compiles Python executables for Linux and Windows. Nexus later implemented the blob cleanup itself.
I analyze and document problems in the chain, for example a Docker/Nexus problem, so the fix is reproducible and not forgotten.

Software Design Themes

I do not claim these as the focus of the Qt 6 project. They are design ideas I developed over many years in the original inspection systems and re-implemented in the Qt 6 rebuild, which is why they are worth noting.

Modular, event-driven widgets and property sheets. Reusable custom widgets with property pages for configuration, inheritance-driven dynamic UI generation and real-time updates from data streams (../discovery/957-experience.md).
Script engine and debugger. A script engine with C++-like syntax, compiled to a small instruction set with jumps, used to connect events between modules, organize application startup, run background processes and handle hot keys.
Dynamic libraries. Interfaces loaded at runtime, so modules can be added without rebuilding the application.
Global information interface. One interface for modules to exchange information events.

Inspection Systems (NDT)

My career started in non-destructive testing (NDT): ultrasonic (UT) and eddy-current (ET) inspection systems. The emphasis of my work in these roles was inspection software development and customer training and field work.

AIMS-NDT (1999–2005)

AIMS-NDT develops UT and ET inspection systems, sold mainly to the aircraft industry all over the world.

I designed and developed inspection systems and device software running on Windows NT/98 and DOS, in C/C++ and Delphi.
I trained customers on site on these systems, in various countries.
I organized company-wide document traceability and records policies.

Hoogovens Technical Services Inspection Systems (1994–1996) and NUSON Inspection Services (1996–1999)

The company (taken over by another owner and renamed in 1996) developed ultrasonic inspection systems, mainly for inspecting steam generators in nuclear power plants, such as power stations, submarines and aircraft carriers.

I developed ultrasonic inspection software and systems in C/C++ for Windows NT and MS-DOS.
I carried out inspections in nuclear power plants in foreign countries, as operator/supervisor of an inspection team using these systems.
I trained customers in operating the systems, wrote the software manuals for installation and usage, and gave technical assistance to the marketing department.
I organized document traceability and the records life-cycle policies for the company.
I obtained the ASNT NDT UT Level II certification in 1994.

Enter-Mbedded (2006–2007)

As a software consultant I developed C++ software for a security system that detects foreign materials on the human body using ultrasonic waves.

What carried forward

The inspection domain explains why I think in terms of data acquisition and visualization, and why the Qt 6 rebuild targets a jet-engine parts inspection application. Several design ideas in Software Design Themes originate here. My CV expertise list also records the technical background: digitizer and data acquisition interfacing, UT and ET technology and analysis, and motion controllers for a 6-axis 3D manipulator.

Business Applications & ISP Services

Domussoft BV (2008–2016 part-time, 2016–2019 full-time)

Domussoft is a company of two people. I was the sole developer and did all the development, while my partner had the financial knowledge, which I implemented in the SaaS applications. I also had direct customer contact about feature implementations.

In-house application framework. I built a PHP application framework, because there was none at the time, and used it as the base for the SaaS web applications (PHP and MySQL on Linux).
Home-owners association (VvE) management application with a financial administration: bookkeeping using a ledger system and sub-administrations, customer relationship management, contribution prolongation via the division deed, a (trouble-)ticket system, order processing to suppliers, quotation assessment, invoice authorization, member meetings, direct debit and direct credit, and a portal with overviews for owners.
Financial project-management application for insight for management and project leaders, initially made for hospitals. It imports data from the customer's bookkeeping software using a web service or files and aggregates thousands of projects into transparent information. It includes relations management, a ticketing system, contract variation, a meeting module and the generation of many overview documents in PDF.
I stayed in direct contact with customers about the features they wanted, so the applications followed real needs.

Cambrium BV (2005–2016)

Cambrium is an ISP that sold internet, phone, TV and Usenet services to other ISPs and private customers.

Framework and websites. I designed a framework and used it to build websites from graphical designs for the ISP's multiple labels.
Subscription orders. The websites were able to take orders for subscriptions.
Order management and invoicing. I designed the order management process that processed these orders, in combination with recurring invoices paid through SEPA direct debit.
Internal and external web applications to administer the production systems and for customers to control their internet services (PHP, MySQL and SOAP).
NNTP service. I developed a Linux NNTP protocol service for binary Usenet in C++.

Sources: CV (Domussoft, Cambrium), clarification answers.

Embedded & Traffic Control (Vialis)

Vialis VRI / VolkerWessels (2023, via Yer) as Software Engineer C++ in a department developing traffic control system (VRI) embedded software and roadside interface services. My emphasis was the build and development environment and bug fixing in an Agile Scrum setting.

Build and development environment

I migrated an old C++ Netbeans project to a modern CMake build project.
I developed a repository of shared bash scripts to perform complex tasks, such as setting up a development environment from scratch and remote debugging of embedded systems.
The department had built up a technical debt over more than 20 years. I spent time on wiki documentation of procedures and conventions for developers on creating and using a development environment, with a cross compiler in a Linux virtual machine hosted by Windows.

Bug fixing in Agile Scrum

I mainly solved software issues in an Agile Scrum setting, working on Redmine tickets.
The embedded software is mostly C/C++ and uses CAN bus for interfacing external hardware. The roadside services are written in Java.
I also created and tested interface protocols and client stubs with Python scripts and the Robot framework (a minor part of my work there).

Sources: CV (Vialis), clarification answers.

Career Timeline

Period	Employer and role	My focus
Now	Up skilling and modernizing my development practices	Qt 6 rebuild, testing, reproducible delivery
2023	Vialis (via Yer), Embedded Software Engineer	Build/dev environment (CMake, shared bash scripts, remote debugging, wiki) and Scrum bug fixing
2020–2022	Multiple small companies in different positions	Various positions
2019–present	Scanframe BV, Senior Software Engineer	Qt 6 modernization, unit testing with coverage, Docker builds, APT and Winget distribution, self-hosted infrastructure
2016–2019 (full-time), 2008–2016 (part-time)	Domussoft BV, Senior Software Engineer	Sole developer: in-house PHP framework and SaaS applications, partner's financial knowledge implemented, customer contact
2006–2007	Enter-Mbedded, UT/Software Consultant	C++ software for an ultrasonic security system
2005–2016 (2005–2006 full-time, 2006–2016 part-time)	Cambrium BV, Senior Software Developer	Framework, label websites with subscription orders, order management, SEPA recurring invoicing, C++ NNTP service
1999–2005	AIMS-NDT BV, Senior Software Engineer	UT/ET inspection software, customer training abroad, company-wide document traceability
1996–1999	NUSON Inspection Services, Software Engineer	UT inspection software, field work, customer training, document traceability
1994–1996	Hoogovens Technical Services - Inspection Systems, Software Engineer	UT inspection software, nuclear plant inspections abroad, manuals, document traceability, ASNT UT Level II
1990–1995	Earlier roles and graduation project (Philips Physics Laboratory, Zondag, Philippart, Electron Fabrikage, Compaq Distribution Center Europe)	Technical, system administration and project engineering roles