Adaptation of the Notification Oriented Paradigm (NOP) for the Development of Fuzzy Systems

Abstract

The Notification Oriented Paradigm (NOP) combines and evolves the event based programming with the declarative programming in order to solve some problems of both paradigms. Breaking down one application into a network of smaller computational entities, such as logic-causal and factual notifier entities that processes only when needed, the NOP eliminates the need to perform unnecessary computations and improves the code reusability. Fuzzy systems, in turn, perform inference based on knowledge bases (IF-THEN rules) that can cope with problems involving impreci-sion. Since NOP uses IF-THEN rules in an alternative way, by reducing evaluation redundancy and coupling, this research was conducted to identify, propose and evaluate the needed changes on the NOP to allow its use in the development of fuzzy systems. The tests results showed a significant reduction in the number of evaluated rules, which may represent improvement in performance of the applications.

Full text

Mathware & Soft Computing Magazine. Vol. 22 n. 1 40 /64
SCIENTIFIC REPORT
Adaptation of the Notification Oriented
Paradigm (NOP) for the Development of
Fuzzy Systems
Luiz Carlos Viana Melo and Jean Marcelo Simão* and João Alberto Fabro
Graduation Program on Applied Computing (PPGCA)
Graduation Program on Electrical Engineering and Computer Science (CPGEI)*
Federal University of Technology - Paraná (UTFPR)
Av. Sete de Setembro, 3165 – 80230-901 – Curitiba – PR – Brazil
Abstract.The Notification Oriented Paradigm (NOP) com-
bines and evolves the event based programming with the
declarative programming in order to solve some problems of
both paradigms. Breaking down one application into a net-
work of smaller computational entities, such as logic-causal
and factual notifier entities that processes only when needed,
the NOP eliminates the need to perform unnecessary compu-
tations and improves the code reusability. Fuzzy systems,
in turn, perform inference based on knowledge bases (IF-
THEN rules) that can cope with problems involving impreci-
sion. Since NOP uses IF-THEN rules in an alternative way, by
reducing evaluation redundancy and coupling, this research
was conducted to identify, propose and evaluate the needed
changes on the NOP to allow its use in the development of
fuzzy systems. The tests results showed a significant reduc-
tion in the number of evaluated rules, which may represent
improvement in performance of the applications.
Keywords.Notification Oriented Paradigm, Fuzzy Systems,
Rule Based Systems.
1. Introduction
The Notification Oriented Paradigm (NOP) was proposed
by Simão [7]as a control solution that later evolved into a
programming paradigm. NOP sought inspiration from both
imperative and declarative paradigms, more precisely from
the object oriented and logic sub-paradigms, at same time
that it aims to solve some of their deficiencies [10].
NOP uses the main advantages of the declarative
paradigm, namely the expressiveness of causal rules from
rule based systems, which has abstraction and language
closer to the form of human cognition. It also uses the advan-
tages of the imperative paradigm, namely the code reusabil-
ity, flexibility and abstraction through classes and objects
from the object oriented sub-paradigm [10]. However, NOP
presents a new form of inference, which differs from current
paradigms.
The main idea behind NOP is the way the software de-
tects changes in variables and makes inferences about it. In
the current imperative paradigms, there are two forms to de-
tect changes in values of a variable: through polling or event
notification. In polling, the program loop performs succes-
sive evaluations of the system variables, performing some
logic evaluations on the values and triggering actions when
certain conditions are met. This approach is considered se-
quential because only one condition is checked at a time in a
given thread. Due to the fact that the loop is executed even
when the variables do not change their values, this approach
wastes computing resources [4].
An alternative to polling is event oriented programming.
In this approach, any processing depends on events. Events
can be triggered by user’s actions or other situations that can
provoke changes in the internal state of the program. In
some approaches this eliminates the need to have a loop that
checks the states of variables, which reduces the unnecessary
computing. However, this alternative makes the application
development usually more complex, resulting in bigger pro-
grams. In addition, given the hardware constraints, the event
controller system may perform polling to dispatch events [4].
In the case of declarative programming, the programmer
must focus on what a program should accomplish instead of
how it should be accomplished. This frees the programmer
from handling many unimportant details. However, they are
usually slower to execute and less flexible than imperative
programming [3, 4].
Having these problems as motivation, NOP combines and
evolves ideas of both event based and the declarative pro-
gramming in order to solve them. Actually, NOP eliminates
the need to perform unnecessary computing and enhance
modular decoupling, thereby facilitating code reusability for
example. NOP achieves this by breaking down one applica-
tion into a network of smaller computational notifier entities
that are executed only when needed [14].
Besides, in the past, some preliminary studies were con-
ducted to evaluate if it would be possible to extend the NOP
paradigm to fuzzy systems [12, 13]. These studies were mo-
tivated due to the fact that in both NOP and fuzzy systems the
knowledge can be described in the IF-THEN rules format such
as those used in natural language. Those preliminary studies
used as case studies applications in the field of robotics.
The results of the previous studies on fuzzy NOP demon-
strated a significant reduction in the number of evaluated
rules, which could improve the application performance.
However, they did not describe in details the changes per-
formed, which makes difficult to replicate them in others ma-
terialization of the paradigm. Consequently, this ended up
causing the lack of support to the development of fuzzy sys-
tems by current implementations of NOP. Also the results in

Mathware & Soft Computing Magazine. Vol. 22 n. 1 41 /64
terms of processing time were not good due to the style of
materializations of NOP at the time, i.e. frameworks in C++
with expensive data structures.
In addition, many works on fuzzy systems use embedded
systems to implement their concepts [5, 6]. Due to the re-
strictions of processing, memory and energy consumption, it
would be interesting to find a way to optimize these factors.
NOP can be an alternative to this since it solves these prob-
lems through the use of passive entities that will be processed
only when necessary.
In the following sections, this paper presents the related
concepts of NOP and fuzzy systems, the modifications per-
formed on the paradigm to provide fuzzy concepts and infer-
ence, and a simple application, to evaluate its applicability.
2. Notification Oriented Paradigm (NOP)
This paradigm basis was first proposed as a control mech-
anism to supply the needs related to modern production sys-
tems [10]. Later, the author realized that this model could
be applied on many problem domains. Therefore, he pro-
posed and adjusted the mechanism to provide a general so-
lution for discrete control. In addition, he also realized that
the model could be used to guide programmers in the con-
ception of applications, resulting in the so-called Notification
Oriented Paradigm (NOP) [3]. This paradigm is detailed in
the following subsections.
2.1. Paradigm structure
NOP introduces a set of new concepts that can be ap-
plied to design, build and execute computer programs. The
main concept is the use of small, active and decoupled en-
tities that collaborates by means of notifications in order to
perform the logical and causal calculation existing in the soft-
ware [8, 10]. The knowledge in the paradigm is represented
by causal rules and factual base elements that are naturally
understood by programmers of the current paradigms [10].
The entities that compose the paradigm are as follows:
•Fact Base Element (FBE): is an entity of the observed
system. It aggregates the Attributes that represents the
facts about the cited entity and the Methods that allow
for the execution of functionalities associated to this
element;
•Attribute: is a value of the FBE that represents one of
its features, composing its state;
•Premise: is a logical inquiry between an Attribute (that
belong to some FBE) and a value (for instance, “Is X
equal to 2 ?"). A Premise is composed of an Attribute, a
comparison operator, and a third element, that can be
a constant value, or another Attribute;
•Condition: is a logical relationship between the Rule’s
Premises. This relationship is usually denoted by the
conjunction (AND) and disjunction (OR) logical con-
nectors, or a combination of both;
•Rule: is a rule in the system’s rule set; this entity as-
sociates a Condition to an Action. The relationship im-
plemented by this entity is casual implication, which
can be read as “IF the Condition is active (antecedent),
THEN activate the Action (consequent)";
•Action: is an action to be executed when the associated
Rule was been approved. This element contains a set
of Instigations that must be processed;
•Instigation: is the activity that induces the execution of
aMethod over a FBE;
•Method: is a FBE’s method, that can perform changes
over Attributes.
Figure 1 displays the class diagram of the cited entities
and the relationship among them.
FBE
Method Attribute
1..*
0..*
Change State *
*
Premise
Notify State
0..*
1..2
Condition
Notify State 0..*
1..*
Rule
<<NOP>>
1
Action
1
Instigation
Activate
1..*
0..*
Instigate
1..*
0..*
<<NOP>>
<<NOP>>
<<NOP>>
<<NOP>>
<<NOP>> <<NOP>>
<<NOP>>
FBE
Method Attribute
1..*
0..*
Change State *
*
Premise
Notify State
0..*
1..2
Condition
Notify State 0..*
1..*
Rule
<<NOP>>
1
Action
1
Instigation
Activate
1..*
0..*
Instigate
1..*
0..*
<<NOP>>
<<NOP>>
<<NOP>>
<<NOP>>
<<NOP>> <<NOP>>
<<NOP>>
Figure 1. Paradigm entities represented in a class diagram
[10].
The collaboration between the entities is the basis for the
paradigm inference mechanism, and the collaboration be-
tween them is done through an exchange of punctual no-
tifications. The following section shows the paradigm notifi-
cation mechanism by displaying the role of each entity.
2.2. NOP notification engine
The notification engine is the internal process to execute
the NOP instances, which determines the application execu-
tion flow. Through this mechanism, the program tasks are
split among the entities, which cooperate through notifica-
tions telling each other about the share of their contributions
to form the application execution flow [3]. Figure 2 shows
an example of the notification chain.

Mathware & Soft Computing Magazine. Vol. 22 n. 1 42 /64
FBC.1
FBC.n
Attribute1.1
Attribute1.n
Attribute2.1
Attribute2.n
Method1.1
Method1.n
Method2.1
Method2.n
Attributes
Attributes
Methods
Methods
Premise.1
Premise.2
Premise.4
Premise.n
Premise.3
Premises
Premises
Instigation.2
Instigation.1
Instigation.3
Instigation.n
Instigations
Instigations
Condition.1
Condition.n
Action.1
Action.n
Conditions
Conditions
Actions
Actions
Rules
Rules
Base of facts…
Base of facts…
Rule.1
Rule.n
FBC.1
FBC.n
Attribute1.1
Attribute1.n
Attribute2.1
Attribute2.n
Method1.1
Method1.n
Method2.1
Method2.n
Attributes
Attributes
Methods
Methods
Premise.1
Premise.2
Premise.4
Premise.n
Premise.3
Premises
Premises
Instigation.2
Instigation.1
Instigation.3
Instigation.n
Instigations
Instigations
Condition.1
Condition.n
Action.1
Action.n
Conditions
Conditions
Actions
Actions
Rules
Rules
Base of facts…
Base of facts…
Rule.1
Rule.n
Figure 2. Paradigm notification chain [8].
The inference process starts when the state (value) of an
FBE’s Attribute is changed (e.g. FBC.1 and FBC.n, seen in
figure 2, left side). Each change causes the Attribute to no-
tify the interested Premises. The Premises, after receiving the
notification, perform logical calculation to determine if their
state have to change (from false to true, for example). This
calculation is done by comparing the Attribute value with the
Premise value using a comparison operator.
Using the same notification procedure, Premises that have
changed their logical values notify the interested Conditions.
Upon receiving the Premises notifications, the Conditions do
their logical calculation from a causal logical expression.
Each Conditions defines the relationship between the noti-
fying Premises by the use of logical connectives (“AND" and
“OR"). An expression can be read as the following exam-
ple: “Premise1 activated ‘AND’ Premise2 activated". If the
Condition state changes, it will notify the Rule to which it is
associated.
The Rule, after receiving a notification from the Condi-
tion, will check if the associated Condition is not in conflict3.
If this is the case, the Rule will notify the associated Action.
An Action will perform a number of instigations through the
Instigation entities within it. In the last step of the notifica-
tion cycle, the Instigations will cause the FBE Methods to be
executed, which can alter the FBE Attributes values, starting
a new cycle of Notification Oriented Inference [16].
Through this notification engine the NOP entities will
only execute after receiving a notification from another en-
tity, which may results in resources saving and speed up in
application performance [3, 10].
In the next section, a brief introduction of the main con-
cepts of fuzzy systems is presented. In the following sec-
tions, the adaptation of the NOP paradigm to handle with
fuzzy concepts and inference mechanisms is proposed and
detailed.
3. Fuzzy systems
The studies on fuzzy systems started in 1965 when Zadeh
[1]proposed his fuzzy sets theory. This theory generalizes
the classical set theory [15], allowing the representation of
concepts which cannot be represented using well defined (or
crisp) limits.
A fuzzy set is the one containing the elements of the uni-
verse of discourse which has variable membership degree to
this set. The equation µA(x)∈[0, 1]represents the mathe-
matical notation of the membership degree µAof an element
xin a set A, where the value “1.0" indicates the complete
compatibility of an element with the concept represented by
the set, and the value “0.0" indicates there isn’t any compat-
ibility of the element with the set.
Another concept related with fuzzy sets is the linguistic
variable, which represents an identifier that can assume one
of several values. Thus, a linguistic variable can take a lin-
guist value which represents a fuzzy set.
Fuzzy logic can be used to develop control systems that
deal with imprecise information. Through a set of rules, it is
possible to perform inferences that will be used in the deci-
sion making process of a system. In the most practical appli-
cations the input data is composed of values provided by sen-
sors, that result from measurements and observations. For
the use of such data by fuzzy inference systems, it is required
to perform a mapping of those measurements into relevant
activation of fuzzy sets [11]. This mapping is called “fuzzy-
fication" and results in a value of membership degree of the
data to each fuzzy set.
The generated sets are used to perform the fuzzy infer-
ence. The inference step is processed through the compar-
ison of the rules stored in the rule database. This process
results in the calculation of the activation level of each rule.
After the calculations the results are spread through the fuzzy
rules, producing fuzzy sets that represent the consequents of
each rule. The contribution of each rule (fuzzy set) is taken
into account through, for instance, the union of the fuzzy
sets. Beyond this point the user already has the result of the
system in the format of fuzzy sets.
Once the output fuzzy set is obtained by the inference
process, in the “defuzzyfication" stage it is converted into a
crisp value using a defuzzyfication function like the centroid
function. This is necessary because usually in practical ap-
plications exact outputs are required, not fuzzy ones [11].
The following section details the changes made in the
NOP implementation to perform inferences based in fuzzy
rules and concepts. Since originally NOP accepts only “crisp”
activations (i.e. each NOP entity can have only one of two ac-
tivation values, “true” or “false”), several modifications were
necessary to allow the propagation of fuzzy activations.
4. Changes made over NOP to provide fuzzy inference
capabilities
Several modifications were required in the paradigm im-
plementation in order to allow fuzzy logic systems develop-
ment. The proposed modifications where applied over the
current implementation of the NOP Framework in C++ lan-
guage, as presented in [9], and draw inspiration from the
first fuzzy implementation developed in previous work [12].
4.1. Changes in the representation of logical state of the
entities
Paradigm entities like Premises,Conditions and Rules have
each one a logical state that is spread through notifications.
This logical state has, in the originally proposed paradigm,
only two possibles values: true(active) or false (inactive),
represented by the integer values in {0,1}. The value 0
3There is mechanisms to solve conflicts as detailed in [18]and [17]

Mathware & Soft Computing Magazine. Vol. 22 n. 1 43 /64
(zero) indicates that the entity is not active, and 1 (one) in-
dicates that it is active.
To extend the representation to support fuzzy logic, the
mentioned entities must represent the logical state by their
activation level. The activation level can be represented as
real values in the range [0,1], representing the member-
ship degree as shown in section 2. The notification process
is started when the activation level of any entity changes.
These changes to the original NOP implementation could
only be from inactive to active, or vice-versa, but with the ex-
tension to fuzzy activations, any change in the value can start
the notification. This activation level is calculated differently
for each entity as described in the following sub-sections.
4.2. Linguistic variable representation
The linguistic variable was implemented as an extension
of an NOP Attribute, as shown in figure 3. This new element
derived from the Attribute by C++ class inheritance has a list
of fuzzy sets that represents the linguistic terms of the vari-
able. Each set is represented by a membership function used
to calculate the membership degree of a value to that set.
LinguisticVariable FuzzySet
Attribute
*
1
MembershipFunction
Figure 3. Definition of element “Linguistic Variable" in the
NOP paradigm.
By assigning a value to this variable, it will behave as an
Attribute and will notify the Premises if the assigned value is
different from current value. The membership degree cal-
culation for a given fuzzy set performed by each Premise as
described in the section 4.3.
4.3. Changes in the calculation of the Premises logical
state
Due the changes described in section 4.1, the Premise log-
ical state is now represented by activation levels. This calcu-
lation depends on the Premise type. The Premises types are:
•Common (or crisp): Premise in which all logical opera-
tions are performed on non-fuzzy Attributes. The result
of this operation will determine the Premise activation
(“true" or “false" , represented by either 0.0 or 1.0);
•Fuzzy Premise:Premise that calculates the membership
degree of the Attribute value in the fuzzy set associated
with that Premise. The calculated membership degree
defines the Premise activation level (a real number be-
tween 0.0 and 1.0).
In the case of fuzzy Premise the activation level will be
the result of the calculation of the membership degree for
the value stored in the Attribute to the fuzzy set referred by
the Premise.
4.4. Readjustment of the Condition logical expression
The change in the Condition consisted in the creation of a
model that represent the Conditions causal expressions. The
model is presented in figure 4.
LogicalAssertion
LogicalConnective
Disjunction
Conjunction
Condition
LogicalValue
Negation
*
1
1
Figure 4. Condition casual expression model.
In this model the Premise is associated to an expression
with a logical value. This value is updated when the Premise
notifies the Condition, and the activation level of the Premise
are then used as input for the operations with the logical con-
nectives defined in the model. The notification also starts the
calculation of the activation level of this Condition.
The calculation is performed using the definitions of the
operations defined by Mamdani in [2]as follows:
•Intersection (µ(A∩B)(x) = min[µA(x),µB(x)]) : logical
connective AND;
•Union (µ(A∪B)(x) = max[µA(x),µB(x)]) : logical con-
nective OR;
•Complement (µ(¯
A)(x) = 1−µA(x)) : negation logic
operation.
The use of the mentioned operations allows the charac-
teristics of the boolean logic to be “emulated", allowing for
the use of Rules with both fuzzy and non-fuzzy Premises.
4.5. Changes in the active part of the inference process
With the changes mentioned in section 4.1 a Rule acti-
vates when there is a change in the Condition state. This also
reflects in the Instigations since they are activated along the
Rules.
In this work, it was defined that the Instigations now have
two forms: the common Instigation and the fuzzy Instiga-
tion. The common Instigation represents the current defini-
tion of the paradigm Instigation and it maintains the current
paradigm behavior. These will only activate when the Rule
activation level is equal to one, otherwise the Instigation is
not activated.
The fuzzy Instigation is activated at every change in the
Rule activation level which it is related to. This activation ex-
ecutes the Methods associated to it, fuzzy or not. If the fuzzy
Instigation involves the execution of a fuzzy Method, the Rule
activation level is passed to it.
The fuzzy Method was created to represent the conse-
quent of fuzzy logic rules. It associates the Attribute to the
fuzzy set and performs the “defuzzyfication" operation. The
operation result can be assigned to an Attribute, which can
then trigger a new notification cycle.
With those changes, NOP can now allow the use of fuzzy
versions of its entities, providing all of the necessary support
for implementation of complete systems based in fuzzy logic
and even allowing the composition of rules with fuzzy and
non-fuzzy elements transparently. In the next section, some

Mathware & Soft Computing Magazine. Vol. 22 n. 1 44 /64
developed experiments to evaluate these modifications are
presented.
5. Tests and results
Tests were performed using the implementation of
paradigm in the form of a C++ framework defined in [9],
after its adjusts to support fuzzy concepts. Comparisons
were performed with a system developed in C++ without
using NOP. The system consists of a simulated washing ma-
chine controller, that defines the wash time according to the
amount of dirt and the size of stain in clothes. It’s rules and
variables were provided by a fuzzy system expert as an ex-
ample, not representing a real system. The Fuzzy Rulebase
relating the input variables and the output variable has nine
Rules as shown in table 1.
No Stain - NS Medium Stain - MS Big Stain - BS
Little Dirt - LD Very Short - VS Average - A Long - L
Average Dirt - AD Short - S Average - A Long - L
Much Dirt - MD Average - A Long - L Very Long - VL
Table 1. Block diagram of a RE-FAM.
Figure 5 shows the fuzzy sets for each defined linguistic
variable.
1,0
0,0
0 50 100
LD AD MD
1,0
0,0
0 50 100
NS MS BS
1,0
0,0
0 40 60
VS AS
10 25
L VL
y
x1x2
(a) (b)
(c)
Figure 5. The fuzzy sets for the dirt (a), stain (b) and wash
time (c) variables.
In the developed fuzzy system using the NOP framework,
extended to support the fuzzy concepts, the Methods exe-
cuted by the activated Rules also increments the value of a
global variable that indicates how many Rules where acti-
vated during the program execution. For “defuzzyfication" it
was utilized the centroid function over the resulting fuzzy
set and the function granularity was adjusted to 0.1 in both
systems.
The test case consists in assigning artificially generated
values and comparing the results of both systems. The fol-
lowing code was used in the tests:
fo r i =0 t o 100 i n c 10
fo r j =0 t o 100 i n c 10
d i r t =i
stain =j
pe rfo rm infe r e n c e
w ri te e x ec ut i on ti me i n f i l e
end
end
This program resulted in the execution of the inference
process 121 times. In both systems (fuzzy C++ and fuzzy
NOP), measurements of the execution time between the as-
signment of the first value and the completion of inference
were performed. For the tests, it was considered the total ex-
ecution time of all inferences, that is, the sum of all measured
times.
During the tests both systems calculated the same values
for the passed input data set. Furthermore, an analysis of
the amount of the Rules activated was performed. As the in-
ference process was executed 121 times and the C++ fuzzy
system analyzed the nine rules this amount of times, this re-
sulted in 1089 verifications. However, in the developed NOP
system, the execution of this test resulted in activation of only
277 Rules.
Despite this result, the C++ system average execution
time was 0.366214 seconds while the NOP system developed
with the modified framework was 1.12508 seconds, result-
ing in an execution ratio of 3.072:1. This was caused by
the framework overhead since it was developed to simulate
the NOP parallelism in a sequential execution environment
by processing one layer of NOP entities (Attributes,Premises,
...) at each time. Furthermore, the framework was not opti-
mized to use multiple threads.
6. Conclusion
With this work it was possible to verify the possibility of
adapting the notification oriented paradigm to support the
development of fuzzy logic systems. The changes mentioned
in this work allowed the paradigm to be used for an proof-
of-concept fuzzy system development. Furthermore, those
changes allow the development of mixed systems, where
crisp Premises and fuzzy Premises can compose the same Rule
through the use of the logical connectives defined by Mam-
dani, and this can be seen as a contribution of this paper.
During the tests it was verified that there was a reduction
in the amount of evaluated rules, which could result in reduc-
tion of necessary computation to execute the mentioned test
case. This is due the inference mechanism of the paradigm,
where the processing will occur only if there’s a change of
state in the system. However, it was also verified that, al-
though the reduced amount of verified rules, the execution
time of the system developed with the fuzzy NOP framework
was three times bigger than the system developed directly in
C++. This happened because the framework was developed
to simulate the NOP parallelism in a sequential execution en-
vironment.
The next step of this work is to extend the NOP language
[14], which is already under development, to include the
proposed fuzzy concepts and structures. This new language
will allow developers to easily create fuzzy systems, which
will help in creation of new test cases and in improvement of
the fuzzy NOP framework, in order to reduce its overhead.
References
[1]L. A. Zadeh: Fuzzy Sets, Information and Control, vol.
8, pp. 338-352. (1965).
[2]E.H. Mamdani: Application of fuzzy algorithms for con-
trol of simple dynamic plant, Proceedings - Institution
of Electrical Engineers, vol. 121, no. 12, pp. 1585-
1588. (1974).
[3]R. F. Banaszewski: Notification Oriented Paradigm -
Advances and Comparisons (in portuguese), Curso de

Mathware & Soft Computing Magazine. Vol. 22 n. 1 45 /64
Pós-Graduação em Engenharia Elétrica (CPGEI), Uni-
versidade Tecnológica Federal do Paraná (UTFPR), Cu-
ritiba, PR. (2009).
[4]E. Peters, R. P. Jasinsk, V. A. Pedroni and Jean M.
Simão: A new hardware coprocessor for accelerating
Notification-Oriented applications, Proceedings - Inter-
national Conference on Field-Programmable Technol-
ogy, pp. 257-260. (2012).
[5]S. Sánchez-Solano, A. J. Cabrera, I. Baturone, F. J.
Moreno-Velo and M. Brox: FPGA implementation of
embedded fuzzy controllers for robotic applications,
IEEE Transactions on Industrial Electronics, vol. 54, no.
4, pp. 1937-1945. (2007. publisher=IEEE
[6]N. Sulaiman, Z. A. Obaid, M. H. Marhaban and M. N.
Hamidon: FPGA-Based Fuzzy Logic : Design and Ap-
plications - a Review, IACSIT International Journal of
Engineering and Technology, vol. 1, no. 5, pp. 491-503.
(2009).
[7]J. M. Simão: A Contribution to the Development of a
HMS Simulation Tool and Proposition of a Meta-Model
for Holonic Control, Curso de Pos-Graduasao em En-
genharia Eletrica (CPGEI), Universidade Tecnologica
Federal do Parana (UTFPR), Curitiba, PR. (2005).
[8]J. M. Simão and P. C. Stadzisz: Notification Oriented
Paradigm (NOP) - A Composition Technique and Noti-
fication Oriented software execution (in portuguese),
Patent pending submitted to INPI/Brazil in 2008 and
UTFPR Innovation Agency. (2008).
[9]A. F. Ronszcka: Contribution to the design of applica-
tions in Notification Oriented Paradigm (NOP) under
the perspective of patterns (in portuguese), Curso de
Pós-Graduação em Engenharia Elétrica (CPGEI), Uni-
versidade Tecnológica Federal do Paraná (UTFPR), Cu-
ritiba, PR. (2012).
[10]J. M. Simão, C. A. Tacla, R. F. Banaszewski, P. C.
Stadzisz: Notification Oriented Paradigm (NOP) and
Imperative Paradigm: A Comparative Study, Jour-
nal of Software Engineering and Applications (JSEA).
(2012).
[11]T. J. Ross: Fuzzy Logic with Engineering Applications,
John Wiley & Sons. (2004).
[12]J. M. Simão, J. A. Fabro, P. C. Stadzisz, L. V. R. Arruda,
S. Ishimatsu: An Agent-Oriented Fuzzy Inference En-
gine, VI Simposio Brasileiro de Automasao Inteligente,
Bauru, SP, pp. 585-590. (2003).
[13]J. T. S. de Souza, J. A. Fabro, J. M. Simão, R. F. Ba-
naszewski: Proposal of a fuzzy inference engine using
Notification Oriented Paradigm (NOP) (in portuguese),
XIV Seminário de Iniciação Científica e Tecnológica da
UTFPR, Pato Branco, PR. (2009).
[14]R. D. Xavier: Software development paradigms:
comparing event-driven and notification oriented ap-
proaches (in portuguese), Curso de Pós-Graduação
em Computação Aplicada (PPGCA), Universidade Tec-
nológica Federal do Paraná (UTFPR), Curitiba, PR.
(2014).
[15]W. Pedrycz, F. Gomide: An Introduction to Fuzzy Sets:
Analysis and Design, MIT Press. (1998).
[16]J. M. Simao, P. C. Stadzisz: Inference Based on Notifica-
tions: A Holonic Metamodel Applied to Control Issues,
IEEE Transactions on Systems, Man and Cybernetics,
Part A: Systems and Humans, vol. 39, no. 1, pp. 238-
250. (2009).
[17]J. M. Simão, P. C. Stadzisz: Conflict resolution mech-
anism and determinism warranty for Notification Ori-
ented Paradigm (NOP) (in portuguese), Patent pending
submitted to INPI/Brazil in 2010 and UTFPR Innova-
tion Agency. (2010).
[18]J. M. Simão, P. C. Stadzisz, R. F. Banaszewski, C. A.
Tacla: Optimized inference engine for Notification Ori-
ented Paradigm (NOP) and mechanisms for conflict
resolution to uniprocessor and multiprocessor environ-
ments applied to NOP (in portuguese), Patent pending
submitted to INPI/Brazil in 2010 and UTFPR Innova-
tion Agency. (2010).