|
|
|
|
|
|
„Failure is just an opportunity to start over, this time more intelligently.” (Henry Ford)
|
|
|
|
|
 Newsletter in October 2026
- The later the Error, the more expensive the Fix
- It’s not a single Tool that matters
- Develop & Debug: Productivity starts long before Testing
- Verify & Observe: Analyse. Understand. Observe Continuously.
- Test: Make Quality reproducible
- Produce: From released Software to the finished Product
- The real Gain: Fewer unnecessary Repetitions
- Faster Development does not mean faster Coding
- Where is the Bottleneck in your Development Process?
|
|
|
|
|
| |
Why do the right tools, used at the right point in the development process, deliver greater value than isolated technical excellence?
An error detected during development can usually be analysed and corrected quickly. The same error discovered weeks later during system testing may already require considerable effort. And if it only appears in a product after delivery, it may be necessary to reconstruct conditions that no longer exist in the development lab.
The later the Error, the more expensive the Fix.
With every development phase an issue passes through undetected, the effort and cost required to resolve it increase.
The key question is therefore not simply:
How do we find errors?
But rather:
How early can we detect them, understand them and reliably prevent them?
|
|
|
 |
It’s not a single Tool that matters. A compiler can generate excellent code. A debugger can provide deep insight into a running system. Analysis and profiling tools make the behaviour of a real-time system visible in the development lab.
Continuous Observability extends this view: Actual runtime behaviour can be observed and analysed not just at a single point in time, but over an extended period – including remotely.
Automated tests safeguard functionality. And production tools ensure that validated software is transferred reliably to the final product.
Each of these tools performs an important task.
The greater commercial benefit, however, emerges when the tools are used where they can detect problems as early as possible, support development and troubleshooting processes effectively, and prevent avoidable errors from being carried into later project phases.
And when the insights gained do not remain isolated, but feed back meaningfully into the other development activities.
Because every error detected in an earlier development phase reduces the effort required in the phases that follow.
|
|
| |
DEVELOP & DEBUG:
Productivity starts long before Testing Efficiency starts during development itself. A powerful development environment and a debugger that provides fast, in-depth insight into the system shorten everyday development and troubleshooting cycles.
But debugging alone is reactive: a problem must first become apparent before it can be investigated.
That is why an efficient development process is not only about how quickly an error can be found, but also about how many errors can be prevented from reaching later development phases in the first place. What matters is not only each individual activity, but the continuous flow of insight throughout the entire development process.
|
|
| |
 |
VERIFY & OBSERVE:
Analyse. Understand. Observe Continuously. Verify & Validate and Continuous Observability examine the runtime behaviour of an embedded system from different but complementary perspectives.
Analysis and profiling tools such as SEGGER SystemView reveal what is actually happening inside a real-time system in the development lab. Tasks, interrupts and software timers can be examined with detailed timing information. This helps identify inefficiencies, resource conflicts and unintended interactions that are difficult to assess from source code alone.
Continuous Observability extends this point-in-time view. A system’s runtime behaviour can be observed and analysed over an extended period – including remotely and on devices already deployed in the field. This makes it possible to capture rare, timing-related or difficult-to-reproduce problems that may never occur under laboratory conditions or may no longer be reproducible there.
The insights gained do not remain isolated at the end of an analysis, but can feed back into development, debugging, verification and testing.
This connection is crucial: System behaviour is not only analysed at individual points in time, but remains observable over longer periods – turning it into a continuous source of information for the entire development process.
|
|
| |
TEST:
Make Quality reproducible What has been identified during development, analysis and observation must then be safeguarded reliably.
Automated tests turn individual findings into a repeatable process. Correc-tions can be verified, regressions detected early, and results documented in a traceable manner.
This also changes the commercial significance of testing: tests are not merely a final quality check.
They protect development work already invested from being lost again when later changes are made.
The more this process is automated, the less manual effort is required for each new software version.
|
|
| |
PRODUCE:
From released Software to the finished Product The end result of the development process is not finished source code, but a functioning product.
Here too, manual processes consume time and introduce the risk of errors. Reliable production programming ensures that released software is transferred to devices in a reproducible and controlled manner.
This completes the Chain:
Develop. Find errors. Verify quality. Understand system behaviour. Test automatically. Produce reliably.
Each of these activities has its own technical purpose. But they only become commercially compelling as an integrated process when as little information, time and previously invested development work as possible is lost between them.
|
|
| |
THE REAL GAIN:
Fewer unnecessary Repetitions The cost of a development process is not determined solely by tools, engi-neering hours or testing effort.
It becomes expensive above all when work that has already been done has to be done again:
An error discovered late sends the project back into development. A non-reproducible fault can occupy engineers for days. A change causes unex-pected side effects. An error that was already fixed reappears. A problem from the field has to be reconstructed at considerable expense.
This is precisely where the commercial value of an integrated tool strategy lies.
Not in using as many tools as possible.
But in avoiding unnecessary repetition, detecting errors earlier and basing decisions on better information.
|
|
| |
Faster Development does not mean faster Coding. Time-to-market is often equated with development speed. But writing code faster alone does not bring a product to market sooner.
What matters is how much time is lost between the first implementation and stable, tested, production-ready software.
When development tools, debugging, analysis and profiling of system beha-viour in the development lab, Continuous Observability in the field over an extended period, automated testing and production programming work to-gether effectively, the result is more than technical quality:
Development becomes more predictable.
Fewer surprises at the end of a project. Less troubleshooting effort that is difficult to estimate. Less repetition. And a better basis for reliable schedules and costs.
| |
| |
Where is the Bottleneck in your Development Process? Not every company needs every tool. And not every development process has the same weaknesses.
Perhaps troubleshooting takes too long in your organisation. Perhaps certain errors only become visible during system testing. Perhaps testing needs to be more highly automated. Perhaps there is insufficient visibility into actual runtime behaviour. Or perhaps an existing development process simply needs to become more efficient overall.
That is why a sound tool decision does not begin with a product catalogue.
It begins with the question of where time is currently being lost across the overall project workflow.
|
|
|
Kind regards, Marian A. Wosnitza
„Making smart mistakes is a great art.” (Federico Fellini, Italian film director & screenwriter)
|
|
|
|
|
|
|
|
|
