-We believe that agent-oriented programming languages and multi-agent programming technologies provide an effective level of abstraction for tackling the design and programming of mainstream software applications, besides being techniques effective for dealing with (Distributed) Artificial Intelligence problems. In this paper we support this claim in practice by discussing the use of a platform integrating two main agent programming technologies - Jason agent programming language and CArtAgO environment programming framework - to the development of Web 2.0 applications. Following the cloud computing perspective, these kinds of applications will more and more replace desktop applications, exploiting the Web infrastructure as a common distributed operating system, raising however challenges that are not effectively tackled - we argue - by mainstream programming paradigms, such as the objectoriented one.
The value of Agent-Oriented Programming (AOP) [
In this paper we show this idea in practice by describing
a platform for developing Web 2.0 applications using agent
programming technologies, in particular Jason for
programming agents and CArtAgO for programming the environments
where agents work. We refer to the integrated use of Jason
and CArtAgO as JaCa and its application for building Web
2.0 application as JaCa-Web. Besides describing the
platform, our aim here is to discuss the key points that make
JaCa and – more generally – agent-oriented programming a
suitable paradigm for tackling main complexities of software
applications, advanced Web applications in this case, that
– we argue – are not properly addressed by mainstream
programming languages, such as object-oriented ones. In that,
this work extends a previous one [
The remainder of the paper is organised as follows. First, we provide a brief overview of JaCa (Section II) programming model and platform. Then, we discuss the use of JaCa for developing Web 2.0 applications (Section III), remarking the advantages compared to existing state-of-the art approaches. To evaluate the approach, we describe the design and implementation of a case study (Section IV), and we conclude the paper by discussing related and future work (Section V).
APPLICATION DEVELOPMENT – THE JaCa APPROACH
An application in JaCa is designed and programmed as
a set of agents which work and cooperate inside a
common environment. Programming the application means then
programming the agents on the one side, encapsulating the
logic of control of the tasks that must be executed, and
the environment on the other side, as first-class abstraction
providing the actions and functionalities exploited by the
agents to do their tasks. More specifically, in JaCa Jason [
Being a concrete implementation of an extended version
of AgentSpeak(L) [
Plans are courses of actions that agents commit to execute so as to achieve their goals. The pro-active behaviour of agents is possible through the notion of goals (desired states of the world) that are also part of the language in which plans are written. Besides interacting with the environment, Jason extended to manage also (Java) objects, so as to work with data agents can communicate by means of speech acts. exchanged by performing actions and processing percepts.
On the environment side, CArtAgO – following the A&A A full description of Jason language/platform and
meta-model [
Finally, the notion of workspace is used to define the of Web 2.0 is a new interaction model between the client topology of complex environments, that can be organised user interface of a Web browser and the server-side of the as multiple sub-environments, possibly distributed over the application. Such rich Web applications allow the client to network. By default, each workspace contains a predefined send multiple concurrent requests in an asynchronous way, set of artifact created at boot time, providing basic actions to avoiding complete page reload and keeping the user interface manage the set of artifacts in the workspace – for instance, live and responding. Periodic activities within the client-side to create, lookup, link together artifacts – to join multiple of the applications can be performed in the same fashion, with workspaces, to print message on the console, and so on. clear advantages in terms of perceived performance, efficiency
JaCa integrates Jason and CArtAgO so as to make the and interactivity. use of artifact-based environments by Jason agents seamless. So the more complex web apps are considered, the more To this purpose, first, the overall set of external actions that a the application logic put on the client side becomes richer, Jason agent can perform is determined by the overall set of eventually including asynchronous interactions – with the user, artifacts that are actually available in the workspaces where with remote services – and possibly also concurrency – due to the agent is working. So, the action repertoire is dynamic and the concurrent interaction with multiple remote services. This can be changed by agents themselves by creating, disposing situation is exemplified by cloud computing applications, such artifacts. Then, the overall set of percepts that a Jason as Google doc3. agent can observe is given by the observable properties and The direction of decentralizing responsibilities to the client observable events of the artifacts available in the workspace at is evident also by considering the new HTML standard 5.0, runtime. Actually an agent can explicitly select which artifacts which enriches the set of API and features that can be used to observe, by means of a specific action called focus. By ob- by the web application on the client side4. Among the others, serving an artifact, artifacts’ observable properties are directly some can have a strong impact on the way an application mapped into beliefs in the belief-base, updated automatically is designed: it is the case of the Web Worker mechanism5, each time the observable property changes its value. So a which makes it possible to spawn background workers running Jason agent can specify plans reacting to changes to beliefs scripts in parallel to their main page, allowing for thread-like that concern observable properties or can select plan according operation with message-passing as coordination mechanism. to the value of beliefs which refer to observable properties.
Artifacts’ signals instead are not mapped into the belief base, 1http://jason.sourceforge.net but processed as non persistent percepts possibly triggering 32hhttttpp::////cdaorctsa.ggoo.osoguler.cceofmorge.net plans—like in the case of message receipt events. Finally, the 4http://dev.w3.org/html5/spec/ Jason data-model – essentially based on Prolog terms – is 5http://www.whatwg.org/specs/web-workers/current-work/ User prime-app-workspace
primeService1 myPage maxnum 100 nprimes 4 incPrimes
PrimeSearcher
PrimeSearcher Jason
CArtAgO Java Virtual Machine
Browser checkPrime
HTTP numGen current 8
nextNum primeService2
chcehcekcPkrPi mrimee JaCa-Web Artifacts
Web tech (JavaScript, LiveConnect, ...)
RemotePrimeService
Another one is cross-document messaging6, which defines B. An Agent-Oriented Programming Approach based on JaCa mechanisms for communicating between browsing contexts in By exploiting JaCa, we directly program the Web 2.0 HTML documents. application as a normal JaCa agent program, composed by
Besides devising enabling mechanisms, a main issue is then a workspace with one or multiple agents working within an
how to design and program applications of this kind [
A basic and standard way to realise the client side of web of artifacts specifically designed for the Web context domain app is to embed in the page scripts written in some scripting (see Fig. 1). Generally speaking, agents are used to encapsulate language – such as JavaScript. Originally such scripts were the logic of control and execution of the tasks that characterise meant just to perform check on the inputs and to create the Web 2.0 app, while artifacts are used to implement the visual effects. The problem is that scripting languages – like environment needed for executing the tasks, including those JavaScript – have not been designed for programming in the coordination artifacts that can ease the coordination of the large, so using them to organize, design, implements complex agents’ work. As soon as the page is downloaded by the programs is hard and error-prone. browser, the application is launched – creating the workspace,
To address the problems related to scripting languages, the initial set of agents and artifacts. higher-level approaches have been proposed, based on frame- Among the pre-defined types of artifact available in the works that exploit mainstream object-oriented programming workspace, two main ones are the Page artifact and the languages. A main example is Google Web Toolkit (GWT)7, HTTPService artifact. Page provides a twofold functionality to which allows for developing client-side apps with Java. This agents: (i) to access and change the web page, internally exchoice makes it possible to reuse and exploit all the strength ploiting specific low-level technology to work with the DOM of mainstream programming-in-the-large languages that are (Document Object Model) object, allowing for dynamically typically not provided by scripting languages—an example updating its content, structure, and visualisation style; (ii) to is strong typing. However it does not provide significant make events related to user’s actions on the page observable to improvement for those aspects that are still an issue for OO agents as percepts. An application may either exploit directly programming languages, such as concurrency, asynchronous Page or define its own extension with specific operations and events and interactions, and so on. observable properties linked to the specific content of the
We argue then that these aspects can be effectively cap- page. HTTPService provides basic functionalities to interact tured by adopting an agent-oriented level of abstraction and with a remote HTTP service, exploiting and hiding the use of programmed by exploiting agent-oriented technologies such as sockets and low-level mechanisms. Analogously to Page, this JaCa: in next section we discuss this point in detail. kind of artifact can be used as it is – providing actions to do HTTP requests – or can be extended providing an higher-level 6http://dev.w3.org/html5/postmsg/ application specific usage interface hiding the HTTP level. 7http://code.google.com/webtoolkit/ To exemplify the description of these elements and of JaCaWeb programming in the overall, in the following we consider a toy example of Web 2.0 app, in which two agents are used to search for prime numbers up to a maximum value which can specified and dynamically changed by the user through the web page. As soon as an agent finds a new prime number, a field on the the web page reporting the total number of values is updated.
The environment (shown in Fig. 1) includes – besides the artifact representing the page, called here myPage – an artifact called numGen, functioning as a number generator, shared and used by agents to get the numbers to verify, and two artifacts, primeService1 and primeService2, providing the (same) functionality that is verifying if a number is prime.
myPage is an instance of MyPage extending the basic Page artifact so as to be application specific, by: (i) defining an observable property maxnum whose value is directly linked to the related input field on the web page; (ii) generating start and stop signals as soon as the page button controls start and stop are pressed; (ii) defining an operation incPrimes that updates the output field of the page reporting the actual number of prime numbers found.
numGen is an instance of the NumGen artifact (see Fig. 3), which provides an action getNextNum to generate a new number – retrieved as output (i.e. action feedback) parameter.
The two prime number service artifacts provide the same usage interface, composed by a checkPrime(num: integer) action, which generates an observable event is_prime(num: integer) if the number is found to be prime. One artifact does the computation locally (LocalPrimeService); the other one, instead – which is an instance of RemotePrimeService, extending the predefined HTTPService artifact – provides the functionality by interacting with a remote HTTP service.
Fig. 2 shows the source code of one of the two agents.
After having set up the tools needed to work, the agent waits to perceive a start event generated by the page. Then, it starts working, repeatedly getting a new number to check – by executing a getNextNum – until the maximum number is achieved. The agent knows such a maximum value by means of the maxnum page observable property—which is mapped onto the related agent belief. The agent checks the number by performing the action checkPrime and then reacting to is_prime(Num: integer) event, updating the page by performing incPrimes. If a stop event is perceived – which means that the user pressed the stop button on the Web page – the agent promptly reacts and stops working, dropping its main intention.
A final note about implementation: Java applet technology is used to run the full application stack (including Jason and CArtAgO) in the browser, using signed applets so to avoid limitations imposed by the sandbox model. LiveConnect technology8 is exploited to enable a bi-direction interaction between the applet and the web page resources (DOM, scripts).
8https://jdk6.dev.java.net/plugin2/liveconnect/ }
} } } }
} 00 !setup. 01 02 +!setup 03 <- focusByName("MyPage"); 04 makeArtifact("primeService1",
"RemotePrimeService"); makeArtifact("numGen","NumGen"). 05 06 07 +start 08 <- focusByName("primeService1"); 09 focusByName("numGen"); 10 !!checkPrimes. 11 12 +!checkPrimes 13 <- nextNum(Num); 14 !checkNum(Num). 15 16 +!checkNum(Num): maxnum(Max) & Num <= Max 18 <- checkPrime(Num); 18 !checkPrimes. 19 20 +!checkNum(Num) <- maxnum(Max) & Num > Max. 21 22 +is_prime(Num) <- incPrimes. 23 24 +stop <- .drop_intention(checkPrimes).
Fig. 2. Jason source code of a prime searcher agent. public class MyPage extends PageArtifact { protected void setup() { defineObsProperty("maxnum",getMaxValue()); //Operation for event propagation linkEventToOp("start","click","startClicked"); linkEventToOp("stop","click","stopClicked"); linkEventToOp("maxnum","change","maxnumChange"); } @OPERATION void incPrimes(){
Elem el = getElementById("primes_found"); el.setValue(el.intValue()+1); } @INTERNAL_OPERATION private void startClicked(){
signal("start"); } @INTERNAL_OPERATION private void stopClicked(){
signal("stop"); } @INTERNAL_OPERATION private void maxnumChange(){
updateObsProperty("maxnum",getMaxValue()); } private int getMaxValue(){
return getElementById("maxnum").intValue(); public class RemotePrimeService extends HTTPService { @OPERATION void checkPrime(double n){
HTTPResponse res =
doHTTPRequest(serverAddr,"isPrime",n); if (res.getElem("is_prime").equals("true")){
signal("is_prime",n); public class NumGen extends Artifact { void init(){ defineObsProperty("current",0); } @OPERATION void nextNum(OpFeedbackParam<Integer> res){ int v = getObsProperty("current").intValue(); updateObsProperty("current",++v); res.set(v); } Fig. 3. Artifacts’ definition in CArtAgO: MyPage and RemotePrimeService extending respectively PageArtifact and HTTPService artifact types which are available by default in JaCa-Web workspaces, and NumGen to coordinate number generation and sharing.
represent main benefits of adopting agent-oriented programming and, in particular, the JaCa-Web programming model, for developing applications of this kind.
First, agents are first-class abstractions for mapping possibly concurrent tasks identified at the design level, so reducing the gap from design to implementation. The approach allows for choosing the more appropriate concurrent architecture, allocating more tasks to the same kind of agent or defining multiple kind of agents working concurrently. This allows for easily programming Web 2.0 concurrent applications, that are able to exploit parallel hardware on the client side (such as multi-core architectures). In the example, two agents are used to fairly divide the overall job and work concurrently, exploiting the number generator artifact as a coordination tool to share the sequence of numbers. Actually, changing the solution by using a single agent or more than two agents would not require any substantial change in the code.
A second key point provided by the agent control architecture is the capability of defining task-oriented computational behaviours that straightforwardly integrate the management of asynchronous events generated by the environment – such as the input of the user or the responses retrieved from remote services – and the management of workflows of possibly articulated activities, which can be organized and structured in plans and sub-plans. This makes it possible to avoid the typical problems produced by the use of callbacks – that can be referred as asynchronous spaghetti code – to manage events within programs that need – at the same time – to have one or multiple threads of control.
In the prime searcher agent shown in the example, for instance, on the one hand we use a plan handling the checkPrimes goal to pro-actively search for prime numbers. The plan is structured then into a subgoal checkNum to process the number retrieved by interacting with the number generator. Then, the plan executed to handle this subgoal depends on the dynamic condition of the system: if the number to process is greater than the current value of the maxnum page observable property (i.e. of its related agent belief), then no checks are done and the goal is achieved; otherwise, the number is checked by exploiting a prime service available in the environment and the a new checkPrimes goal is issued to go on exploring the rest of the numbers. The user can dynamically change the value of the maximum number to explore, and this is promptly perceived by the agents which can change then their course of actions accordingly. On the other hand, reactive plans are used to process asynchronous events from the environment, in particular to process incoming results from prime services (line 22) and user input to stop the research (line 24).
Finally, the third aspect concerns the strong separation of concerns which is obtained by exploiting the environment as first class abstraction. Jason agents, on the one side, encapsulates solely the logic and control of tasks execution; on the other side, basic low-level mechanisms to interact and exploit the Web infrastructure are wrapped inside artifacts, whose functionalities are seamlessly exploited by agents in terms of actions (operations) and percepts (observable properties and events). Also, application specific artifacts – such as NumGen – can be designed to both encapsulate shared data structures useful for agents’ work and regulate their access by agents, functioning as a coordination mechanism.
To stress the features of agent-oriented programming and test-drive the capabilities of the JaCa-Web framework, we developed a real-world Web application – with features that go beyond the ones that are typically found in current Web 2.0 app. The application is about searching products and comparing prices from multiple services, a “classic” problem ton the Web.
We imagine the existence of N services that offer product lists with features and prices, codified in some standard machine-readable format. The client-side in the Web application needs to search all services for a product that satisfies a set of user-defined parameters and has a price inferior to a certain user-defined threshold. The client also needs to periodically monitor services so as to search for new offerings of the same product. A new offering satisfying the constraints should be visualised only when its price is more convenient than the currently best price. The client may finish its search and monitoring activities when some user-defined conditions are met—a certain amount of time is elapsed, a product with a price less than a specified threshold is find, or the user interrupts the search with a click on a proper button in the page displayed by the browser. Finally, if such an interruption took place, by pressing another button it must be possible to let the search continue from the point where it was blocked.
Typically applications of this kind are realised by implementing all the features on the server side, without – however – any support for long-term searching and monitoring capabilities. In the following, we describe a solution based on JaCa-Web, in which responsibilities related to the long-term search and comparison are decentralised into the client side of the application, improving then the scalability and quality of service for the users.
UserAssistant agent – which is responsible of setting up the application environment and manage interaction with the user – and multiple ProductFinder agents, which are responsible to periodically interact with remote product services to find the products satisfying the user-defined parameters. To aggregate data retrieved from services and coordinate the activities of the UserAssistant and ProductFinder we introduce a ProductDirectory artifact, while a MyPage page artifact and multiple instances of ProductService artifacts are used respectively by the UserAssistant and ProductFinder to interact with the user and with remote product services.
More in detail, the UserAssistant agent is the first agent booted on the client side, and it setups the application environ- ... ment by creating the ProductDirectory artifact and spawning +searchState("start") a number of ProductFinder agents, one for each service to <- f!o!csuesa(r"cshe.rvice1"); monitor. Then, by observing the MyPage artifact, the agent monitors user’s actions and inputs. In particular, the web +!s<e-arcrhe:qukeesytwPorroddsu(cKtesy(wKoerydwso)rds,ProductList); page provides controls to start, stop the searching process and !processProducts(ProductList, to specify and change dynamically the keywords related to PPrroodduuccttssTTooRAedmdo,ve); the product to search, along with the conditions to possibly addProducts(ProductsToAdd); terminate the process. Page events are mapped onto start r.ewmaoivte(P{r+okdeuycwtosr(dPsr(o_d)u}c,t5s0T0o0R,e_m)o;ve); and stop observable events generated by MyPage, while !search. specific observable properties – keywords and termination +searchState("stop") conditions – are used to make it observable the input infor- <-.drop_intention(search). mation specified by the user.
The UserAssistant reacts to these observable events and Fig. 5. A snippet of ProductFinder agent’s plans. to changes to observable properties, and interacts with ProductFinder agents to coordinate the searching process. The interaction is mediated by the ProductDirectory artifact, remote product service by means of a private ProductService which is used and observed by both the UserAssistant artifact, which extends a HTTPService artifact providing an and ProductFinders. In particular, this artifact provides a operation (requestProducts) to directly perform highusage interface with operations to: (i) dynamically update level product-oriented requests, hiding the HTTP level. the state and modality of the searching process – in particular startSearch and stopSearch to change the B. Implementation value of a searchState observable property – useful The source code of the application can be consulted on to coordinate agents’ work – and changeBasePrice, the JaCa-Web web site9, where the interested reader can changeKeywords to change the value of the base price find also the address of a running instance that can be used and the keywords describing the product, which are stored in a for tests. Here we just report a snippet of the ProductFinder keyword observable property; (ii) aggregate product informa- agents’ source code (Fig. 5), with in evidence (i) the plans tion found by ProductFinders – in particular addProducts, used by the agent to react to changes to the search state removeProducts, clearAllProducts to respectively property perceived from the ProductDirectory artifact - adding add and remove a product, and remove all products found so and removing a new search goal, and (ii) the plan used far. Besides searchState and keywords, the artifact has to achieve that goal, first getting the product list by means further observable properties, bestProduct, to store and of the requestProducts operation and then updating the make it observable the best product found so far.
Finally, each ProductFinders periodically interact with a 9http://jacaweb.sourceforge.net ProductDirectory accordingly by adding new products and removing products no more available. It is worth noting the use of the keywords belief – related to the keywords observable property of the ProductDirectory artifact – in the context condition of the plan to automatically retrieve and exploit updated information about the product to search.
To conclude, we believe that agent-oriented programming – including multi-agent programming – would provide a suitable level of abstraction for tackling the development of complex software applications, extending traditional programming paradigms such as the Object-Oriented to deal with aspects such as concurrency, reactiveness, asynchronous interaction managements, dynamism and so on. In this paper, in particular, we discussed the advantages of applying such an approach to the development of Web 2.0 advanced applications, exploiting the JaCa integrated platform.
works and bridges have been developed to exploit agent
technologies for the development of Web applications. Main
examples are the Jadex Webbridge [
All these approaches explore the use of agent technologies on the server side of Web Applications, while in our work we focus on the client side, which is what characterises Web 2.0 applications. So – roughly speaking – our agents are running not on a Web server, but inside the Web browser, so in a fully decentralized fashion. Indeed, these two views can be combined together so as to frame an agent-based way to conceive next generation Web applications, with agents running on both the client and server side.
interoperable computational entities already sets the stage for
a possible evolution of Web 2.0 applications into Semantic
Web applications [