I had an idea that I was considering with some colleagues. None of us knew if it existed at present. The main room should have a system that has 100% uptime, but can become more efficient dynamically.
Here is the scenario:
* Thus, we quickly display the specified set of interfaces for the system, it has zero optimizations, but we are sure that it is 100% stable though (questionable, but for the sake of this scenario, please play along)
* Then we profile the source classes and start replacing programs for bottlenecks.
* Original and replacement are initiated simultaneously and synchronized.
* The original is allowed to run until completed: if the replacement hasn't been completed, it vetoed the system as a replacement for the original.
* A replacement should always return the same value as the original, for a certain number of times, and for a certain range of values, before it is accepted as a replacement for the original.
* If an exception occurs after a replacement, the system automatically tries to perform the same operation with the class that it was replaced.
Have you seen a similar concept in practice? Criticism Please ...
The following are comments written after the initial question regarding messages:
* The system demonstrates a Darwinian approach to the evolution of the system.
* Original and replacement will work in parallel not in a series. * Race conditions are an integral issue for multi-threaded applications, and I recognize them.
source
share