User:Tal.architect/sandbox

Persistence Free Architecture is a software design schema that offers complete reliable and robust business flows without the necessity to have a local persistence solution. The general idea is to have a software solution that overcomes external failures, is able to restore its “required” state and continue without the need to have a local persistence infrastructure. E.g. overcome unexpected shutdowns and software crashes. In part of the cases, the “required state” will not necessarily be the exact last known state, but rather a state that allows the software to continue the expected work. In other part of the cases, the “required” state will be the last known state and the software can simply continue its work. Both approaches provide high reliability, ongoing performance improving, simplicity. However it may lead to a minor efficiency degradation during the initialization stage. The schema motto is “prefer smart recovery over ongoing expensive persistency maintenance”.

The architecture schema was first defined in NICE Systems Ltd, and was later implemented in several projects.

Motivation
Having a local persistence solution inside a piece of software is expensive. Practically, systems with local persistence usually suffer from ongoing and continuously poor performance, maintaining complex code and are required for in depth testing scenarios. These testings are usually out of the business scope. In addition to that, such systems are based on multiple layers design and implementations in the main flows, that by that also introduce complex troubleshooting processes and possible expensive integration with 3rd party solutions.

Taking that, if a software could carry out tasks without the need to worry about persistence ongoing maintenance, it would immediately result with much more efficient and robust solution.

Main Concept
The good news is that most of the systems do not need local persistence layer regularly. Internal information is maintained in memory, and other system information is already maintained in a central storage location, e.g. external database or file system. Since the persistence layer is then used to keep valuable state information in case of crashes, it means that it is needed only during recovery flows. At the same time, as mentioned, these SW products work as an integral part of a bigger system. Such big systems usually have their own central persistence solution (e.g. central database, central file system storage) that all surrounding services work with. Thus taking out the persistence basically means that the Persistence Free Architecture needs to focus on handling those recovery scenarios smartly.

For this, one of the following two approaches can be implemented:

1. “Restore” - Design a local recovery solution that can effectively leverage only the central persistence solution and to restore and continue from the required (current) stage.

2. “Ignore and continue” - Ignore the required state and simply continue the work by starting a new task. This by taking into consideration that part of the done work can be lost and need to be processed again.