A New Software Architecture for the Wise Object Framework:

Multidimensional Separation of Concerns

Sylvain Lejamble

1, 2 a

, Ilham Alloui

2 b

, S

´

ebastien Monnet

2 c

e Savoie Mont Blanc, Annecy, France

Those consist of distributed communicating software objects (Wise Objects) able to autonomously learn on

how they behave and how they are used while demanding little attention from their users. A WO is either

delivering a service (Awake state) or simulating its operation to learn behavior that has not occurred yet (Dream

state). In its first version, WO architecture has been designed on the basis of a single component embedding

built-in mechanisms for data monitoring and analysis. This architecture has major drawbacks we encountered

when using WOF to develop new applications: (1) built-in mechanisms embedded within the WO do not allow

using data by other components such as new analyzers, (2) raw data and data resulting from analysis in Awake

or Dream states are not distinguished, (3) mandatory components to self-adaptation are missing especially

those for action plan construction and execution. In this paper, we address those limitations through a MAPE-

K compliant architecture, based on the Separation of Concerns(SoC) and an event-driven publish/subscribe

ducing the effort required for human-machine interac-

tion. It must also be able to detect unusual situations

(error, unexpected behavior...) and manage them (cor-

rect, alert a suitable person to its resolution...). Self-

adaptive systems are an open area of research that ad-

dress many of these issues with the goal to let IT pro-

fessionals focus on business higher value-added tasks.

For this purpose, we developed WOF, a Wise Object

Framework to build self-adaptive software systems

we name “Wise systems”. A Wise system consists of

https://orcid.org/0000-0002-3713-0592

c

https://orcid.org/0000-0002-6036-3060

d

https://orcid.org/0000-0001-7684-6502

to monitor their functioning in order to acquire ex-

perience on their operation and hence on the use of

the system (“Real logs”). Logs analysis guides the

system towards an action plan (self-correction, adap-

tation, optimization...). Each time a WO is requested

state” and “Dream state”. The WO ability to discon-

nect from the real world is a strong feature that dis-

tinguishes wise systems from other self-adaptive sys-

tems. WOs may execute some parts of the system

without impacting the real operation (Business do-

main). These “simulations” have several goals: (i)

learn more about rare (fewly used) operations on the

system, (ii) create state-transition behavioral graphs

of the system, and (iii) create credible/realistic data to

help analyzing real functioning of the system. During

ones, we call them “Dream logs”. The existing WO

architecture in the WOF (Alloui et al., 2018) does not

meet the requirements regarding the adaptation of the

framework to complex applications. Indeed, in its first

version, WO architecture has been designed on the

basis of a single component embedding built-in mech-

be them from Awake or Dream states are not distin-

guished, (3) mandatory components to self-adaptation

are missing especially those for plan construction and

execution. In this paper, we address those limitations

through a MAPE-K compliant architecture, based on

the Separation of Concerns and an event-driven pub-

lish/subscribe mechanism. This is related to the gen-

eral issue of wise system maintenance, reuse and evo-

lution. Separation of Concerns is done according to

different dimensions that are managed using hyper-

its of the current architecture. Section 5 explains the

solution we propose to handle present limitations. Fi-

nally, Section 6 concludes the paper and opens some

interesting perspectives.

2 RELATED WORK

To meet the growing demand for more complex prob-

lems, IT professionals are striving to build even more

complex systems. These high-value-added systems

are very efficient but are becoming increasingly diffi-

tem (Ravindranathan and Leitch, 1998), modifying its

components without waiting for the next maintenance

periods to limit human interactions (Naqvi, 2012)

or even evaluating its performance and changing its

strategy when it is not performing enough (Cheng

et al., 2009).

Self-adaptive systems are an open area of research

that can address many of these issues. If the system

can solve a problem itself, then IT professionals can

focus on higher value-added tasks for the business.

Although a system is highly dependent on its appli-

cation domain, all self-adaptive systems have similar

operation logs and make them available to the other

lyze its past operations in the manner of an expert and

draw a conclusion: is the system functioning appro-

sis results to produce a strategy addressing the prob-

applies this plan to make the system perform a cor-

logs, analyzes, metrics, topological information, ac-

Separation of Concerns (SoC) (Dijkstra and Edsger,

1982) becomes essential while developing very com-

types of Separations of Concerns

aration (separation through functionalities), (ii) verti-

cal separation (dividing the application into modules),

(iii) aspect separation...

MAPE-K provides the ability, by defining dis-

tinct blueprints, to separate priorities and thus to ac-

celerate and simplify software development (Parnas,

1972). The multidimensional separation of priorities

is interesting when a system may have to deal with

separation-of-concerns/

was focusing on an orthogonal separation. They be-

lieve that the future of software development requires

a ”simultaneous separation of overlapping concerns

in multiple dimensions”. They also show that their

work was already partially done in Subject-Oriented

Programming (Harrison et al., 1993)(subjects are hy-

concerns that might be separated. (Makabee, 2012)

use an Event-driven approach to spot entangled con-

cerns and separate them from other functionalities.

He also compares Event-driven and Aspect-Oriented

approaches and show that Event-driven programming

has several advantages over AOP (more reusable, al-

lowing inheritance and concurrent execution...).

developed around the notion of WO (Alloui et al.,

2018). This framework opens up the possibility of

using the WO concept in a classical computer appli-

cation. It allows the use of a simple @WiseObject an-

notation in the declaration of the target object to mon-

itor all its status changes. By doing so, a proxy is auto

generated wrapping the original object. It also con-

will cause the object to fall into an unwanted state.

Within the framework, WOs are able to commu-

nicate with each other through a software bus (pub-

lish/subscribe). The communication is done through

event condition action rules (ECA) established by a

manager. By detaching components from this soft-

ware bus, it is possible to work with small parts of the

application without impacting the system.

when using up(), the object discovers that it can enter

a different state if it applies the procedure it just dis-

covered. The use of Dream state improves the overall

system perspectives. By analyzing produced logs, we

are able to enrich the knowledge we have about the

system. For example, we can confront the theoreti-

pertise. For example, with a statistical analyzer, we

can compute temporal metrics on the functioning of

the object. By interpreting the results, it is possible to

detect anomalies (e.g.: switch unusually Up on 16/03

from 6pm to 7am) and then warn the user.

the end of the Dream that all possible business states

and the transitions between them would be discov-

ered. Since we only had a few possible alterations,

the system never ends up in an incoherent state. If

we make the system dream with parameterized meth-

ods in a random way(random function with random

parameter), we risk finding impossible values when

using the system in a business context. Furthermore,

state change methods were hard-coded with restrict-

ing boundaries (we can call up when the object is

lem is therefore the following: we want to discover as

many business states of the system as possible and at

the same time we want these findings to be relevant.

To overcome this problem, we have chosen to ana-

lyze the parameters before asking the Wise Object to

use them (during Dream state). This allows the sys-

tem to get closer to the human, i.e. the human dreams

about his past experience and not randomly. In or-

der to analyze these parameters, we need to be able

to distinguish at the software level what really hap-

pened (real logs) from what we asked the system to

do to discover its states (dream logs). This is not pos-

ter adaptability and re-usability. A multidimensional

separation seems to be necessary at the analysis level

as we would like to stack non-vital part of the appli-

cation. Parameter analysis will not be detailed in this

paper but will surely be the subject of a more detailed

study.

multiple roles but mandatory components of the

We propose an upgrade of the current WOF archi-

tecture as well as an extension including the last el-

ements of the MAPE loop. We built the meta-model

presented in Figure 3. This model represents only the

interactions between a single WO and its own feed-

back loop. We made the decision not to present the

entire WO System because we did not change inter-

actions between WOs. The meta-model is detailed

component by component in the next sections.

In the previous works, we had 2 possible states of the

advantages: consumption of unnecessary resources,

production of redundant logs, higher complexity of

the analysis. So we decided to add a third state Idle.

This state allows the object not to perform any action

when the system does not hold the object.

As shown in Figure 4, the Dream is now included

in the new Idle state. The WO is not allowed to dream

until it knows what it has to dream. The WO can

dream when it is in the Idle state and receives a dream

plan request. Once the dream is finished, the WO falls

them. This is a huge step forward in terms of mainte-

nance and re-usability.

In the precedent architecture, the WO shared too

much responsibilities with other parts of the system.

The WO should only do his business job without

worrying about the other components of the MAPE

loop. As shown in Figure 5, we separate the Moni-

toring/Analysis/Knowledge steps because this would

help along interoperability of components.

We chose to use a WiseEventManager from Fig-

ure 3 inside the memory. This manager has the role to

store the data in an appropriate passive storage.

We want the planner to be standalone in order to deal

with the Separation of Concerns. In the Awake state,

the planner uses the results of the analysis in order

to decide if the original call for the object has to be

modified. If it notices an irregularity, it generates an

action plan to correct it. In the Dream state, the plan-

ner decides to use the parameter analysis to send an

plan. Policies (Kephart and Chess, 2003) are defined

as a high-level configuration file. It contains business

objectives that can be different if we want to use the

same system in diverse environments. For example,

if the policy is set with max unusual uptime=2h, the

planner consumes this plan while looking for the anal-

ysis. A switch unusually Up on 16/03 from 6am to

7am will not generate a plan.

In our architecture, we choose to generate a plan-

ner in parallel to an analyzer, but our architecture is

The executor did not exist in the previous version.

It joins all the plans made by the planner so that

the object can understand what it has to do. Un-

like many self-adaptive applications, the executor has

an additional responsibility. It has to call/modify

executor. The Reaction Executor has been introduced

to apply Awake plans that have an impact on the real

system. Meanwhile, the Dreamer only applies Dream

plans. The Dreamer’s actions have no impact on the

system since in the Dream state the WO is discon-

nected from the bus.

We introduced IAPE-K (Alloui and Vernier, 2017)

in our previous paper. IAPE-K is nothing else than

an adaptation of MAPE-K when the object is in the

same data structure. The only difference will be a flag

Figure 3: Meta-model of the new architecture.

edge generator monitors all the states of the object, it

knows where to store the usage logs.

A manager is thus necessary within the knowl-

edge, it will have the role to allocate the logs to the

right place of the knowledge. It receives data from di-

verse sources WO(Awake/Dream), Analyzers and put

them in their own storage. Note that a manager is not

mandatory in the Plan/Execute steps. As opposed to

Memory, Planner/Executor are active elements. They

can therefore dispatch the data themselves.

Driven system while keeping different functioning in

the boxes below. For example, Analyzers primitive

units (WEvent) are similar but how they update their

knowledge will be different. In Figure 8, we rep-

resent an example of some MAPE loop components

along the horizontal axis. Similar slices are also re-

grouped into hyper-modules where we can see feature

decomposition along the vertical axis. The knowl-

edge hyper-module can be seen as a data dimension.

Even if the methods have the same names, knowledge

slices store their WEvent at different places. It also

publishes to different modules like Planners, Analyz-

ers according to the type of WEvent. It is worth to

note that there is no relation along the vertical axis

between modules.

the whole knowledge block. The multidimensional

Separation of Concerns is very useful in our analysis

management. Each analysis will surely have different

dependencies (statistics, deep learning, set theory...).

Since they do not interact directly with each other,

this makes modularization easier by creating several

independent layers. We will use the notion of Hyper-

Slices from (Tarr et al., 1999) in order to increase di-

mensions with each addition of analyzer. For the mo-

ment the analyzers do not interact with each other as

tecture where a same entity (WO) embed several re-

sponsibilities, we propose a new architecture based on

the separation of concerns and on an even-driven pub-

lish/subscribe mechanism. Separation of concerns is

done according to several dimensions: MAPE-K loop

model, Real knowledgevs. Dream knowledge, com-

ponents with similar responsibilities. To complete the

MAPE-K loop, we also implemented Plan construc-

tion and Execution components that were absent in

the previous version of WOF.

components to interact only with the relevant part of

knowledge they need .

With this new architecture, we plan in the short

term to develop Markovian and deep learning analyz-

Figure 8: Example of components of the MAPE-K loop using hyperslicing visualization.

ers in addition to the existing graph and statistical an-

alyzers. Developing different analyzers is crucial to

the reliability of self-adaptive systems: analyzers may

either discover faster new states of the monitored ob-

ject or draw better conclusions about its functioning.

Moreover analyzers of operation’s parameters seems

rally will implement different Plan and Execute com-

ponents dedicated to both Dream and Awake states

of a WO. A first “dreamer” will be a smart dreamer

that takes into account the WO experience (real data)

instead of randomly simulating data. Regarding ex-

ecutors, the first one will simply authorize or not exe-

cution of the planned actions.

We also intend to study in future work how

to improve the new architecture, by introducing a

higher level where knowledge related to a WO can be

Alloui, I., Esale, D., and Vernier, F. (2015). Wise objects for

Alloui, I. and Vernier, F. (2017). A wise object framework

Brun, Y., Serugendo, G. D. M., Gacek, C., Giese, H.,

Dijkstra and Edsger, W. (1982). On the role of scientific

Gouda, G, M., Herman, and Ted (1991). Adaptive program-

Harrison, William, Ossher, and Harold (1993). Subject-

Makabee, H. (2012). An event-driven approach for the sep-

Moreira, A., Rashid, A., and Ara

´

ujo, J. (2005). Multi-

Naqvi, M. (2012). Claims and supporting evidence for

Ravindranathan, M. and Leitch, R. (1998). Heterogeneous

Tarr, P., Ossher, H., Harrison, W., and Sutton, S. (1999). N