article: Every Prototype Is Also a Measurement Tool by markusgruen · Pull Request #140 · Zuehlke/software-engineering-corner

markusgruen · 2026-01-14T07:56:15Z

I am unfamiliar with git. I hope I did everything correctly....

Regarding the picture: I copied it from Unsplash. Am i required to put in a reference somewhere?

kunman93

very well written.

P.S. I used AI to review your PR, otherwise I wouldn't have found all of these findings.

kunman93 · 2026-05-05T12:45:45Z

+Whether it’s a completely new, innovative product or the next iteration of an existing one, I keep seeing the same pattern.
+
+Right from the start — during requirements definition, system architecture, and in early functional prototypes — one crucial element is often overlooked. 
+And this happens regardless of whether you’re developing an electric toothbrush, a coffee machine, or a medical ventilator.


Suggested change

And this happens regardless of whether you’re developing an electric toothbrush, a coffee machine, or a medical ventilator.

This happens regardless of whether you’re developing an electric toothbrush, a coffee machine, or a medical ventilator.

kunman93 · 2026-05-05T12:46:41Z

+And this happens regardless of whether you’re developing an electric toothbrush, a coffee machine, or a medical ventilator.
+
+From day one, the device is designed with the finished product in mind. 
+What's often forgotten is this: the path to that finished product is long, full of unknowns that must be explored, understood, and — most importantly — measured. During development, the final product doesn’t exist yet. 


Suggested change

What's often forgotten is this: the path to that finished product is long, full of unknowns that must be explored, understood, and — most importantly — measured. During development, the final product doesn’t exist yet.

What's often forgotten is this: the path to the finished product is long, full of unknowns that must be explored, understood, and — most importantly — measured. During development, the final product doesn’t exist yet.

kunman93 · 2026-05-05T12:47:45Z

+
+From day one, the device is designed with the finished product in mind. 
+What's often forgotten is this: the path to that finished product is long, full of unknowns that must be explored, understood, and — most importantly — measured. During development, the final product doesn’t exist yet. 
+It only emerges through countless iterations, tests, measurements, debugging loops, and insights.


Suggested change

It only emerges through countless iterations, tests, measurements, debugging loops, and insights.

It emerges only through countless iterations, tests, measurements, debugging loops, and insights.

kunman93 · 2026-05-05T12:48:40Z

+
+## The missing piece: measurability during development
+
+Especially in early phases, core functions of the device often need to be explored experimentally. 


Suggested change

Especially in early phases, core functions of the device often need to be explored experimentally.

Especially in the early phases, core functions of the device often need to be explored experimentally.

kunman93 · 2026-05-05T12:57:34Z

+**But for development, the opposite is true.**
+
+System integrators and engineers need access to all relevant signals — and since nobody knows at the beginning which signals will turn out to be relevant later, "relevant" effectively means *everything*. 
+All raw sensor data, all actuator control values, all internal states (such as state machine states), ideally at the native sampling rate. 


Suggested change

All raw sensor data, all actuator control values, all internal states (such as state machine states), ideally at the native sampling rate.

All raw sensor data, all actuator control values, and all internal states (such as state machine states), ideally at the native sampling rate.

kunman93 · 2026-05-05T13:10:15Z

+4.	**Selective logging:**  
+Developers choose only the signals relevant for the current measurement. This requires more logic and user interaction.
+5.	**Event-based logging:**  
+Useful for signals that change infrequently (e.g., system states). Harder to use with CSV because timestamps must be transmitted.


Suggested change

Useful for signals that change infrequently (e.g., system states). Harder to use with CSV because timestamps must be transmitted.

Useful for signals that change infrequently (e.g., system states) but harder to use with CSV because timestamps must be transmitted.

kunman93 · 2026-05-05T13:10:25Z

+Developers choose only the signals relevant for the current measurement. This requires more logic and user interaction.
+5.	**Event-based logging:**  
+Useful for signals that change infrequently (e.g., system states). Harder to use with CSV because timestamps must be transmitted.
+6.	**Separate channels:**  


Suggested change

6. **Separate channels:**

6. **Separate channels:**

kunman93 · 2026-05-05T13:17:18Z

+
+Both approaches can work — but only if the architecture supports them. 
+Once again, this brings us back to early design decisions. 
+Inter-controller communication must either be designed for the required data volume and frequency, or the main processor must provide a system clock or heartbeat that other controllers can synchronize to. 


Suggested change

Inter-controller communication must either be designed for the required data volume and frequency, or the main processor must provide a system clock or heartbeat that other controllers can synchronize to.

Inter-controller communication must either be designed for the required data volume and frequency, or the main processor must provide a system clock or heartbeat that other controllers can synchronize with.

kunman93 · 2026-05-05T13:22:53Z

+> A prototype that 'works' is useful".\
+"A prototype that is measurable is invaluable.


Suggested change

> A prototype that 'works' is useful".\

"A prototype that is measurable is invaluable.

> A prototype that “works” is useful. A prototype that is measurable is invaluable.

kunman93 · 2026-05-05T13:23:19Z

+
+Without complete and correctly timed measurement data, debugging becomes guesswork and optimization becomes trial and error. Planning a clear developer interface early saves time, reduces frustration, and dramatically accelerates product development.
+
+Or, to put it another way:


Suggested change

Or, to put it another way:

Or, to put it another way:

PhoenixZu · 2026-07-30T10:37:01Z

+## The missing piece: measurability during development
+
+Especially in early phases, core functions of the device often need to be explored experimentally. 
+Proofs-of-concept usually only answer a simple question: _Does it work at all?_ How it works in detail only becomes clear over the course of the project.


Suggested change

Proofs-of-concept usually only answer a simple question: _Does it work at all?_ How it works in detail only becomes clear over the course of the project.

POC'a usually only answer a simple question: _Does it work at all?_ How it works in detail only becomes clear over the course of the project.

PhoenixZu · 2026-08-05T07:25:16Z

+4.	**Selective logging:**  
+Developers choose only the signals relevant for the current measurement. This requires more logic and user interaction.
+5.	**Event-based logging:**  
+Useful for signals that change infrequently (e.g., system states). Harder to use with CSV because timestamps must be transmitted.


Suggested change

Useful for signals that change infrequently (e.g., system states). Harder to use with CSV because timestamps must be transmitted.

Useful for signals that change infrequently (e.g., system states), this is harder to use with CSV because timestamps must be transmitted.

PhoenixZu · 2026-08-05T07:34:19Z

+In one of my recent projects, I was fortunate: a logging function already existed, though not in the required scope.
+Extending it was accepted without much resistance.
+Still, it became clear once again that retrofitting logging late is far more work than planning it upfront.


Suggested change

In one of my recent projects, I was fortunate: a logging function already existed, though not in the required scope.

Extending it was accepted without much resistance.

Still, it became clear once again that retrofitting logging late is far more work than planning it upfront.

I was fortunate in one of my recent projects as a logging function already existed. Unfortunately it was not (yet) fit for purpose.

We were allowed to extend it without excessive deliberation.

That said, retrofitting the existing solution was more complicated than if we had planned the logging capability upfront.

PhoenixZu · 2026-08-05T07:38:47Z

+As a result, the entire data path — both between processors and in the logging output — had to be reworked to support native-rate raw data logging.
+It took more than a week of unplanned work before all raw data finally appeared correctly at the logging interface.


Suggested change

As a result, the entire data path — both between processors and in the logging output — had to be reworked to support native-rate raw data logging.

It took more than a week of unplanned work before all raw data finally appeared correctly at the logging interface.

As a result, the entire data path — both between processors and in the logging output — had to be reworked to support logging at the raw data rate.

It took more than a week of unplanned work before all of the raw data finally appeared correctly at the logging interface.

PhoenixZu · 2026-08-05T07:39:31Z

+As a result, the entire data path — both between processors and in the logging output — had to be reworked to support native-rate raw data logging.
+It took more than a week of unplanned work before all raw data finally appeared correctly at the logging interface.
+
+## Example: pressure sensor calibration during operation


Suggested change

## Example: pressure sensor calibration during operation

## Example: Pressure Sensor Calibration During Operation

PhoenixZu · 2026-08-05T07:39:53Z

+Inter-controller communication must either be designed for the required data volume and frequency, or the main processor must provide a system clock or heartbeat that other controllers can synchronize to. 
+These are not details you want to figure out late in the project.
+
+## Why logging must be planned from day one


Suggested change

## Why logging must be planned from day one

## Why Logging Must Be Planned From Day One

PhoenixZu · 2026-08-05T07:40:14Z

+A well-designed early concept saves time, makes the project more robust, and — most importantly — accelerates development.
+Debugging becomes painful when you can’t see what’s happening inside the system.
+
+## Example: logging in a highly complex distributed system


Suggested change

## Example: logging in a highly complex distributed system

## Example: Logging in a Highly Complex Distributed System

PhoenixZu · 2026-08-05T07:40:43Z

+
+The key takeaway: logging must be considered from the very beginning — during system architecture design, hardware design, and even component selection — to avoid performance issues later.
+
+## Distributed systems: logging across multiple controllers


Suggested change

## Distributed systems: logging across multiple controllers

## Distributed Systems: Logging Across Multiple Controllers

PhoenixZu · 2026-08-05T07:41:03Z

+Most importantly, the output must be synchronized to the system clock, ideally by including timestamps. 
+Without proper timing, measurement data quickly becomes ambiguous and hard to interpret.
+
+## When data volume becomes a problem


Suggested change

## When data volume becomes a problem

## When Data Volume Becomes a Problem

PhoenixZu · 2026-08-05T07:41:22Z

+All raw sensor data, all actuator control values, all internal states (such as state machine states), ideally at the native sampling rate. 
+Only with this level of visibility can you truly understand system behavior, develop features efficiently, analyze bugs, and systematically identify root causes.
+
+## Turning prototypes into measurement instruments


Suggested change

## Turning prototypes into measurement instruments

## Turning Prototypes Into Measurement Instruments

PhoenixZu · 2026-08-05T07:41:40Z

+What's often forgotten is this: the path to that finished product is long, full of unknowns that must be explored, understood, and — most importantly — measured. During development, the final product doesn’t exist yet. 
+It only emerges through countless iterations, tests, measurements, debugging loops, and insights.
+
+## The missing piece: measurability during development


Suggested change

## The missing piece: measurability during development

## The Missing Piece: Measurability During Development

PhoenixZu · 2026-08-05T07:42:44Z

+
+## Example: pressure sensor calibration during operation
+
+The same project also showed why logging actuator commands is just as important as logging raw sensor data — both at native frequency and fully time-synchronized.


Suggested change

The same project also showed why logging actuator commands is just as important as logging raw sensor data — both at native frequency and fully time-synchronized.

This same project also showed why logging actuator commands is just as important as logging raw sensor data — both at controller native frequency and fully time-synchronized.

PhoenixZu · 2026-08-05T07:44:54Z

+Without complete and correctly timed measurement data, debugging becomes guesswork and optimization becomes trial and error. Planning a clear developer interface early saves time, reduces frustration, and dramatically accelerates product development.
+
+Or, to put it another way:
+> We’re not just building a tea machine. First, we’re building a measurement instrument.


Suggested change

> We’re not just building a tea machine. First, we’re building a measurement instrument.

> We’re not just building a tea machine. First: we’re building a measurement instrument.

markusgruen added 11 commits January 13, 2026 15:37

Update AUTHORS.md

ad02534

Create index.md and paste blog post article

9402098

Update index.md - add date and adjust short description

d88e9f8

Create image folder

ea04a5e

delete dummy.txt

25a7943

Create images-folder

9beafe9

Add files via upload

e7acec3

delete dummy.txt

e407148

Update index.md - table, date

b956fd9

Update index.md - minor editorial changes

fd7477f

Update index.md - minor editorial changes

9e3d3b5

kunman93 reviewed May 5, 2026

View reviewed changes

PhoenixZu reviewed Jul 30, 2026

View reviewed changes

PhoenixZu reviewed Aug 5, 2026

View reviewed changes

PhoenixZu approved these changes Aug 5, 2026

View reviewed changes

	And this happens regardless of whether you’re developing an electric toothbrush, a coffee machine, or a medical ventilator.
	This happens regardless of whether you’re developing an electric toothbrush, a coffee machine, or a medical ventilator.

	What's often forgotten is this: the path to that finished product is long, full of unknowns that must be explored, understood, and — most importantly — measured. During development, the final product doesn’t exist yet.
	What's often forgotten is this: the path to the finished product is long, full of unknowns that must be explored, understood, and — most importantly — measured. During development, the final product doesn’t exist yet.

	It only emerges through countless iterations, tests, measurements, debugging loops, and insights.
	It emerges only through countless iterations, tests, measurements, debugging loops, and insights.


		## The missing piece: measurability during development

		Especially in early phases, core functions of the device often need to be explored experimentally.

	Especially in early phases, core functions of the device often need to be explored experimentally.
	Especially in the early phases, core functions of the device often need to be explored experimentally.

	All raw sensor data, all actuator control values, all internal states (such as state machine states), ideally at the native sampling rate.
	All raw sensor data, all actuator control values, and all internal states (such as state machine states), ideally at the native sampling rate.

	Useful for signals that change infrequently (e.g., system states). Harder to use with CSV because timestamps must be transmitted.
	Useful for signals that change infrequently (e.g., system states) but harder to use with CSV because timestamps must be transmitted.

	Inter-controller communication must either be designed for the required data volume and frequency, or the main processor must provide a system clock or heartbeat that other controllers can synchronize to.
	Inter-controller communication must either be designed for the required data volume and frequency, or the main processor must provide a system clock or heartbeat that other controllers can synchronize with.

		> A prototype that 'works' is useful".\
		"A prototype that is measurable is invaluable.

	> A prototype that 'works' is useful".\
	"A prototype that is measurable is invaluable.
	> A prototype that “works” is useful. A prototype that is measurable is invaluable.


		Without complete and correctly timed measurement data, debugging becomes guesswork and optimization becomes trial and error. Planning a clear developer interface early saves time, reduces frustration, and dramatically accelerates product development.

		Or, to put it another way:

	Proofs-of-concept usually only answer a simple question: _Does it work at all?_ How it works in detail only becomes clear over the course of the project.
	POC'a usually only answer a simple question: _Does it work at all?_ How it works in detail only becomes clear over the course of the project.

		As a result, the entire data path — both between processors and in the logging output — had to be reworked to support native-rate raw data logging.
		It took more than a week of unplanned work before all raw data finally appeared correctly at the logging interface.

	## Example: pressure sensor calibration during operation
	## Example: Pressure Sensor Calibration During Operation

	## Why logging must be planned from day one
	## Why Logging Must Be Planned From Day One

	## Example: logging in a highly complex distributed system
	## Example: Logging in a Highly Complex Distributed System


		The key takeaway: logging must be considered from the very beginning — during system architecture design, hardware design, and even component selection — to avoid performance issues later.

		## Distributed systems: logging across multiple controllers

	## When data volume becomes a problem
	## When Data Volume Becomes a Problem

	## Turning prototypes into measurement instruments
	## Turning Prototypes Into Measurement Instruments


		## Example: pressure sensor calibration during operation

		The same project also showed why logging actuator commands is just as important as logging raw sensor data — both at native frequency and fully time-synchronized.

Uh oh!

Conversation

markusgruen commented Jan 14, 2026

Uh oh!

kunman93 left a comment

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

3 participants

	The same project also showed why logging actuator commands is just as important as logging raw sensor data — both at native frequency and fully time-synchronized.
	This same project also showed why logging actuator commands is just as important as logging raw sensor data — both at controller native frequency and fully time-synchronized.

	> We’re not just building a tea machine. First, we’re building a measurement instrument.
	> We’re not just building a tea machine. First: we’re building a measurement instrument.