An Illustrative Example of the JADEL Programming Language
Eleonora Iotti
1
, Federico Bergenti
2
and Agostino Poggi
1
1
Dipartimento di Ingegneria e Architettura, Universit
`
a degli Studi di Parma, 43124 Parma, Italy
2
Dipartimento di Scienze Matematiche, Fisiche e Informatiche, Universit
`
a degli Studi di Parma, 43124 Parma, Italy
Keywords:
Agent-oriented Programming Languages, Agent-oriented Software Engineering, JADE.
Abstract:
This paper presents a case study intended to investigate the features of JADEL, an agent-oriented programming
language designed to ease the development of JADE agents and multi-agent systems. The paper first motivates
the need for JADEL, and it briefly shows the main features of the language. Then, a well-known problem
originally designed to assess the features of actor-based programming languages is recalled, and a possible
solution implemented in JADEL is presented. The proposed solution is intended to validate the features of the
language that concern concurrency and distribution, and it can be used as a guideline to use JADEL to target
problems expressed in terms of agents that cooperate to bring about joint goals.
1 INTRODUCTION
JADE (Java Agent DEvelopment framework)
(Bellifemine et al., 2005) is an agent platform that
enables the development of distributed multi-agent
systems by means of a specific Java development
framework, which is used to access a dedicated
runtime support. Nowadays, JADE is one of the most
popular frameworks to develop and deploy real-world
multi-agent systems, even if its first release dates
back to the early 2000s. JADE is widely employed
both for industrial and academic purposes, and it
is generally recognised as a solid and reliable tool
(Kravari and Bassiliades, 2015) that can follow
programmers from early prototyping to mission
critical deployments, as discussed, for example, in
(Bergenti et al., 2003) and (Bergenti et al., 2015).
Many factors contributed to the success of JADE,
both in academia and in the industry (Kravari and
Bassiliades, 2015). First, it offers a mature and well-
documented development framework fully written in
Java. In the early days of JADE, Java was a novel
and promising technology, and developers wanted to
use it for their applications. Moreover, Java was par-
ticularly relevant in the scope of Web technologies,
and it contributed significantly to the rapid growth of
the Web. For these reasons, Java seemed to be a per-
fect solution for a novel framework like JADE. Then,
JADE is currently developed and maintained, and a
number of significant extensions have been proposed
in the last fifteen years. The two main project rela-
ted to JADE from the core group of researchers that
originally proposed JADE are WADE (Workflows and
Agents Development Environment) (Bergenti et al.,
2012) and AMUSE (Agent-based Multi-User Social
Environment) (Bergenti et al., 2013; Bergenti et al.,
2014). WADE allows JADE to execute agents desig-
ned according to the workflow metaphor, and it pro-
vides additional features regarding fault tolerance and
load balancing. AMUSE offers tools to use JADE
to support multi-user interactions in applications like,
for example, multi-player games. Finally, it is worth
recalling that one of the factors that contributed to the
success of JADE is that it complies with FIPA (Foun-
dation for Intelligent Physical Agents) specifications,
which promoted the adoption of JADE in the industry.
Besides the constant appreciation from a large
community, JADE has been facing in the last few
years a slow decay of popularity among developers
of multi-agent systems. One of the most important
reasons for such a loss of interest is that today the
100% pure Java approach is less appealing than it
was in the past. This is mainly motivated by the gro-
wth of valid alternatives to Java that are becoming
popular among programmers, like scripting langua-
ges and DSLs (Domain-Specific Languages) (Fowler,
2010). Another important reason for the loss of in-
terest in JADE is that the AOP (Agent-Oriented Pro-
gramming) paradigm is inherently different from the
OOP (Object-Oriented Programming) paradigm, and
such a difference is reflected in some controversial as-
pects of the JADE development framework. In parti-
282
Iotti, E., Bergenti, F. and Poggi, A.
An Illustrative Example of the JADEL Programming Language.
DOI: 10.5220/0006659402820289
In Proceedings of the 10th International Conference on Agents and Artificial Intelligence (ICAART 2018) - Volume 1, pages 282-289
ISBN: 978-989-758-275-2
Copyright © 2018 by SCITEPRESS – Science and Technology Publications, Lda. All rights reserved

cular, the difference between the AOP and the OOP
programming paradigms forces AOP programmers to
deal with low-level details that they do not perceive
as important, while it forces OOP programmers to
adopt programming idioms that fail to meet their ex-
pectations. In addition, the complexity of the JADE
development framework has been consistently incre-
asing because of the continuous growth of the JADE
community and of related project, and such a growth
of complexity is immediately perceived by program-
mers. Finally, the loss of interest in FIPA caused by
the shift of industrial focus to other technologies that
enable the effective development and deployment of
interoperable systems contributed significantly to the
loss of interest in JADE.
All mentioned problems have been discussed and
analysed within the JADE community and among
JADE contributors, and several solutions have been
proposed. Among such proposals, JADEL, which
stands for JADE Language (Bergenti, 2014; Ber-
genti et al., 2017), was proposed primarily to try to
bridge the gap between the AOP-inspired approach
that JADE promotes, and its current OOP incarnation.
JADEL is a DSL for JADE agents and multi-agent
systems that aims at simplifying the use of the frame-
work with no loss of effectiveness and applicability.
JADEL reinterprets the JADE agent model in terms of
a simplified language that features selected AOP ab-
stractions, like agents and behaviours, together with a
dedicated support for messaging and interaction pro-
tocols. All such features contribute to lift the level of
abstraction that the programmer perceives, and they
make JADEL a tool to program at a higher level of
abstraction with respect to the level of ordinary OOP
programming. The programmer is no longer reque-
sted to master the details of JADE because such de-
tails are securely embedded in the language.
The core features of JADEL were presented in
(Bergenti et al., 2016c; Bergenti et al., 2017), and the
introduction of interaction protocols in JADEL was
discussed in (Bergenti et al., 2016a; Bergenti et al.,
2016b). JADEL has been recently used (Monica and
Bergenti, 2015) to support specific experiments on the
use of agents for location-aware services and applica-
tions (Monica and Ferrari, 2014a), and its current run-
time support provides a module for robust localization
of agents (Monica and Ferrari, 2013a; Monica and
Ferrari, 2013c; Monica and Ferrari, 2014c; Monica
and Ferrari, 2015a; Monica and Ferrari, 2016) in
known environments using ordinary Wi-Fi infrastruc-
tures (Bergenti and Monica, 2016; Monica and Ber-
genti, 2016a; Monica and Bergenti, 2016b; Monica
and Bergenti, 2017; Bergenti and Monica, 2017b) or
specific infrastructures for accurate and robust loca-
lization based on UWB (Ultra-Wide Band) techno-
logy (Monica and Ferrari, 2013b; Monica and Ferrari,
2014b; Monica and Ferrari, 2015b).
In order to assess the actual capabilities of JA-
DEL, it is important to validate it on complex pro-
blems and to analyse its features in terms of readabi-
lity, usability and performance. In this paper, JADEL
is used to develop a multi-agent system that solves a
well-known coordination problem (Trono, 1994) that
was stated to assess the characteristics of actor-based
programming languages. The addressed problem is
sufficiently complex to represent a valid case study of
the features of JADEL in the management of concur-
rency and distribution, but it is also sufficiently simple
to have it discussed and commented in the short space
of a single paper. In addition, the study of a classic
concurrency problem that is commonly solved using
actors can help to evaluate the advantages provided
by the agent-oriented approach in the context of dis-
tributed and decentralized coordination.
This paper is organized as follows. Section 2 pro-
vides a short overview of the state of the art of agent-
oriented programming languages. Section 3 briefly
explains the syntax of JADEL and its informal se-
mantics. Section 4 describes the addressed case study
and it shows the proposed implementation in JADEL.
Finally, a concise summary of the major results of a
quantitative analysis of the proposed implementation
concludes the paper.
2 RELATED WORK
Agent-Oriented Software Engineering (AOSE) (Ber-
genti et al., 2004) is the discipline that studies met-
hodologies and tools involved in the development
of agent-oriented applications and services. Agent-
Oriented Programming (AOP) is the programming
paradigm first introduced in (Shoham, 1997) that is
meant to reinterpret the development of multi-agent
systems as a programming task. In this scope, agent
programming languages are specific programming
languages that turned out to be especially convenient
to develop complex multi-agent systems, in contrast
to more traditional, but lower-level, languages. Due
to the long history of the research on agents and
multi-agent systems, which lasts various decades, se-
veral agent programming languages have been de-
signed and implemented. AGENT-0 (Shoham, 1991)
was the first example of the application of the AOP
paradigm. The work of Shoham is very important
because it affected most of the subsequent develop-
ments of agent programming languages, thus opening
a wide and promising research area. PLACA (Tho-
An Illustrative Example of the JADEL Programming Language
283

mas, 1995) can be considered the direct descendant
of AGENT-0. Just like AGENT-0, PLACA has an ex-
perimental nature and it was not meant for practical
use. Successively, Concurrent MetateM (Finger et al.,
1993) was proposed to use temporal logics to deal
with concurrency in multi-agent systems. Similarly,
AgentSpeak(L) (Rao, 1996) was introduced to support
formal reasoning on multi-agent systems based on
BDI (Belief-Desire-Intention) agents. Only recently,
Jason (Bordini et al., 2007) was proposed to pro-
vide practical support for AgentSpeak(L). Many ot-
her languages were developed in the scope of specific
contexts, such as the Semantic Web, with the SEA L
(Semantic web-Enabled Agent Language) (Demirkol
et al., 2012) language, or BDI-based autonomous ro-
bots, with the PROFETA (Python RObotic Frame-
work for dEsigning sTrAtegies) (Fichera et al., 2017)
language. One of the latest entries in the plethora
of agent programming languages is SARL (Rodriguez
et al., 2014), which is a modern general-purpose pro-
gramming language. SARL is very similar to JADEL
in terms of syntax, but they are very different in terms
of purpose and usage, they have been developed inde-
pendently, and they target different agent platforms.
3 OVERVIEW OF JADEL
JADEL is a programming language intended to sup-
port effective development and deployment of JADE
multi-agent systems. JADE provides a number of
agent-oriented abstractions for the construction of
multi-agent systems, but JADEL selects only a few
primary abstractions among them to offer to the deve-
loper a clear vision of multi-agent systems. In detail,
only four main abstractions that JADE implements
were chosen, namely: agents, behaviours, (commu-
nication) ontologies, and interaction protocols. Note
that in the case study described in next section, only
agents, behaviours and ontologies are used.
Communication ontologies are formal means to
support the semantics of agent communication lan-
guages for specific problems. An ontology provi-
des a dictionary of terms and schemas, which can
be organised in a hierarchical structure. Such terms
can be atomic or composite concepts, atomic propo-
sitions, or predicates. With respect to first-order lo-
gics, atomic concepts are constant terms, composite
concepts represent function symbols, propositions are
well-formed formulas, and predicates are first-order
logic predicates. Schemas describe terms at runtime,
and they are used to validate inbound and outbound
messages. A JADEL ontology with a proposition, a
concept, and three predicates is shown below.
ontology Ch ame neo s O nt o l o gy {
concept C o l o r (string d e s c r ipt i o n )
predicate Me e tin g C o un t (integer co u n t )
predicate M eet (aid ch ameneo s ,
Colo r color )
predicate C h a n g e ( C o l o r co l o r )
proposition Te r m ina t e d
}
Behaviours can be considered as agent tasks. Each
behaviour encapsulates an action, and it manages a
list of inbound events. JADEL provides a specific
syntax to declare, activate and deactivate behaviours,
and it also offers specific linguistic constructs to ma-
nage actions and events. An example of a behaviour
that handles the reception of messages and that sends
replies is shown below.
cyclic behaviour Cha n g e Col o r
for Ch ame n e osA g e nt {
on message msg
when {
content is Ch a n g e
} do {
extract ms g c ont e n t as C h a n g e
theAg e n t . c o lor = m s gcon t e n t . col o r
send message {
performative is IN F O R M
receivers are #[ m sg . s e n d e r ]
content is new Meet ( t h e Agent . AID ,
theAg e n t . c o lor )
ontology is Ch a m en e o sO n t o lo g y
}
}
}
Agents in JADEL use ontologies and behaviours,
and they take roles in interaction protocols, as discus-
sed, for example, in (Bergenti et al., 2003). JADEL
aims at making the declarations of agents clearer than
semantically equivalent declarations made with JADE
by means of a lighter syntax, and by means of a focus
on the connections of the agent with other abstracti-
ons. The declaration of an agent is allowed to ex-
tend the declaration of another agent, with the usual
semantics of inheritance, and two event handlers are
provided to support initialization and take-down pha-
ses. Behaviours are normally activated in initializa-
tion and take-down phases to ensure that agents can
react to interesting events, like the reception of a mes-
sage. An agent that uses the ChameneosOntology
shown previously and that activates two behaviours
upon creation is shown below.
ICAART 2018 - 10th International Conference on Agents and Artificial Intelligence
284

agent Ch ame n e osA g e nt (
String d esc r i p t ion )
uses ontology Ch a m en e o sO n t o lo g y {
var C o l o r col o r
on create {
colo r = n ew Color ( de s c r i pti o n )
activate behaviour
Cha n g e Col o r ( this )
activate behaviour
Wa i t F or M e e ti n g ( t his )
}
}
A description of the expressions that JADEL of-
fers to the programmer for the construction of pro-
gram statements is omitted because of space con-
straints. Next section provides examples of relevant
expressions that should be self-exaplanatory.
4 THE SANTA CLAUS
COORDINATION PROBLEM
This section describes a JADEL implementation of a
multi-agent system that solves the Santa Claus coor-
dination problem, which is a classic problem first in-
troduced in (Trono, 1994). In its simplest form, the
problem can be expressed as follows. Santa Claus
has nine reindeer and ten elves. He sleeps while he
waits for a group made of all reindeers or of three of
his elves. When the group of reindeer is ready and
Santa Claus is awake, they work together to deliver
toys. On the contrary, when three elves are ready
and Santa Claus is awake, they discuss about building
new toys. Note that when both groups are ready at
the same time, Santa Claus gives priority to the group
of reindeers. In addition, the problem could be ex-
tended by incrementing the number of Santa Clauses,
elves and reindeers, thus opening a wide variety of ot-
her problems. For example, reindeers and elves must
help one Santa Claus at a time, and Santa Clauses can-
not wait for too long for a group to get ready, so that
they could decide to release reindeers and elves when
groups do not get ready in time. All such extensi-
ons are not discussed in the proposed implementation
because they would require the nontrivial addition of
timing constraints among distributed agents.
The Santa Claus coordination problem is a clas-
sic exercise that focuses on concurrency and paralle-
lism. A number of different solutions to the problem
are available, and the main challenge that it puts for-
ward is about the management of groups and of com-
munication patterns. In the proposed JADEL imple-
mentation, the Santa Claus problem is solved by defi-
ning three types of agents, namely Santa, Reindeer,
and Elf agents. Such definitions are sufficient for the
underlying JADE platform to distinguish among the
three agent roles in the problem.
Agents in the implemented multi-agent system
can exchange messages, and the following communi-
cation ontology is provided to support the validation
of the structure of messages.
ontology Sa n ta O n t ol o g y {
predicate El f R e a d y (aid id )
predicate Re i nd e e r Re a d y (aid id )
proposition OK
}
The SantaOntology defines the proposition OK,
which is used by Santa Claus when one groups be-
comes ready to inform group members that the work
is about to start. The two other predicates (ElfReady
and ReindeerReady) relate an AID (Agent IDentifier)
to the type of the agent that sends them (elf or rein-
deer, respectively). The AID of an agent in JADEL
(and in JADE) is unique to the platform and it con-
sists of a name (chosen when the agent starts) and an
address (the address of the machine where the agent
executes). Reindeers and elves send inform messages
that use such predicates to let Santa Claus know about
their AIDs and their types. In the proposed solution,
the ready message is sent from an elf or a reindeer to
Santa Claus using the following behaviour.
oneshot behaviour Re a d y ( AI D santa ,
Pred i c a t e r e ady ) {
do {
send message {
performative is IN F O R M
content is re a d y
receivers are #[ santa ]
ontology is Sa n t a Ont o l ogy
}
}
}
The behaviour is declared oneshot, and it contains
a procedure in the do block. When an agent activa-
tes a oneshot behaviour, it adds the behaviour to its
list of active tasks, and, during its life-cycle, it tries
to execute all such tasks sequentially. Obviously, if
a behaviour must wait for a message, and no messa-
ges are present in the agent mailbox, the behaviour
is blocked and the agent does not execute its action.
Generic oneshot actions can be performed without
triggers, and, after their executions, they are remo-
ved from the list of active tasks. In this specific case,
the behaviour Ready has two parameters, namely, the
AID of Santa Claus and the predicate used to inform
him about the availability of the agent that uses the
An Illustrative Example of the JADEL Programming Language
285

behaviour. This behaviour can be used by reindeers
and elfs, and the ready predicate is meant to let Santa
Claus know whether the sender is a reindeer or an elf.
A Santa agent must capture ready message and
reply accordingly. The following behaviour shows the
actions involved in the reception of an inform mes-
sage whose content is a ReindeerReady predicate.
cyclic behaviour Wa i t For M e ss a g e s
for S a n t a {
on message msg
when {
content is Re i n d eer R e ady
} do {
extract predicate as
re i n d eer R e ady
theAg e n t . r e i ndee r s . add (
re i n d eer R e ady . id )
if ( t h e A g e n t . rei n d e e r s . s ize == 9) {
send message {
performative is IN F O R M
receivers are
theAg e n t . r e i ndee r s . t o L i s t
content is new OK
ontology is Sa n t a Ont o l ogy
}
activate behaviour
Del i v e rTo y s ( t h e Agent )
}
}
}
The reception of messages requires a cyclic beha-
viour, which is a behaviour that remains in the list
of active tasks of the agent also after the execution
of its action. The keyword for is meant to specify a
type of agent to which the behaviour is applicable.
It is useful, for example, when the behaviour have
access to internal fields of the agent. The special field
theAgent is used inside the action of a behaviour to
access the agent that is currently using the behaviour.
The on-when-do declaration can be used to handle
generic events, and it can be used also to handle in-
coming messages. The keyword on specifies the type
of interesting events (messages, in this case), and the
keyword when introduces a condition to filter events
(messages, in this case). Finally, the keyword do al-
lows expressing the actual procedure to be performed.
The statement extract-as is used in the scope of an
on-when-do declaration to extract the content of an
incoming message. When Santa Claus receives nine
ReindeerReady messages, he sends an OK message
to all reindeers involved, and then it activates a new
behaviour to deliver toys.
The reception of ElfReady messages can be ad-
ded to the shown behaviour by simply extending
the behaviour with a similar on-when-do decla-
ration just below the declaration used to process
ReindeerReady messages. Note that on-when-do
declarations are used in the order in which they appear
in the source code, so in this case they ensure that the
priority of reindeer messages is higher than that of elf
messages. When a reindeer or an elf receives an OK
message, the following behaviour is activated.
cyclic behaviour Wait F o r O K {
on message msg
when {
content is OK
} do {
if ( t h e A g e n t i n sta n c e o f R eindeer )
activate behaviour
Del i v e rTo y s ( t h e Agent )
else
activate behaviour
Dis c u s sTo y s ( t h e Agent )
}
}
Finally, Reindeer, Elf, and Santa agent types
can be defined as follows. For reindeers and elves,
the declaration are very similar. They take as parame-
ters a reference to Santa Claus agent, and they use the
SantaOntology for exchanging messages. In their
initialization phases, they activate the two behaviours
shown above.
agent Re i n d e e r ( AID santa )
uses ontology Sa n t a Ont o l ogy {
on create {
activate behaviour
Wait F o r O K ( t h is )
activate behaviour
Read y ( this , santa , n ew
Re i n d ee r M ess a g e ( t h is . AID ) )
}
}
The definition of the single agent of type Santa in
the system is very simple. It only has to sleep while
waiting for groups of reindeer or groups of elves to
become available for work. The source code of the
Santa Claus agent is shown below.
agent S a n t a
uses ontology Sa n t a Ont o l ogy {
var Set < AID > rei n d e e r s = n e w Hash S e t
var Set < AID > e l v e s = newH a s h Set
on create {
activate behaviour
Wa i t F or M e ssa g e s ( t h is )
}
}
ICAART 2018 - 10th International Conference on Agents and Artificial Intelligence
286

5 RESULTS AND CONCLUSIONS
This paper describes a JADEL multi-agent system in-
tended to implement the scenario described in the
simple version of the classic Santa Claus coordination
problem (Trono, 1994). The proposed implementa-
tion uses one specific type of agent for each actor of
the problem, and the interactions among agents are
managed by the behaviours and the communication
ontology described in the previous section. In order
to assess relevant characteristics of the proposed im-
plementation, the produced source codes are compa-
red with their direct translations into Java source co-
des that use JADE. Table 1 shows a summary of such
a comparison in terms of Lines Of Code (LOCs), un-
der the assumption that one LOC contains exactly one
statement, thus excluding empty lines and comments.
The table shows that JADEL source codes are defi-
nitely more succinct than Java source codes that use
JADE, especially for the definition of communication
ontologies. In addition, the table shows the density of
AOP features in source codes, which is computed by
counting the LOCs that refer to AOP features, such
as activation of behaviours and reception of messa-
ges. The table shows that agent-oriented features are
more dense in JADEL source codes, mostly because
of the specific linguistic constructs added in the lan-
guage that provide succinct statements for complex
tasks.
In summary, JADEL is meant to provide a light
syntax to support the development of JADE agents
and multi-agent systems in order to ease the adop-
tion of the framework also from novice programmers.
The effort made in carefully selecting appropriate ab-
stractions seems to provide quantitative benefits, at le-
ast, in terms of the quantity of produced code and in
terms of its maintainability. The example proposed in
this paper follows other examples discussed in other
papers, but this example emphasises the possibility of
using JADEL to solve problems that are normally ad-
dressed using actors. JADE agents can behave as ac-
tors, and JADEL provides an effective means to deve-
lop and deploy them.
Besides improving the robustness of the tools that
support JADEL, an envisaged improvement of the
language regards the possibility of turning JADEL
into a hybrid language in the spirit of Alma-0 (Apt
et al., 1998). Such an extension woud give first
class citizenship in the language to logic variables
and to relevant types of constraints, like those discus-
sed in (Bergenti et al., 2016d; Bergenti et al., 2016e;
Bergenti and Monica, 2017c; Bergenti and Monica,
2017a), and it could move JADEL towards a more de-
Table 1: Number of LOCs and number of AOP features (in
percentage over the total number of LOCs in each group of
source codes) for JADEL and JADE implementations of the
Santa Claus example.
JADEL
Agents Behaviours Ontology
LOCs 19 68 5
AOP (%) 57.89 61.76 80
JADE
Agents Behaviours Ontology
LOCs 54 237 64
AOP (%) 33.34 29.54 17.19
clarative style of programming, while remaining im-
perative and event-based.
REFERENCES
Apt, K. R., Brunekreef, J., Partington, V., and Schaerf, A.
(1998). Alma-0: An imperative language that supports
declarative programming. ACM Transactions on Pro-
gramming Languages and Systems, 20(5):1014–1066.
Bellifemine, F., Bergenti, F., Caire, G., and Poggi, A.
(2005). JADE – A Java agent development frame-
work. In Bordini, R. H., Dastani, M., Dix, J., and
El Fallah Seghrouchni, A., editors, Multi-Agent Pro-
gramming: Languages, Platforms and Applications,
pages 125–147. Springer.
Bergenti, F. (2014). An introduction to the JADEL pro-
gramming language. In Proc. IEEE 26
th
Int. Conf.
Tools with Artificial Intelligence (ICTAI), pages 974–
978. IEEE Press.
Bergenti, F., Caire, G., and Gotta, D. (2012). Interactive
workflows with WADE. In Proc. 21
st
IEEE Int. Conf.
Collaboration Technologies and Infrastructures (WE-
TICE 2012), pages 10–15. IEEE Press.
Bergenti, F., Caire, G., and Gotta, D. (2013). An over-
view of the AMUSE social gaming platform. In Proc.
14
th
Workshop “Dagli Oggetti agli Agenti” (WOA
2013), volume 1099 of CEUR Workshop Proceedings.
RWTH Aachen University.
Bergenti, F., Caire, G., and Gotta, D. (2014). Agent-based
social gaming with AMUSE. In Proc. 5
th
Int. Conf.
Ambient Systems, Networks and Technologies (ANT
2014) and 4
th
Int. Conf. Sustainable Energy Infor-
mation Technology (SEIT 2014), Procedia Computer
Science, pages 914–919. Elsevier.
Bergenti, F., Caire, G., and Gotta, D. (2015). Large-scale
network and service management with WANTS. In
Industrial Agents: Emerging Applications of Software
Agents in Industry, pages 231–246. Elsevier.
Bergenti, F., Gleizes, M.-P., and Zambonelli, F., editors
(2004). Methodologies and Software Engineering for
Agent Systems: The Agent-Oriented Software Engi-
neering Handbook. Springer.
An Illustrative Example of the JADEL Programming Language
287

Bergenti, F., Iotti, E., Monica, S., and Poggi, A. (2016a).
A case study of the JADEL programming language.
In Proc. 17
th
Workshop “Dagli Oggetti agli Agenti”
(WOA 2016), volume 1664 of CEUR Workshop Pro-
ceedings, pages 85–90. RWTH Aachen University.
Bergenti, F., Iotti, E., Monica, S., and Poggi, A. (2016b).
Interaction protocols in the JADEL programming lan-
guage. In Proc. 6
th
Int. Workshop Programming Ba-
sed on Actors, Agents, and Decentralized Control
(AGERE 2016), pages 11–20. ACM Press.
Bergenti, F., Iotti, E., Monica, S., and Poggi, A. (2017).
Agent-oriented model-driven development for JADE
with the JADEL programming language. Computer
Languages, Systems & Structures, 50(C):142–158.
Bergenti, F., Iotti, E., and Poggi, A. (2016c). Core fea-
tures of an agent-oriented domain-specific language
for JADE agents. In Trends in Practical Applicati-
ons of Scalable Multi-Agent Systems, 14
th
Int. Conf.
Practical Applications of Agents and Multi-Agent Sy-
stems (PAAMS 2016), volume 9662 of Lecture Notes
in Computer Science, pages 213–224. Springer.
Bergenti, F. and Monica, S. (2016). Location-Aware So-
cial Gaming with AMUSE. In Trends in Practical
Applications of Scalable Multi-Agent Systems, 14
th
Int. Conf. Practical Applications of Agents and Multi-
Agent Systems (PAAMS 2016), volume 9662 of Lec-
ture Notes in Computer Science, pages 36–47. Sprin-
ger.
Bergenti, F. and Monica, S. (2017a). Hyper-arc consistency
of polynomial constraints over finite domains using
the modified Bernstein form. Annals of Mathematics
and Artificial Intelligence, 80(2):131–151.
Bergenti, F. and Monica, S. (2017b). An optimization-based
algorithm for indoor localization of JADE agents.
In Proc. 18
th
Workshop “Dagli Oggetti agli Agenti”
(WOA 2017), volume 1867 of CEUR Workshop Pro-
ceedings, pages 65–70. RWTH Aachen University.
Bergenti, F. and Monica, S. (2017c). Satisfaction of poly-
nomial constraints over finite domains using function
values. In 32
nd
Italian Conference on Computational
Logic, volume 1949 of CEUR Workshop Proceedings,
pages 262–275. RWTH Aachen.
Bergenti, F., Monica, S., and Rossi, G. (2016d). Polynomial
constraint solving over finite domains with the modi-
fied Bernstein form. In Fiorentini, C. and Momigli-
ano, A., editors, 31
st
Italian Conference on Computa-
tional Logic, volume 1645 of CEUR Workshop Pro-
ceedings, pages 118–131. RWTH Aachen.
Bergenti, F., Monica, S., and Rossi, G. (2016e). A sub-
division approach to the solution of polynomial con-
straints over finite domains using the modified Bern-
stein form. In Adorni, G., Cagnoni, S., Gori, M., and
Maratea, M., editors, AI*IA 2016 Advances in Artifi-
cial Intelligence, volume 10037 of Lecture Notes in
Computer Science, pages 179–191. Springer.
Bergenti, F., Rimassa, G., Somacher, M., and Botelho,
L. M. (2003). A FIPA compliant goal delegation
protocol. In Huget, M.-P., editor, Communication in
Multiagent Systems: Agent Communication Langua-
ges and Conversation Policies, volume 2650 of Lec-
ture Notes in Artificial Intelligence, pages 223–238.
Springer.
Bordini, R. H., H
¨
ubner, J. F., and Wooldridge, M.
(2007). Programming multi-agent systems in Agent-
Speak using Jason. John Wiley & Sons.
Demirkol, S., Challenger, M., Getir, S., Kosar, T., Kardas,
G., and Mernik, M. (2012). SEA L: A domain-
specific language for Semantic Web enabled multi-
agent systems. In Federated Conference on Compu-
ter Science and Information Systems (FedCSIS), pages
1373–1380.
Fichera, L., Messina, F., Pappalardo, G., and Santoro, C.
(2017). A Python framework for programming auto-
nomous robots using a declarative approach. Science
of Computer Programming, 139:36–55.
Finger, M., Fisher, M., and Owens, R. (1993). MetateM
at work: Modelling reactive systems using executa-
ble temporal logic. In Proc. 6
th
Int. Conf. Indus-
trial and Engineering Applications of Artificial Intel-
ligence and Expert Systems (IEA/AIE-93).
Fowler, M. (2010). Domain-specific languages. Pearson
Education.
Kravari, K. and Bassiliades, N. (2015). A survey of agent
platforms. Journal of Artificial Societies and Social
Simulation, 18(1):11.
Monica, S. and Bergenti, F. (2015). Location-aware JADE
agents in indoor scenarios. In Proc. 16
th
Workshop
“Dagli Oggetti agli Agenti” (WOA 2015), volume
1382 of CEUR Workshop Proceedings, pages 103–
108, Napoli, Italy. RWTH Aachen University.
Monica, S. and Bergenti, F. (2016a). A comparison of accu-
rate indoor localization of static targets via WiFi and
UWB ranging. In Trends in Practical Applications of
Scalable Multi-Agent Systems, 14
th
Int. Conf. Practi-
cal Applications of Agents and Multi-Agent Systems
(PAAMS 2016), volume 473 of Advances in Intelligent
Systems and Computing, pages 111–123. Springer.
Monica, S. and Bergenti, F. (2016b). Experimental evalu-
ation of agent-based localization of smart appliances.
In 14
th
European Conference on Multi-Agent Systems
(EUMAS 2016), volume 10207 of Lecture Notes on
Artificial Intelligence, pages 293–304. Springer.
Monica, S. and Bergenti, F. (2017). Indoor localization of
JADE agents without a dedicated infrastructure. In
Proc. 15
th
German Conference on Multiagent System
Technologies (MATES 2017), volume 10413 of Lec-
ture Notes in Artificial Intelligence, pages 256–271.
Springer.
Monica, S. and Ferrari, G. (2013a). Impact of the number
of beacons in PSO-based auto-localization in UWB
networks. In Proc. 15
th
European Conference on the
Applications of Evolutionary Computation (EvoAppli-
cations 2013), volume 7835 of Lecture Notes in Com-
puter Science, pages 42–51. Springer.
Monica, S. and Ferrari, G. (2013b). Optimized anchors
placement: An analytical approach in UWB-based
TDOA localization. In Proc. 9
th
International Wi-
reless Communications & Mobile Computing Confe-
rence (IWCMC 2013), pages 982–987. IEEE Press.
Monica, S. and Ferrari, G. (2013c). Particle swarm op-
timization for auto-localization of nodes in wireless
ICAART 2018 - 10th International Conference on Agents and Artificial Intelligence
288

sensor networks. In Proc. 11
th
International Confe-
rence on Adaptive and Natural Computing Algorithms
(ICANNGA 2013), volume 7824 of Lecture Notes in
Computer Science, pages 456–465. Springer.
Monica, S. and Ferrari, G. (2014a). Accurate indoor lo-
calization with UWB wireless sensor networks. In
Proc. 23
rd
IEEE International Conference on Ena-
bling Technologies: Infrastructure for Collaborative
Enterprises (WETICE 2014), pages 287–289. IEEE
Press.
Monica, S. and Ferrari, G. (2014b). An experimental model
for UWB distance measurements and its application to
localization problems. In Proc. 14
th
IEEE Internati-
onal Conference on Ultra Wide Band (ICUWB 2014),
pages 297–302, Paris, France. IEEE Press.
Monica, S. and Ferrari, G. (2014c). Swarm intelligent ap-
proaches to auto-localization of nodes in static UWB
networks. Applied Soft Computing, 25:426–434.
Monica, S. and Ferrari, G. (2015a). A swarm intelligent
approach to 3D distance-based indoor localization.
In Proc. 17
th
European Conference on the Applica-
tions of Evolutionary Computation (EvoApplications
2015), volume 9028 of Lecture Notes in Computer
Science, pages 91–102. Springer.
Monica, S. and Ferrari, G. (2015b). UWB-based localiza-
tion in large indoor scenarios: Optimized placement
of anchor nodes. IEEE Transactions on Aerospace
and Electronic Systems, 51(2):987–999.
Monica, S. and Ferrari, G. (2016). A swarm-based approach
to real-time 3D indoor localization: Experimental per-
formance analysis. Applied Soft Computing, 43:489–
497.
Rao, A. S. (1996). AgentSpeak(L): BDI agents speak out
in a logical computable language. In Van de Velde,
W. and Perram, J. W., editors, Agents Breaking Away:
7
th
European Workshop on Modelling Autonomous
Agents in a Multi-Agent World (MAAMAW ’96), vo-
lume 1038 of Lecture Notes in Artificial Intelligence,
pages 42–55. Springer.
Rodriguez, S., Gaud, N., and Galland, S. (2014). SARL:
A general-purpose agent-oriented programming lan-
guage. In Proc. IEEE/WIC/ACM Int. Joint Confe-
rences of Web Intelligence (WI) and Intelligent Agent
Technologies (IAT), volume 3, pages 103–110. IEEE
Press.
Shoham, Y. (1991). AGENT-0: A simple agent language
and its interpreter. In Proc. of the 9
th
National Con-
ference on Artificial Intelligence (AAAI), volume 91,
pages 704–709.
Shoham, Y. (1997). An overview of agent-oriented pro-
gramming. In Bradshaw, J., editor, Software agents,
volume 4, pages 271–290. MIT Press.
Thomas, S. R. (1995). The PLACA agent programming lan-
guage. In Wooldridge, M. J. and Jennings, N. R., edi-
tors, Intelligent Agents: ECAI-94 Workshop on Agent
Theories, Architectures, and Languages, pages 355–
370. Springer.
Trono, J. A. (1994). A new exercise in concurrency. ACM
SIGCSE Bulletin, 26(3):8–10.
An Illustrative Example of the JADEL Programming Language
289