Permalink
Find file
Fetching contributors…
Cannot retrieve contributors at this time
1328 lines (975 sloc) 40.1 KB

Jason release notes

version 2.2

version 2.1

(a built package is available at here)

  • this release just fixes some bugs

version 2.0

(a built package is available at here)

New features

  • modules and namespaces, see doc/tech/modules-namespaces.pdf

  • concurrent courses of actions within a single plan and advanced concurrent agent architectures, see doc/tech/concurrency.adoc

  • operator + works with plans and rules enclosed by { and }. For instance:

    ...
    + { p :- q & r };
    + { +b : p <- .print(ok) };
    ...
  • two new parameters in the .jason/user.properties file: kqmlPlansFile (the file with the plans that implement the KQML semantics) and kqmlReceivedFunctor (the functor used to produce new message events).

  • improved BUF with linear time (previous belief update function was quadratic)

  • source code has been moved to GitHub

  • started using gradle

New internal actions

  • .asserta: inserts a belief (or rule) in the begin of the belief base (can be used in prolog like rules)

  • .assertz: inserts a belief (or rule) in the end of the belief base (can be used in prolog like rules)

  • .relevant_rules: gets rules with a given head predicate

  • .lower_case and .upper_case for strings

  • .include: to load an asl source code at run time

Changes

  • AgArch act method has just one parameter (the action to be executed)

  • Java 1.7 is now used

  • JaCaMo is not an available infrastructure anymore, it has its own support to run MAS (the .jcm files)

Note
In Jason 2.0 the way to run the Jason IDE (based on jEdit) has changed. Rather than running an application (Jason.exe or Jason.app), the IDE is now run by double clicking the jedit/jedit.jar file or using the script files in the scripts folder.

New Tutorial on BDI (see doc/tutorials/hello-bdi/readme.adoc).

version 1.4.2

revision 1821 on SVN of SF

New features

  • REPL button on MASConsole and jason-repl.jar this feature allows the user to easily create and run agents while the MAS is running

version 1.4.1

revision 1792 on SVN

New features

version 1.4.0

revision 1759 on SVN

New features

  • implementation of tail recursion optimisation (TRO) for sub-goals. It can be turned off in the agent options, e.g.:

    agents: bob [tro=false];

Changes in the API

  • the method apply was removed and replaced by capply that clones and applies an unifier. Usually a code like

    Term t = ....
    t = t.clone();
    t.apply(u);
    should be replaced by
    Term t = .....
    t = t.capply(u);

NB. TRO and capply have improved the performance of some applications by up to 30%.

version 1.3.10b

revision 1750 on SVN

New features

  • (sub)goals can have a deadline, e.g.

    ...; !g(4)[hard_deadline(3000)]; ...
    if g(4) is not finished in 3 seconds, a failure event is produced.
  • the internal action .wait accepts a logical expression as argument, as in

    ...; .wait(b(X) & X > 10); ....
    The intention will be suspended until the agent believes b(X) with X > 10.
    Timeout and elapse time arguments can be used as previously.

New example:

version 1.3.9

revision 1721 on SVN

New features

  • new operators do add beliefs

    • "++" adds a belief with new focus (a new intention is created for the event produced by the addition)

    • "<" adds a belief at the beginning of the belief base (it is the same as the usual "" operator)

    • '+>" adds a belief at the end of the belief base

  • new special achievement goal events

    	+!jag_sleeping
    	+!jag_awaking

    that are created when the agent is going to sleep (has just become idle) and is becoming busy after sleeping, respectively. See demos/idle for an example of how to use this feature.

Note
The +!idle event is deprecated, you must use +!jag_sleeping instead! Note however that the +!jag_sleeping event is only generated when the agent starts an idle period, rather than being generated again at every reasoning cycle as with +!idle in previous releases.
  • new agent options:

    • [qcache=cycle]: it enables cache for queries on the same cycle, this could improve the agent performance in some applications.

    • [qprofiling=yes]: it generates some statistical data related to queries and is used to measure the performance of the qcache option

  • new general configuration parameter the define whether short names will be used for unnamed variables (those starting with _). Usually these vars may have quite long names. With this option enabled, the names will be kept short.

    This parameter is stored in the ~/.jason/user.properties file and can be changed either by editing the file or by running

    java -jar lib/jason.jar

NB: If in the user.properties file doesn’t exist the first time someone runs Jason, the file <jason install directory>/jason.properties will be used for initial user’s parameters.

  • new internal action .shuffle to shuffle the elements of lists

version 1.3.8

revision 1709 on SVN

New features

  • new internal action .empty to check lists

  • new method in Agent class (killAcc) to customise whether an agent accepts to be killed by another. (implemented only in Centralised infrastructure)

  • performance improvement for pool of threads

  • some kqmlPlans (tell/achieve) are bypassed if not customized by the user and not running in debug mode to improve performance

Bugs fixed - unique id of Intention wasn’t thread safe - indexedBB didn’t work on pool of threads

version 1.3.7

revision 1687 on SVN

New features

  • Initial implementation of Cyclic Terms

  • JaCaMo infrastructure (in beta)

Bugs fixed - the expression "1 - 1 - 1" is evaluated as 1 instead of -1

Other changes - support for SACI is removed, users that still use this platform should not upgrade to this version

version 1.3.6a

revision 1668 on SVN

New features

Bugs fixed - real numbers cannot be used in mas2j. - jade architecture not visible for other classes

version 1.3.6

revision 1659 on SVN

New features

  • several architectures can be defined for an agent (e.g. Cartago and FailurePerception)

Bugs fixed - .send ask with multiple receivers (in a variable ground to a list) doesn’t work - JADE infrastructure does not start the agents when used with jEdit plugin

version 1.3.5

revision 1656 on SVN

New features

  • new option to start up mind inspector for agents in non-debug mode.

  • new option to store mind samples in files (see debug section in FAQ for more information)

  • synchronous ask can have several receivers, the answers in this case is a list of all replies.

  • backtracking for .intend and .desire

Bugs fixed - cartago + jade does not work together - execution control deadlock

version 1.3.4

revision 1628 on SVN

New example

  • wumpus (inspired by Russel & Norvig book)

New features

  • creation of Ant scripts to help the running of JADE agents in a distributed configuration. See demos/distributed-jade for examples and the FAQ for more details.

  • possibility to customize the sniffer.properties of JADE

  • new function to compute standard deviation

  • new internal action setof

  • two new arguments in options to create agents in the .masj2 project: initial beliefs and goals. For example, in the project

    agents:
        bob   ag.asl [beliefs="b(20),rec(alice)",goals="g(1),g(2)"];
        alice ag.asl [beliefs="b(20),rec(bob)"];

both agents has the same source code. They differ in the initial beliefs and goals, which are defined in the projects instead of the agent’s code (ag.asl).

Bugs fixed

  • atomic plans that fail aren’t removed from the intention set.

  • succeed_goal doesn’t consider the case where several goals exist

  • backtrack on annotations doesn’t work with tail as in p[A|R]

Other changes

  • JADE is updated to 4.0.1

version 1.3.3

revision 1603 on SVN

New features

Creation of meta events for goal state change. Goal states are:

  • started: the goal has been started, e.g. !g in a plan

  • finished: the goal has been achieved, e.g. a plan for !g has finished

  • failed: the goal has failed

  • suspended: the goal has been suspended by .suspend, .wait, and action, …​

  • resumed: the goal has been resumed by .resume

The syntax for meta-events is

	^<goal type><goal literal>[state(<s>)]

where <goal type> is ! or ? and <s> is one of the above states

These events can than be handled by plans such as

	^!goto(X,Y)[state(S)] <- .print("goto state is ",S).

for the state suspended, another annotation contains the suspension reason (.wait, .suspend, …​)

	^!goto(X,Y)[state(S)[reason(R)]]
           <- .print("goto state is ",S," due to ",R).

see demos/meta-events for an example

version 1.3.2

revision 1586 on SVN

New features

  • backtracking on annotations (and literal’s annotations are sorted)

API changes

  • a new listener can be added in TS to be notified about changes in goals state (there are methods for created, suspended, resumed, finished, and failed goals) (see new class GoalListener)

Changes in the syntax

  • syntax of if/while/for statements are now like C/Java:

      if ( X > 3) {
           bla;
      } else {
           bla;
      }

";" is not required after "}" last formula in <then> can be followed by ";" keyword "else" is used

Bugs fixed

  • equals in ObjectTermImpl, as reported by Tim Cleaver in jason-bugs list

  • unnamed variables in some rules are not correctly replaced, as reported by Tim Cleaver in jason-bugs list

  • "E+1" is parsed as <exponent> instead of arithmetic expression

  • .relevant_plan with meta-variable plans as reported by Iain Wallance

version 1.3.1

revision 1553 on SVN

New demo - use of controllers to write a customised mind inspector

Internal actions - .random has an optional second parameter to setup backtrack

Bugs fixed - foreach when no solution exists causes failure - perception of atoms cause failure with SACI - initialisation of TimeSteppedEnvironment (bug: waits for a first action to start) - .succeed_goal does not work when applied to 'itself' (the intention succeed itself) - !Var does no work correctly

version 1.3

revision 1489 on SVN

New features - Plans and Triggers can be used as terms when enclosed by { and }

This feature is used in the following internal actions
.relevant_plans
    e.g.       .relevant_plans({ +!g(_) }, ListOfPlans)
    instead of .relevant_plans( "+!g(_)" , ListOfPlans)
.add_plan
.at
.wait
It may be used in send tellHow
.send(bob, tellHow, { +te : c <- a1 }).
It is also used by internal actions that 'return' plans, like
. plan_label
. relevant_plans
. current_intention
The advantages are that unification works
     e.g. .at("now +1 m", {+stop(ID)})
and syntax errors are detected at compilation time
The old style (with strings) continues to work.
More complex meta-programming is also possible:
.... !myadd( { .print(a); .print(b) } ) ....
     // pass the body of the plan as parameter to !myadd
+!myadd(Action) <-.add_plan( {+!g : c & b <- Action} ).
    // add a plan with a fixed event/context and body
    // given as a parameter
  • The performance is improved (+- 15%) by not cloning all the plan in the creation of intended means

Changes in the GUI - When closing the window of MAS Console, the application is also stopped.

Changes in communication - for messages sent to itself, the sender is 'self' now, and not the agent’s name as in previous releases

New internal actions - .puts: used for printing messages to the console (based on Ruby similar method). Developed by Felipe Meneguzzi. - .all_names: get the name of all agentes in the system. - .list_plans: print out the plans of agent’s plan library - .prefix, .suffix and .sublist: see comments in the API doc, as their implementation is currently generates slightly different results from their usual implementation in logic programming.

Changes in internal actions - .relevant_plans has a third argument that gets the labels of the plans - .create_agent and .kill_agent accept strings for the agents' name

New example - Blocks World

Bugs fixed - arithmetic expressions are considered as Literal, causing failures in unification - variable unified with atom cannot be added in BB, as in X = p; +X; - The third argument of .create_agent (list of options) can not be used. - Some concurrent execution of .wait and .drop_desire/intention does not work (the intention isn’t dropped) - send askHow with 4th argument blocks the intention - TimeSteepedEnvironment wait timeout when it is not required to wait

version 1.2

the 5th Anniversary Release

revision 1428 on SVN

New features - customised belief bases can be organised in a chain so that several functionalities can be composed. For more information see the demo/chain-bb see API doc of ChainBB and ChainBBAdapter

  • annotations in failure events. All failure events are now annotated with: error(<atom: error id>): the identification of the type of error, values used by Jason are: no_applicable: no applicable plan no_relevant: no relevant plan no_option: no option selected constraint_failed: constraint (i.e., a logic expression in the plan body) failed ia_failed: internal action returned false action_failed: environment action failed ask_failed: answer to an ask message failed (due to timeout) wrong_arguments: wrong arguments (type and/or number) passed to an internal action

       error_msg(<string>): the human readable message for the error
       code(<literal>): the part of the plan body where the failure occurred
       code_src(<string>): the file where the failure was
       code_line(<int>): the line in that file
    see demo/failure for an example
    see FAQ for more details
    see code of JasonException and TS for more information
  • the version of JADE is upgraded to 3.6

  • new base class for internal actions: ConcurrentInternalAction. This class can be used in place of DefaultInternalAction to create an IA that suspends the intention while it is being executed. For example, if DefaultInternalAction is used for an action that requires user input, the agent’s thread is blocked until an answer is given by the user. With ConcurrentInternalAction, only the intention using the IA is suspended. See demos/gui/gui1 and the API doc of this new class.

  • API doc uses UMLGraph to show relations between classes

New demo - java-object-terms: shows how variables may be unified to Java objects

New internal actions - .term2string: transforms a term into a string and vice-versa

New functions - .math.sum: sums a list of numbers - .math.average: returns the average of a list of numbers

API changes - the most significant change is in the Literal class, which is now abstract. To create a new literal, the previous method Literal.parseLiteral(…​.) still works, but new Literal(…​) has to be written as ASSyntax.createLiteral(…​.) the ASSyntax factory is the preferred approach for the creation of all types of terms. see API doc for further details. see discussion about the Literal class in the jason-developers list.

version 1.1.2

New features . (experimental) control of the execution in plan bodies with if, while, and for.

--- if ----
syntax:
if ( <logical formula> ) {
   <plan_body1>
[ } else { <plan_body2> ]
};
if <logical formula> holds, <plan_body1> is executed; otherwise,
<plan_body2> is executed.
e.g.: if (vl(X) & X > 10 & X < 20) { // where vl(X) is a belief
         .print("value > 10 and ");
         .print("value < 20")
      }
--- while ---
syntax:
while ( <logical formula> ) {
  <plan_body>
};
while <logical formula> holds, the <plan_body> is executed.
e.g.: while (vl(X) & X > 10) {
         -+vl(X+1)
      }
--- for ---
syntax:
for ( <logical formula> ) {
  <plan_body>
};
the <plan_body> is executed for all unifications of <logical formula>.
e.g.: for ( vl(X) ) {
        .print(X)
      };
      for ( .member(X,[a,b,c]) ) {
        .print(X)
      };
      for ( .range(I,1,10) ) {
         .print(I)    // print all values from 1 to 10
      };

New examples and demos: . demos/gui: two simple examples of how to make a GUI for individual agents . example/food-simulation: implementation of the scenario of simulation presented in http://jasss.soc.surrey.ac.uk/1/3/3.html

Bugs fixed: . BUF didn’t add annotation "source(percept)" in the perception deletion event . drop_desire did not remove desires in Circumstance.Event correctly when annotations are used . print worked like println . problem in =.. with atoms . problem in unification when unbound vars were used as arguments for rules (as identified by Stephen Cranefield)

version 1.1.1

New features . Terms can be body plans enclosed by "{ …​ }", as in the following example: test({ a1; !g; ?b(X); .print(X) }, 10)

Bugs fixed: . unification in return of ! and ? . use nested source annotations in communication . add "source(self)" in goals without source . correctly handle failure event caused by no relevant plans . timeout in .wait does not cause a runtime exception

version 1.1.0

New features . Performance improvements: in general, applications run 30% faster.

  1. Arithmetic functions: math.abs, math.max, …​ see doc/index.html and demo/function for more information

  2. Compiler warns about "singleton variables" in plans and rules (see plugin options to disable this feature). If you don’t use anonymous variables for logical variables whose contents will not be used, you may want to disable this feature.

  3. Terms can be logical expressions, as in the following example of .findall usage: .findall(X, (a(X) & X > 10), L)

  4. A list of goals can be sent with the "achieve" performative: .send(bob,achieve,[g1,g2,g3]) Note that each goal will become a separate intention of bob (if the message is accepted).

New example: . the Jason team used in the Agent Contest 2007 was added to the examples (folder gold-miners-II) . a GUI was added to the IPD example

New demo: . function: shows how to create new arithmetic functions.

New internal actions: . .reverse: reverse the order of lists and strings. . .union, .intersection and .difference of sets.

Bugs fixed: . the internal action .concat did not clone the lists properly . +?b(X) plans did not "return" the X value (bug in 1.0.1 only) . +!A used to catch events of the form +p . JDBC belief base did not work with null values . The MAS did not stop running when the "stop" button is pressed . The parser allowed mixing initial beliefs and goals with plans.

version 1.0.1

New features . a new entry is added in the mas2j project: aslSourcePath. This entry allows the developer to set where the runtime will search for AgentSpeak sources. E.g:

MAS ts {
  agents: a; b; c;
  aslSourcePath: "."; "src/asl"; "kk";
}
search the sources of agents a, b, and c in the paths "." (current path),
"src/asl", and "kk".
The default value is the project's directory.
  1. a preliminary version of an eclipse plugin (http://jasonplugin.wikidot.com)

New documentation . A getting started with Jason (see doc/index.html) . A mini-tutorial of interoperability between Jason and JADE (see doc/index.html)

New Demo . demo/sync-environment shows how to use the SteppedEnvironment. This environment has steps where each agent can perform only one action. When all agents have asked for the execution of an action, the actions are really executed, the perception is updated and the next step starts. The game-of-live example is also updated to use this kind of environment.

New internal actions . .suspend and .resume were moved from the example to the standard library. They can thus be used in any Jason application. . .delete to remove elements from lists or strings

Bugs fixed . clone example . use-only-jason-bdi example . the save files when opening a new project locks the jEdit . parser accepts initial goals and beliefs mixed with plans

version 1.0

Jason v 1.0 is used in the book 'Programming Multi-Agent Systems in AgentSpeak using Jason'

New feature . the centralised infrastructure can use a thread pool instead of one thread by agent. It is useful to run thousand of agents. See demo/big and examples/game-of-life for more details.

New Demo: . demo/clone shows how an agent can create a clone of itself.

version 0.9.7

New features: . First (experimental) version of JADE infrastructure (see FAQ for details) . Mind inspector has "bi-directional" debug and other improvements.

New example: . iterated-prisoners-dilemma

New Demos: . tell-rule: implements a new performative to tell rules like a :- b & c. to other agents.

  1. suspend-resume: implements two useful internal actions: one to suspend intentions and other to resume them.

Bugs fixed: . JavaWebStart of Jason applications in windows.

Changes: . new beliefs are added before the others in the belief base. . asynchronous acting in centralised infrastructure.

version 0.9.6

New features . test goal now can also have expressions, as in: +e : true ← …​ ?(a & b | d); …​ unlike simple test goals, the event +? will not be generated in case the test fails. As before, simple expressions that make no reference to the belief base don’t need to be in a test goal. . when an error occurs during the execution of a plan, the corresponding line in the source code is shown in the console. . the build.xml file created for each Jason application has two new tasks: "jar": creates an executable jar for the application "jnlp": creates a JavaWebStart application

New internal actions . min(<list>,<term>) gets the minimum value from the list. . max(<list>,<term>) gets the maximum value from the list. . .drop_event(D) removes the event +!D from the set of events

Changes in internal actions . .drop_desire(D) also removes the intentions related to +!D. . .drop_all_desires also removes all intentions.

Bugs fixed . broadcast did not work with SACI. . persistent BB in text files did not work . strong negation was not shown in the mind inspector . initial beliefs with negative arguments were not shown in the mind inspector

version 0.9.5

New features

  1. Users can define their own compiler directives. A directive can, for instance, change a set of plans to add a command in the end of all plans. See the new example "directives" for more information.

  2. Asynchronous ask in communication. When the internal action .send with an ask performative does not have the fourth argument, it does not suspend the intention. The answer is added to the sender’s belief base.

Changes in AgentSpeak semantics . "-b" in a plan removes "b[source(self)]" from the Belief Base and not b with its all annotations. However, the source(self) annotation is added only in case b has no annots. For -b[a], the "self" source is not added and only annotation "a" is removed.

Changes in internal actions . Many internal actions were renamed to follow a Prolog pattern. E.g., addPlan → add_plan, createAgent → create_agent. . .drop_desire does not produce events anymore, it just removes the event from the circumstance. . uses of .dropGoal(g,true) should be replaced by .succeed_goal(g). . uses of .dropGoal(g,false) should be replaced by .fail_goal(g). . new internal action .nth to select some term of a list.

Documentation . all internal actions were documented using javadoc (see doc/api).

Bugs fixed in 0.9.5b . The date in the application build.xml use latin characters. . The variable name in the KQML plans may conflict with users' variables. . .sort changes the first parameter. . the include directive can not be used before initial beliefs.

version 0.9.4

New features . The user can define class paths for Jason projects, see the Sniffer project file (Sniffer.mas2j) for an example.

Examples: . Add support form message sniffing in centralised infrastructure and improve the Sniffer example to use it (and also store all messages in a data base) . Improve the wandering capabilities in the Gold-Miners example.

Changes in the API . The TermImpl was renamed to Structure . The method that executes actions in the environment is not executeAction(String agName, Term act) anymore, but was changed to executeAction(String agName, Structure act) So you should change your environment method parameters to work with this version.

Bugs fixed: . unification of variable in annotations

version 0.9.3

New features . an event +!idle is generated when the agent has nothing to do (no other event, no intention, no message, …​.)

  1. Mind inspector can show the agent state in LaTeX

  2. New commands: asl2html and asl2tex

  3. We add some useful classes to develop grid based environments. There is a class to model (maintain the data) the scenario and another class to draw it in the screen. The examples CleaningRobots, DomesticRobot, and Gold-Miners use these classes. More information is available in these examples and in the API of package import jason.environment.grid

  4. goal patterns as proposed in DALT 2006 paper:

  5. Backtracking Declarative Goal

  6. Blind Commitment Goal

  7. Open-Minded Commitment

  8. Maintenance Goal

  9. Relativised Commitment Goal

  10. and others

New examples . Sniffer: shows how to get all messages sent by the agents. . ContractNetProtocol: shows how the CNP may be implemented with Jason

New internal action: . dropGoal(<goal>,[true|false]): the implementation of the .dropGoal as specified in DALT 2006 paper. All intentions with goal <goal> will be popped until the <goal> intended means (im). If the second parameter is true, the IM is considered successfully finished. Otherwise, the IM fails.

  1. member(<element>, <list>), verify whether <element> belong to the <list>. this internal action backtracks when there are more than one answer, as in .member(X, [4,1,6]) which has 3 results.

  2. planLabel(<plan>, <label>), gets the string of a plan based on its label (useful for tellHow). E.g.: @test +!g : true ← act. …​. ← .planLabel(P, test); .send(ag,tellHow,P).

  3. structure(X): verify whether X is a structure (see API doc)

  4. atom(X): verify whether X is an atom (see API doc)

Changes in the communication . performative ask is changed to askOne . the event for messages is now +!kqmlReceived (and not +!received) . send ask can have an 5th parameter: timeout. E.g. .send(ag,askOne,vl(X),Answer,3000) will wait the answer for 3 seconds. If ag will not respond, Answer will unify with "timeout".

Changes in the API

  1. The interface of internal actions changed. The execute method returns an Object, and not a boolean anymore, and the class may extends DefaultInternalAction (see the API for more information). For example:

    public class myIA extends DefaultInternalAction {
       public Object execute(TransitionSystem ts, Unifier un, Term[] args) throws Exception {
      ....
         return true;
    }  }

version 0.9.2

New internal action: . count(<bel>,<var>): count the number of beliefs that match <bel>.

New examples: . SimpleCommunication: briefly shows how to send and receive messages. . DomesticRobot: it is an improved version of the previous House robot.

Bugs fixes: . performative ask does not work properly.

version 0.9.1

New internal actions: . random(X): unifies X with a random value from 0 to 1. . date(YY,MM,DD): gets the current date . time(HH,MM,SS): gets the current time . var(X), string(X), number(X), ground(X), list(X): verify whether X is a var, string, number, ground, or list.

Bugs fixed: . Jason 0.9.1 correctly stops the running project (in windows). In Jason 0.9 some java.exe processes do not finish properly.

version 0.9

This version requires java 1.5.

New features: . Belief Base (BB) can be customised. There are two available customisations: one that stores the beliefs in a text file and another that stores them in a relational DB. This latter customisation can also be used the access any other relational DB (via JDBC). The AgentSpeak code remains the same regardless of the BB customisation. See the "persistentBelBase" example for more information.

Changes in the AgentSpeak syntax . there can be initial goals in the source code, e.g.: bel(a). !initgoal. +!initgoal : …​. ← …​.

  1. belief base can have simple (prolog-like) inferences rules, e.g.: a(10). a(20). b(20). c(X) :- a(X) & b(X).

  2. or (represented by "|") is allowed in plans' context, e.g.: +e : a | b ← …​. +e : a & not(b | c) ← …​. Disjunction is also possible in the inference rules in the belief base.

  3. 'true' context or plans can be omitted. e.g.: +e : c ← true. +e : true ← !g. +!e : true ← true. can be written as +e : c. +e ← !g. +!e.

  4. new operator "-+", which can appear in a plan body, adds a belief after removing (the first) existing occurrence of that belief in the belief base, e.g.: -+a(X+1) removes a(_) from and adds a(X+1) to the belief base.

  5. new plan annotation: "all_unifs". When a plan’s label has this annotation the list of applicable plans will include all possible unifications (the same plan can lead to more than one Option), e.g.: a(10). a(20). @l[all_unifs] !g : a(X) <- print(X). "!g" has two options, one where X=10 and another where X=20.

  6. the arithmetic operator % was renamed to "mod"

Changes in .mas2j file . the environment class can receive parameters from the .mas2j file. e.g. in a mas2j file: …​ environment: myenv(1,"a b c",vl) …​ the environment implementation will receive these parameters in the init method: public void init(String[] args) { …​ }

Changes in the API . the BRF method, in the "Agent" class, was renamed to BUF (Belief Update Function). A new BRF method was added for belief revision rather than update. While BUF is called to update the BB when percepts are obtained, BRF is called for `', `-', and `-' operators (those used in AS plans). Note that certain custmosations of BRF may require that BUF is customised to use BRF for the actual changes in the BB.

Other changes . the "src/templates" folders contains all sources used by the JasonIDE to create new files (e.g., when users request a new agent or a new project to be created).

  1. new internal action ".length(<string>|<list>, <size>)": gets the size of a list or string

  2. new internal action ".abolish(<literal>)": remove all ocurrences of a literal from BB

  3. Performatives "askOne" and "askIf" are new "ask".

  4. Events generated from received KQML messages are not "received(....)", but "!received(…​)".

version 0.8

New features . Jason is now a jEdit (www.jedit.org) plugin. . Jason was prepared for new infrastructures (Jade, MadKit, …​) To create a new infrastructure, you shoud add an infrastrucure Factory in .jason/user.properties file and implement some classes. See jason.infra.centralised and jason.infra.saci packages as examples. . AS syntax was changed to support include directive, e.g. in an AS file: …​. plans …​. { include("anotherfile.asl") } …​. more plans …​. . new internal action wait, e.g. in an AS file: a : true <- .wait(1000). // waits 1 second +a : true <- .wait("!x"). // waits an event . new internal action sort, e.g. in an AS file: …​. .sort([b,c,g,casa,f(10),[3,4],[3,1],f(4)],L); …​ L is [b,c,casa,f(4),f(10),g,[3,1],[3,4]]

Changes in .mas2j file . The user can inform its own parameters in the agent declaration, e.g.: …​. agents: ag1 [verbose=2,file="a.xml",value=45]; These extra parameters are stored in the Settings class and can be consulted in the programmer classes by getUserParameter method, for example, ts.getSettings().getUserParameter("file");

Changes in ASL syntax . the unnamed variable ("_") is added . annotations are an AS list, so it is possible constructions like p(t)[a,b,c] = p(t)[b|R] (R is [a,c]) . variables can have annotations, e.g. X[a,b,c] = p[a,b,c,d] (unifies and X is p) p[a,b] = X[a,b,c] (unifies and X is p) X[a,b] = p[a] (do not unify) p[a,b] = X[a] (do not unify) e.g in a plan +te : X[source(ag1)] ← do(X). . plans' trigger event can be a variable, e.g. +!X[source(S)] : not friend(S) ← .send(S, tell, no). . new operator =.. used to (de)construct literals, syntax: <literal> =.. <list> where <list> is [<functor>, <list of terms>, <list of annots>] e.g. p(t1,t2)[a1,a2] =.. L (L is [p,[t1,t2],[a1,a2]]) X =.. [p,[t1,t2],[a1,a2]] (X is p(t1,t2)[a1,a2]) . new operator "!!": sub-goal with new focus . new operator "div": integer division

Changes in the agent architecture customisation . In this version, the user extends AgArch class instead of Centralised or Saci architectures. Thus, the same architecture customisation can be used in both infrastructures.

Other changes . The Java logging API is used to output the execution. The default log configuration is in the src/logging.properties file. The user can copy this file to its project directory to customise the output format. . The internalAction removePlan use plan’s label as argument instead of plan’s strings. . Ant is used to run the MAS, for each project a build.xml file is created. The build template file is located in src/xml directory. If the project has a file called c-build.xml, the build.xml file is not created and this script is used instead.

version 0.7

New features . atomic execution of intention. When an intention is created from a plan with a label that has an 'atomic' annotation @label[atomic] +…​. : …​. ← …​. this intention has highest priority, no other intention will be selected until this one was finished. . breakpoint annotation in plans' label . editor syntax highlight for AS/MAS2J . online parsing on editing . number of cycles until perception (see manual) . new AS grammar that supports expressions, e.g. +b : true : X = 4; Y = X + 3 * X / 2; …​ . jar files in the application lib directory are automatically added in the classpath

Changes in the Environment programming . Each agent has its own perception list in version 0.7. In the application Environment class, the user can change these lists by calling . addPercept(P): add perception P in the perception of all agents; . addPercept(A,P): add perception P only in the agent A’s perception. . removePercept(P): …​ . removePercept(A,P): …​ The method getPercepts(A) returns the perceptions for agent A. See Environment javadoc API for more information.

  1. Perception is now a list of Literals, thus there is not anymore a positive and a negative list of Predicates.

    a code like
      getPercepts().add(Term.parse("p(a)"));
    should now be written as
      addPercept(Literal.parseLiteral("p(a)"));
    and a code like
      getNegativePercepts().add(Term.parse("p(a)"));
    should now be written as
      addPercept(Literal.parseLiteral("~p(a)"));

Changes in Internal Actions . Internal actions args are now terms and not Strings . Internal actions implements InternalAction interface . Each agent has its own IA objects — IA has a state for its agent

Other changes . auto-save before running . brf() was moved to Agent class (and architecture perceive returns a List of perceptions) . The log4j is used to output the execution. The default log configuration is in the src/log4j.configuration file. The user can copy this file to its project directory to customise the output format. See http://logging.apache.org/log4j/docs/ for more information. . environment is optional in mas2j . initial beliefs generate events like + operator.

version 0.6

New features . Two execution modes: async and sync (see doc/faq.html) . Debugging execution mode with "mind inspector" tool (works both for centralised and distributed agents)

Agent Communication . new implementation: all received messages create an event that is handled by standard AS plans (see bin/resources/kqmlPlans.asl file) . acceptTell/Trust functions are replaced by socAcc (see manual)

Changes to AS syntax . variables can be used where literals are expected, and a few other changes (see manual)

Changes to .mas2j file syntax . user can set a controller class (see grammar) and doc/faq . Environment.notifyEvents() was renamed to informAgsEnvironmentChanged() . default architecture is centralised, not Saci.

Changes in the API . the classes was reorganised into new packages. An User’s environment class needs the following imports: import jason.; import jason.asSyntax.; import jason.environment.*;

Other changes . the ulibs dir. is not used anymore. The user classes should be placed in his/her project directory (or in any directory in your CLASSPATH) . source annotation in predicates now have the form "[source(self)]" instead of "[self]" (similarly for perception and other agents as sources). . Saci is included in the distribuion

version 0.5

Changes at .mas2j file syntax . the user can use java packages for his/her classes (see examples/Simple)

Changes in agentSpeak syntax . the plan context can use infix relational operators (<, ⇐, >, >=, ==, \==, = (unify)) for example: +p(X,Y) : X >= Y ← !doSomeThing().

  1. the plan label must be prefixed by "@", e.g.: @label +trigger : true ← action1; action2.

Changes in the API . The jason packages was refactored. The user environment class imports likely will need to be rewritten to: import jason.asSyntax.; import jason.environment.;

  1. Some methods' name has changed:

  2. Term.parameter → Term.getTerm(i)

  3. Term.funcSymb → Term.getFunctor()

A new internal action, .broadcast(<ilforce>,<content>), was added.

version 0.4

The implementation of the user-defined environment class has been changed so as to allow users to specify customised perception for each individual agent.

Users who used old-style environment code such as:

public class marsEnv implements Environment { <code1> EnvironmentPerception envP = null; public void setEnvironmentPerception(EnvironmentPerception ep) { envP = ep; <code2> } <code3> }

should be changed to:

public class marsEnv extends Environment { <code1> public marsEnv() { <code2> } <code3> }

Briefly, the changes are as follows:

  1. The user’s environment class does not "implements Environment" anymore, but "extends Environment". (See API documentation for more information on this new class.)

  2. The method setEnvironmentPerception, where the environment initialisation was done, is replaced by the user environment constructor.

  3. To change the environment perception list use: getPercepts().remove(g1); instead of envP.getPercepts().remove(g1);

  4. To send specific perceptions for an individual agent, override the method getPercepts(agName); for example:

    public class marsEnv extends Environment {
      ...
      public List getPercepts(String agName) {
        if (agName.equals(...)) {
          List customPercepts = new LinkedList(super.getPercepts(agName));
          customPercepts.add(...);
          customPercepts.remove(...);
          return customPercepts;
        } else {
          return super.getPerceps(agName);
        }
      }
      ...
    }

The option "event=retrieve" was added. It makes the selectOption function be called even if there is not relevant plans.

version 0.3

Jason now has an IDE! This version of Jason also runs on MS Windows, if you must.

version 0.2

First public release.

Agent and AgentArchitecture classes are only required if the user needs to provide any customisation. The same environment code now works for Saci and Centralised.

version 0.1

The very first release of Jason!