Using platform thinking enables the development of flexible and reusable technologies for various robot applications. But how can you implement newly developed software into existing products and at the same time ensure that it only improves functionality instead of deteriorates it? This blog discusses the use of early adopters to test and implement new software and ensure product stability.
The difficulties of layered applications
As described in our previous blog about platform thinking, the applications within Smart Robotics are built around a core software platform. This platform contains the basics to control the robots, keeps track of performance and statistics, features the use of cameras, and much more. All these components are subject to change. Changes can include bug fixes, stability or performance improvements, a complete restructure, or the addition of new functionalities. It is important to ensure that, for instance, changes in the core software do not break any functionalities of the applications currently using specific parts of that changed code. Even though most software can be tested using continuous integration (CI) and by implementing it in an actual hardware test setup, it is impossible to tackle all situations that can arise.
Two kinds of software changes
When looking at changes in the core software and how they can affect other applications, there are two different types of changes to take into account. Both types of changes have a different size of impact, and are therefore tackled in a specific way.
- On one hand, there are small changes that come from application specific requests or slight improvements in the software code. For example, the addition of extra collision features in a world model. This type of changes may find their way deep down into the core software and therefore affect all applications. Most of the times, these changes will not negatively affect the other applications, but nonetheless they should be tested before updating the systems in the field.
- On the other hand, there are changes that are more comprehensive. These changes can be a complete restructure of (a part of) the code, which might affect applications. For example; a new motion executive which is a complete new implementation of controlling the motions of the robot. Even though one always tries to keep the application working at least at the same level as before, unforeseen problems can always pop up
Early adopters to test comprehensive changes
The more comprehensive software changes should be tested extensively to make sure the applications still work as they should. At Smart Robotics, besides Continuous Integration (CI) and Unit Testing, we also use early adopters. Early adopters are smaller projects and applications in the field that can be used to test most of the comprehensive developments without compromising on stability and performance. Using early adopters for software testing provides several advantages:
- Because early adopters are smaller projects, they are usually the “easier” projects. This provides the opportunity to implement and test the software changes faster compared to the larger projects.
- Because it is a relatively simple and fast implementation, it is also easier to find out whether everything works as expected and the application still functions as it should. Additionally, the bugs that might occur are less complicated and can be isolated and fixed more easily.
- After implementation, the updated application can be tested in the field without too much risk. For these smaller projects, field testing is easy to manage and maintain. Equal to the first implementation, possible problems and their causes can be found and solved more easily due to the relatively simpler application.
From early adopters to all applications
Once the early adopters applications work at a stable level, the implementation and testing on the other, larger projects will begin. Because of the extensive testing, developers of other projects and applications can expect the code to be stable and robust. Therefore, all applications benefit from the work done by the early adopters.
Early adopters to create robust and reliable products
By using early adopters it can be ensured that new developments are tested more extensively. Without using early adopters, the more comprehensive code changes would be less reliable and robust, and may even result in problems such as down time at customer plants. Due to the fact that early adopters create the possibility to test and actively monitor new implementations, we at Smart Robotics can make sure that our robot solutions are stable, reliable, and that we continuously improve performance and user friendliness.