[ecoop-info] Tutorial on the SARL Agent Programming Language at EUSPN18

Stephane Galland stephane.galland at utbm.fr
Fri May 25 16:32:57 CEST 2018

                                  Tutorial on SARL

at the 9th International Conference on Emerging Ubiquitous Systems and Pervasive
Networks (EUSPN18)

Leuven, Belgium
November 5-8, 2018


1. Description

Complex software development calls for appropriate high-level features to better and
easily tackle the new requirements in terms of interactions, concurrency and
distribution. This demands a paradigm change in software engineering and
corresponding programming languages. Agent-oriented programming may provide the
appropriate support for this change by focusing on a small corpus of commonly
accepted concepts and in line with the current developers' programming practices.

This tutorial introduces SARL (http://www.sarl.io), a new general-purpose
agent-oriented programming language undertaking this challenge. The main perspective
that guided the creation of SARL is the establishment of an open and easily extensible

Several agent-oriented frameworks are known and recognized in the academic and
not-academic communities, such as MATSIM (transport simulation), Gama (geospatial
simulation), or NetLogo. Unlike these tools, SARL is not just a framework for creating
simulation software. Indeed, SARL is a programming language for creating agents that
could be ran either in a simulator or in a non-simulated environment. Moreover,
like NetLogo, SARL is not dedicated to an application domain, such as MATSIM for
transport simulation. SARL offers tools (language, behavior libraries, user interface
libraries, simulation engine, etc.) to build agent-based applications. SARL has
been used successfully to simulate road traffic, crowd movements, smart grid
management, and to control autonomous cars in real-time control.'''

SARL aims at providing the fundamental abstractions for dealing with concurrency,
distribution, interaction, decentralization, reactivity, autonomy and dynamic reconfiguration.
These high-level features are now considered as the major requirements for an easy and
practical implementation of modern complex software applications. We are convinced that
the agent-oriented paradigm (AOP) holds the keys to effectively meet this challenge.

Indeed, the ultimate goal of agent-oriented software engineering (AOSE) and
programming is the establishment of a new standard paradigm able to succeed
object-oriented paradigm to ease the development of complex software applications
by providing higher-level abstractions. However, it is clear that AOP has not yet
a significant influence on the current mainstreams and standards in software
programming. One possible explanation may be that most of contributions in AOP
remain highly theoretical and rather far from industrial concerns and related
developers' programming practices. We adopt a different perspective capitalizing
on previous experiences aspiring to define a small corpus of concepts only
focusing on the key principles. Considering the variety of existing approaches and
meta-models, but also the lack of established standards in the field of AOSE and
more generally multi-agent systems, our approach remains as generic as possible and
highly extensible to easily integrate new concepts and features. The idea is not to
respond to every issue immediately but rather to provide a first set of concepts,
the corresponding programming language as well as a set of tools for supporting its
implementation. Our expectations is to provide the community with a common forum in
terms of a first working testbed to study and compare various programming alternatives
and associated meta models.

In this perspective, SARL is platform-independent and agent's architecture-agnostic.
It provides a set of agent-oriented first-class abstractions directly at the language
level, but it was designed to ease the integration and the mapping of concepts
provided by other meta models. SARL itself exploits this extension mechanism for
defining its own extensions (organizational, event-driven, etc.) and also natively
supports the notion of holonic multi-agent systems and recursive agent (also called
Holon), but does not force the developer to use it.

SARL comes with its full support in the Eclipse IDE for compilation and debugging
purposes. We also provide a first set of tools to support its execution. SARL
compiler generates Java code that can then be integrated within any agent platforms
supporting Java libraries.

2. Content of the Tutorial

The tutorial will introduce SARL's main concepts, providing basic knowledge to develop
multi-agent systems with SARL. Then, we will present more advanced concepts like
agent's architecture extensions and recursive agents programming (Holonic MAS).

* Introduction to Agent Oriented Programming
* Basic SARL concepts
* Development Environment
* Execution Environment
* Extending SARL Agents capabilities
* Holonic Multiagent programming
* Demos and Examples

Prof. Dr. Stephane GALLAND <stephane.galland at utbm.fr>

3. Requirements

No specific knowledge on computer programming is required to follow this tutorial.

4. Registration

Please visit the EUSPN18 Registration Page
for more information.

5. Venue, Accomodation & Visa Requirements

Please visit the EUSPN18 Venue & Accomodation Page
for more information.

More information about the ecoop-info mailing list