There is no simpler way to make people understand the interest of algebraic software structuring than to take as an example the problems of elementary arithmetic that are asked to children in school. Even for an adult, they are not always simple because arithmetic requires more or less global understanding of the problem. But as soon as we apply the techniques of algebra, these same problems are solved with extreme ease because algebra allows us to focus successively on each fundamental characteristic of the problem independently of the others.

The same applies when applying algebraic software structuring to software development.

Although multiple methods of analysis have emerged, they are still much more linked to arithmetic than to algebra. A flowchart is constructed as general as possible and then cut out to distribute tasks. This flowchart is usually very complicated and the difficulties in mastering it intellectually are sources of errors sometimes discovered late during integration tests.

The algebraic software structuring, on the contrary, consists in identifying each elementary function which can obviously be an execution program but also a logical sequence, a data management program or an interface program with hardware elements (sensors, actuators, displays, etc.)

It is particularly important to note that the logical sequence is no longer disseminated in different programs but, on the contrary, entirely contained in one or more specific programs whose purpose it is. In other words, the logical sequence is not disseminated in the execution programs.

Once this step is completed, each elementary function thus identified is treated in a program of good quality (short, one function, one entry, one exit except possibly for switching programs)

Programs handling data of a similar nature are then gathered ("algebra" means "gathering") into modules. Each module is known to other modules only by its entry points and thus constitutes a subset whose access is perfectly controlled.

Thus the responsibility for the development of the different modules can be assigned to different engineers or even to different companies. This responsibility typically covers the following steps : analysis, programming, unit testing and documentation.