-This paper outlines the major features of Jadescript, a scripting language designed to support agent-oriented programming. The core abstractions that Jadescript provides are those related to event-driven agents and message passing, and the view of multi-agent systems that it promotes is closely related to that offered by JADE. Programmers using Jadescript are granted a dedicated syntax largely inspired by modern scripting languages, and major programming activities are supported in the scope of the language with a marked raise of the level of abstraction with respect to the direct use of JADE.
Agent-Oriented Programming (AOP), as described in [
Despite being a language intended to support programmers
in the effective use of JADE, Jadescript is not an
objectoriented language, at least not directly. Every Jadescript source
file, if valid, is primarily intended to be compiled to one or
more Java source files. Such files are then compiled to Java
bytecode using one of the available Java compilers, and they
are executed by a Java Virtual Machine (JVM) with the help
of JADE. Such an approach has already been proved effective,
and it is currently adopted, e.g., by JADEL and by SARL [
Finally, another important reason for the choice of compiling
Jadescript source codes to Java source codes regards the
availability of very powerful tools in the Eclipse ecosystem
for the construction of this type of compilers. In particular,
sharing the approach of, e.g., JADEL and SARL, the current
implementation of the Jadescript compiler uses the tools
of Xtext [
This paper is organised as follows. Section II shows a brief overview of Jadescript with emphasis on supported agentoriented abstractions using an illustrative example. Section III concludes the paper and discusses possible future developments of the language and of its tools. II. OVERVIEW OF JADESCRIPT
Jadescript is a statically typed language, and its type system is based on five groups of types: primitive types, ontology types, collection types, behaviour types, and agent types. The following is the list of primitive types currently supported by the language (in alphabetical order): 1) boolean: Boolean logical values; 2) double: double-precision floating-point numbers; 3) float: single-precision floating-point numbers; 4) integer: integer numbers; and 5) text: texts (strings of characters).
Note that primitive types, with the exception of texts, are mapped to Java primitive types with similar names.
Structured types are supported in Jadescript in terms of concepts, propositions, predicates and actions declared in ontologies (see Subsection II-C). Such structured types can refer to other primitive, collection or ontology types. Fig. 1 shows an example of a declaration of an ontology which includes the declarations of two concepts, one predicate, and one action.
Jadescript is an AOP language intended to support the
implementation of agents using an event-driven style of
programming with emphasis on the possibility for agents to
exchange structured messages. The major abstractions that it
supports are (communication) ontologies, (agent) behaviours,
and agents. Such abstractions are well-known to JADE
programmers, and Jadescript keeps them exactly as JADE
programmers would expect (e.g., [
In order to ease descriptions, the features of Jadescript
discussed in this section are often presented using illustrative
examples. Besides minimal examples used in the description 1 ontology BookShop
of statements and expressions, the illustrative example used 2 concept person(surname as text,
to present the agent-oriented features of the language is a 3 name as text)
variation of the well-known ping-pong example discussed in 4
JADE documentation [
Upon executing the requested action, pong agents send back Jadescript offers two collection types used to refer to
a FIPA inform message [
The remaining of this section describes the features that can Finally, behaviour types and agent types are provided for be included in a Jadescript source file. Note that a Jadescript the manipulation of behaviours (see Subsection II-D) and of source file always has a specific structure. It starts with the agents (see Subsection II-E), respectively. Every behaviour mandatory declaration of the module where all features defined definition or agent definition implicitly defines a new data in the source file are contained using the keyword module. type, whose use is restricted with respect of other data types. Modules are simply intended as named groups of features, In particular, Jadescript provides specific constructs for the each of which can be public or private to the module. After manipulation of behaviours and of agents to ensure that such the declaration of the module, imported features from other abstractions are given first-class support in the language. modules are enumerated using the keyword import. Finally, Given that Jadescript is designed as a statically typed a list of definitions related to the major features supported language, the types of all features defined and referenced in by the language, i.e., ontologies, behaviours, and agents, is a source code are known at compile time, and there is no provided. All such features are discussed in the following after way to synthesise new types at run time. However, in order to a brief note on the procedural features of the language. relieve the programmer from the burden of explicitly declaring the types of variables, the Jadescript compiler infers automatically the types of variables from mandatory initialisation expressions. Therefore, there is no need to explicitly declare the types of variables in Jadescript. In addition, the compiler tracks declared names and when a new name is found in an assignment statement, it assumes that a new variable is implicitly declared. Note that the sort of type inference that Jadescript provides is limited with respect to other languages, and the types of some elements of a Jadescript source code, e.g., the types of formal parameters in function declarations, need to be explicitly stated.
Jadescript is an event-driven language and, as such, it provides the common statements and expressions of procedural languages. The following is a summary of supported statements and expressions that cannot be considered specific to the agent-oriented style of programming. AOP statements and expressions are discussed together with the agent-oriented abstractions that they support.
In the tradition of the programming languages derived from the C language, function calls can be used as statements in Jadescript. In addition, the do-nothing statement is just a placeholder to allow users to write empty blocks of code. The do-nothing statement is necessary because the delimitation of blocks in Jadescript is based on indentation.
Jadescript provides a single statement to declare variables and to perform assignments. The common infix = operator is provided for such tasks. As discussed at the end of previous subsection, the types of variables is inferred by the compiler from mandatory initialisation expressions, and there is no need to make types explicit.
Jadescript provides the create statement to create instances of collection and ontology types. After the create keyword, the first required term is the type of which the instance is being created. Right after that, an identifier is required, which determines the name of the new variable that refers to the created value. If needed, a list of named arguments is provided after the with keyword. Fig. 2 is an example which uses the ontology types declared in Fig. 1. 1 create book odyssey with author homer, 2 title "Odyssey", price 19.99
The classic if statement can be used to express conditional blocks of code. Like in most procedural languages, the if statement can also have multiple if-else branches and an optional else branch at the end. After every condition, a new block of code must be opened by increasing the indentation level. The semantics of this statement is intuitively the same of conditional constructs in common procedural languages.
Jadescript provides a first form of iterative statement in terms of the common while-do statement. In addition, iteration over collections is supported with the for-in-do statement, which can be used to iterate over the elements of lists or over the keys of maps. At each iteration, an element from the collection which follows the in keyword is extracted and, before the body of the statement is executed, it is assigned to a variable whose name is declared after the for keyword.
In the procedural parts of a Jadescript source code, the return statement can be used to terminate the execution of a procedure or of a function and possibly return a value to the caller. The use of the return statement is mandatory in functions and all possible execution paths of a function must terminate with a proper return statement.
A set of statements is provided by Jadescript to work on collection types. In particular, add-to, remove-from, and clear statements are used to manipulate the contents of lists.
Note that add-to and remove-from can possibly specify an optional index to work on an element different from the last element of the list. Similarly, remove-from and clear are available for maps. Note that other common operations on collections, e.g., the operation to access singles elements of a list, are provided in terms of expressions.
Just like common procedural languages, Jadescript offers a system of expressions. Every expression computes a value and the types of computed values are determined by the compiler.
Operations can be combined to share operands and common precedence and associativity rules are adopted to disambiguate the order of evaluation. As usual, a limited set of expressions can also be used at the left side of the = operator.
Ordinary Boolean expressions are formed in Jadescript using the keywords and, or, and not. Such Boolean operations follow a lazy evaluation scheme: if the value of the whole operation can be deducted from the evaluation of the first operand, the second operand is not evaluated. In addition, ordinary comparison operators with common semantics are provided. Finally, arithmetic expressions are supported in Jadescript using ordinary operators for addition, subtraction, multiplication, division, and modulo.
Jadescript provides operators to work with collection types.
Ordinary square brackets are available to access the elements of lists and maps. When applied to lists, they require a nonnegative integer to be used as an index in the list. When applied to maps, they require a value compatible with the type of the keys to access the corresponding value in the map. Note that square brackets can also be used at the left side of the = operator to modify lists and maps. In addition, the size-of operator can be used to retrieve the number of elements of lists and maps. The contains operator has the function to check if the collection returned by the evaluation of the leftside operand contains the element returned by the evaluation of the right-side operand. It can work on lists and on the keys of maps. Finally, Jadescript offers a concise way to instantiate lists and maps by declaring their contents. A list literal is written as a comma-separated list of values between square brackets. The type of the elements contained in the list is computed by finding the closest common ancestor of all types in the list literal. Similarly, Jadescript offers a way to quickly instantiate a map by enumerating a set of key-value pairs. A map literal is written as a comma-separated list of key-value pairs between curly brackets, where keys are separated from values by colons. The type of the keys of the map is computed by finding the closest common ancestor of all types of the keys of the map literal. The type of the values of the map is computed by finding the closest common ancestor of all types of the values of the map literal.
Type casting is supported in Jadescript using the as operator, which forces the type of the result of the evaluation of the expression on its left side to the type specified on its right side, if types are actually compatible. Type inspection is supported in Jadescript by means of a specific operator. The is operator checks if the type of the value computed by the expression at its left side is actually compatible with the type specified as right operand.
Behaviours are used to describe how agents operate
during their lifetime in the multi-agent system. In Jadescript,
these are built on top of JADE behaviours and they are
characterised by the peculiar scheduling mechanisms of JADE
behaviours [
More complex types of behaviours, as supported by JADE, are planned for future versions of the language. The declaration of a behaviour can restrict the type of the agents that can use the behaviour by means of the construct for-agent, and it can link the behaviour to an ontology with the construct uses-ontology. Finally, the declaration of a behaviour C. Ontologies is completed with a list of optional features to be used to
Ontologies are used by agents to share concepts, actions, actually implement the behaviour. Such features are properties,
predicates, and propositions, and to refer to them in messages functions, procedures, actions, and (event) handlers. Note that,
(e.g., [
With the exception of propositions, all features declared in be requested to perform, and they are primarily intended to an ontology can be used to create structured values, whose support communication among agents. elements can be accessed using the of operator. Fig. 4 shows Various on constructs can be used to declare (event) hanan example of the use of such an operator at the left side and dlers in the scope of behaviours. Handlers are used to identify at the right side of the = operator. the blocks of code that are supposed to be executed when interesting events occur. For the time being, the most important 1 author of odyssey = author of iliad type of event handler available in behaviours is intended to support the reception of messages. Handlers of this type assign Fig. 4. Example of the use of the of operator in Jadescript. a name to the messages being received and specify a condition that interesting messages are demanded to satisfy.
Behaviours can be activated using the specific activate-behaviour statement, which can be used inside the actions of agents and behaviours. This statement creates a new behaviour and it marks the behaviour as active, so that the behaviour can be scheduled for execution by the agent. Some behaviours need a set of arguments in order to be properly initialised. Such arguments are passed to the behaviour by using the with keyword in the scope of the activate-behaviour statement.
It is evident that sending and receiving messages are the
central activities to support agent communication in
multiagent systems. The on-when-do construct is meant to
manage incoming messages, while the send statement is used to
manage outgoing messages. There are two syntactical forms
of the send statement. The most basic form can be used if an
instance of the concept describing FIPA messages is available,
and it allows accessing all the features of FIPA messages [
Fig. 5 shows two behaviours used to implement the pingpong example. The SendToPong behaviour is scheduled by ping agents to send messages to pong agents, while ReplyToPings behaviour is used by pong agents to reply. The count of outbound messages is a property of ping agents. 1 one shot behaviour SendToPong for agent Ping uses ontology PingPong 2 3 4 other as aid 5 6 on create with pong as aid do 7 other = pong 8 9 do 10 counter = counter of agent 11 12 13 14 counter of agent = counter + 1 15 16 cyclic behaviour ReplyToPings for agent Pong uses ontology PingPong
send request reply(counter) to other on message m when performative of m is request and counter of m is reply do r = content of m as reply c = counter of r send inform alive(c) to sender of m
Jadescript multi-agent systems. Essentially, they are JADE
agents and they can be defined using the agent construct.
Agents are structured in terms of the following features:
properties, procedures, functions, and (event) handlers. Properties,
procedures, and functions are the same features available in the
declaration of behaviours. In particular, the of operator can be
used to access the properties of agents. Handlers are restricted
forms of handlers with respect to the handlers available in
behaviours because they can be used only to react to events
regarding the lifecycle state of agents. One of such events is
captured with the on-create handler, which is activated
just before the agent becomes available to the multi-agent
system. Similarly, the on-destroy handler is triggered just
before the agent is removed from the multi-agent system.
Interested readers should consult JADE documentation [
This paper presented a brief overview of the Jadescript
programming language. Jadescript is a language for
eventdriven programming which supports the implementation of
agents and multi-agent systems by means of specific syntax
and semantics. The adopted syntax is designed to reduce the
gap between a Jadescript agent and a semantically equivalent
pseudocode, and it uses the common features of a modern
scripting language. The long-term vision of this project is
to allow programmers to easily adopt agents and multi-agent
systems to benefit from their relevant features in terms of
reusability and composability, and interoperability (e.g., [
One of the major planned developments of the discussed
work regards the possibility of managing events different from
the reception of messages. This would require the definition
of a framework to let event provider feed events to agents,
and it would require syntactic enhancements to the language
to allow reacting to events in the environment and proactively
sensing the environment. Such a possibility would allow the
use of Jadescript in situations where agents are immersed
in complex and dynamic environments, e.g., the industrial
environments discussed in [
Jadescript is currently supported by a set of tools packed as an Eclipse plug-in to ease the adoption from programmers with no specific background on agent technology. The current version of tools and related documentation is available upon request for authors, and an open-source distribution is planned for the near future.