-This has been ported to [this GitHub Gist](https://gist.github.com/ssardina/43d6e6f469921e5f692b37304f952d43)
-I can imagine there are other ways, but the way I made it work is by starting ECLIPSE from CLI with the variable exported already:
-If you find another way that ECLIPSE can gather the environment variables (without re-defining them one by one), let me know!
- * This will require first to install [Eclipse Dynamic Language Toolkit](https://projects.eclipse.org/projects/technology.dltk) (DLTK)
-IntelliJ cannot find the native library as it does not have `LD_LIBRARY_PATH` set correctly. See next question.
-Since it is painful to do it manually for each, one should first modify the Templates in "Run/Debug Configuration" to include the environment variables needed, for example `LD_PRELOAD`, `SWI_HOME_DIR`, and `LD_LIBRARY_PATH`.
-See this [post](https://intellij-support.jetbrains.com/hc/en-us/community/posts/205820189-How-to-set-default-environment-variables-)
- LD_LIBRARY_PATH=/usr/local/swipl-git/lib/swipl/lib/x86_64-linux/;SWI_HOME_DIR=/usr/local/swipl-git/lib/swipl/;LD_PRELOAD=libswipl.so
-* The [JPL documentation](https://jpl7.org/ReleaseNotes701.jsp) maintained by Paul Singleton, which has information on:
- * How to access Java from SWI Prolog code: The [Prolog API side of JPL](https://jpl7.org/PrologApiOverview.jsp)
- * HOw to access SWI Prolog from Java code: The [JAVA API side of JPL](https://jpl7.org/JavaApiOverview.jsp)
-* The types of queries available: [One-shot vs Iterative](https://github.com/ssardina-research/packages-jpl/wiki/Types-of-Queries:-One-shot-vs-Iterative)
-* How [multi-threading queries](https://github.com/ssardina-research/packages-jpl/wiki/Multi-Threaded-Queries) work under JPL.
-Please refer to [this entry](https://jpl7.org/DeploymentMacos) in the JPL documentation. (Note: that is from 2018; it may be fixed in newer versions)
-The reason why we have two library paths is that `lib/amd64/` is used for SWI 7.6.4, whereas `lib/x86_64-linux/` is used in 8.x.x versions.
-If, instead, you compiled the SWI from git sources and installed at `/usr/local/swipl-git`, you would do something like this:
- * Note current (Feb 2019) stable 8.0.x version has a problem with `libswipl.so` which makes JPL crash.
-Second, make sure you also have the **JPL package installed** in the system. This is an additional SWI module, it is not part of the core.
-* In **Windows**, it is easy as you can click to install JPL Java<-->SWI interface at installation time.
-* In **Linux**, you need to make sure `libjpl.so` and `jpl.jar` are somewhere! If you cannot find it, then you may need to install JPL.
- * In ARCH, you can generate it and install it using AUR package builder and `swi-prolog-git` package. Running the default PKG build file is enough to get JPL installed.
- * In MAC, we don't know how to make it work, as there is a glitch in one of the packages built for Mac... :-( [if you make it work, please let me know!]
-Finally, make sure your system is aware of both SWI and JPL by setting the appropiate env variables; see previous above.
-If you are using SARL, you may also refer to the instructions of the [SARL Prolog Capacity](https://bitbucket.org/ssardina-research/sarl-prolog-cap)
-To understand the environment library `LD_PRELOAD` check [this post](https://answers.ros.org/question/132411/unable-to-load-existing-owl-in-semantic-map-editor/) and [this one](https://blog.cryptomilk.org/2014/07/21/what-is-preloading/) about library preloading. Also, check [this](https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=690734) and [this](https://github.com/yuce/pyswip/issues/10) posts.
-Suppose your application need version `1.2.0.7.2` of artifact `sarl-agtcity-mw` from group id `org.bitbucket.ssardina-research`, but for some reason it cannot be gathered automatically from the cloud.
-Suppose you can get a hold of that dependency and obtain file `sarl-agtcity-mw.jar`. How do you install it in the repo? Here it is:
-Use the `-o` option for offline mode (e.g., `mvn -o clean package`): <https://www.packtpub.com/mapt/book/application_development/9781785286124/8/ch08lvl1sec81/working-in-offline-mode>
-Note you will still need to build the system online at least one, so that your system has the chance to get all the dependencies and store them under `~/.m2/`
-ECLPSE IDE seems to download all sources by default. To get the sources via CLI: `mvn dependency:sources`
-To state the POM to get all sources (and javadocs) of dependencies, check [this post](https://stackoverflow.com/questions/11361331/how-to-download-sources-for-a-jar-with-maven/11361413)
-The version of the [maven-compiler-plugin](https://maven.apache.org/plugins/maven-compiler-plugin/) should not be higher than `3.6.2` because the newer versions are using Java 1.9. And, it may cause problems during the compilation process.
-In reality, the [maven-compiler-plugin](https://maven.apache.org/plugins/maven-compiler-plugin/) is not mandatory at all in the POM because Maven is supposed to download one when needed for compilation.
-If you encounter strange error related to the use of an Java 9 class from the Google library, then you have to specify the maven-compiler-plugin in order to avoid it:
-Note that with version `3.1.0` this may take quite longer to compile, as all dependencies are packaged into a single, often large, JAR file.
-1. Have [JDK](https://www.oracle.com/technetwork/java/javase/downloads/jdk8-downloads-2133151.html) installed in your system (the Java development framework that comes with the compiler `javac`), not just the Java runtime environment JRE.
-2. Your `PATH` environemnt variable points to the directory where `java` and `javac` of the JDK where installed.
-3. Your `JAVA_HOME` points to the directory where the JDK was installed. Alternative, you will need to specify it in your `pom.xm`; see [here](http://roufid.com/no-compiler-is-provided-in-this-environment/) .
-To also remove all the print out of xml messages (e.g., the ones thrown by the Massim EIS for the Agents in City game):
-You can use the `MAVEN_OPTS` environmnt variable that will apply to all calls to Maven. For example:
-We use the [Maven Surefire Plugin](https://maven.apache.org/surefire/maven-surefire-plugin/) with [skipping by default](https://maven.apache.org/surefire/maven-surefire-plugin/examples/skipping-tests.html):
- <!-- Check this: https://maven.apache.org/surefire/maven-surefire-plugin/examples/skipping-tests.html -->
-Many of the answers here are almost verbatim explanations from SARL developer Stéphane Galland to my email enquires :-)
-Because it uses and builts on [XTEND](https://www.eclipse.org/xtend/documentation/203_xtend_expressions.html) framework.
-There could be many reasons and it may depend on the OS you are using. You need to have SWI-Prolog, JPL package, and the right environment variables set-up.
-Check [this question](https://bitbucket.org/snippets/ssardina/9er67X#markdown-header-my-javasarl-application-cannot-cannot-find-jpl)
-In 0.8.6 I was not successful. Check this post: <https://groups.google.com/forum/#!topic/sarl/E_mhpFWyBFo>
-See [here](http://www.sarl.io/docs/official/faq/SyntaxFAQ.html#1-12-how-do-i-control-the-log-level-of-the-logging-built-in-capacity).
-An event `AgentSpawned` will be emitted when an agent has been created and can be handled, say by a coordinator, to know the agent is now alive! Fo example:
-### Equality and identity comparison (`==`, `===`, `!=`, `!==`) in SARL and checking for null: same as Java ?
-Check [here](http://www.sarl.io/docs/official/faq/SyntaxFAQ.html#1-13-equality-and-identity-comparison-in-sarl-and-checking-for-null-same-as-java)
-* Java’s identity equals semantic is mapped to the tripple-equals operators `===` and `!==` in Xtend.
-Check xtend doc [here](https://www.eclipse.org/xtend/documentation/203_xtend_expressions.html#operators) for more details and SARL doc [here](http://www.sarl.io/docs/official/reference/general/Operators.html#3-comparison-operators).
-_**Note directly from SARL developer (Sept 2018)**_: SARL extends a part of [Xtend dialect](https://www.eclipse.org/xtend/index.html) in order to have benefits of several background features, such as the validation tests for type inheritance. Since Xtend and SARL uses [Xbase](https://www.eclipse.org/Xtext/documentation/305_xbase.html#xbase-expressions), a large part of the syntax is the same, especially within the blocks of code. (The rest of the syntax is defined in parallel. SARL was inspired by languages such as Scala, Python and Ruby. Several bugs or incoherencies of Xtend are fixed in SARL.
-There is still a bit of an issue inside the Xbase library; check this <https://github.com/sarl/sarl/issues/852#issuecomment-420842088>
-I have created an issue regarding null == value: Issue [#854](https://github.com/sarl/sarl/issues/854).
-According to the associated discussion within the Xbase group [#300](https://github.com/eclipse/xtext-extras/issues/300), the error message will be updated to push the developers to use `===`.
-Check [here](http://www.sarl.io/docs/official/faq/SyntaxFAQ.html#1-13-equality-and-identity-comparison-in-sarl-and-checking-for-null-same-as-java)
-**Not anymore an issue from 0.9**, has been resolved in [this issue](https://github.com/sarl/sarl/issues/859).
-The `Initialize` event is fired by the `registerBehavior` function. As you could see, this function does not provide a mean for passing initialization parameters.
-I think the ability to set the Initialize parameters when registering the behaviors is a missed feature from the SARL API.
-Note that because registration happens after the creation of the behavior module, the `initParam` will be available at time of `Initialize` execution.
-The owner of the skill is set when the skill is _attached_ to the agent. It means that the owner cannot be known within the constructor of the skill. The function `install` is invoked just after the skill is installed into the agent.
-Importantly, the initialization (via `Initialize` event) is not at creation time (constructor) but when the entity is attached to the agent.
-Within SARL developers' perspective, constructor statements should be redefined only if you want to set the value of a field that is final (`val` keyword), because it is mandatory regarding the semantic of the val keyword.
-Consequently, the best practice is that all initializations should be within the `on Initialize`. They should avoid constructor definition.
-Check [here](http://www.sarl.io/docs/official/faq/GeneralFAQ.html#3-4-how-can-the-warnings-given-by-the-sarl-compiler-be-avoided)
-Check [here](http://www.sarl.io/docs/official/faq/SyntaxFAQ.html#1-6-why-can-not-a-static-field-be-defined-in-an-agent-type-declaration-agent-skill-behavior)
-Check [here](http://www.sarl.io/docs/official/faq/GeneralFAQ.html#3-3-be-careful-on-the-emit-of-events-in-on-initialize)
-The function `fire(e)` retrieves all the "`on E`" and runs them in parallel, and there is a synchronization point after the running of all the "`on E`" if `E` is `Initialize` or `Destroy` (for forcing synchronous execution of "`on Initialize`" and "`on Destroy`"). At the end of the "`on Initialize`" (after synchronization point), all the buffered events are fired.
-Observe that if the event is fired from within the "`on Initialize`", the same algorithm is applied whatever the receiving agent.
-1. First, the spawn agent is created. This part is run _in the same thread_ as the caller of spawn, so the spawn call _blocks_.
-2. Once the spawn agent has been created, the initialization process runs within a _separated thread_ from the spawner agent. So, the call `spawn()` is now not locked anymore. Then, the created thread runs all the initialization process, including the synchronous execution of "`on Initialize`". Consequently, the "`on Initialize`" of the spawn agent will not block the spawn caller.
-From 0.9.0, there is an error if the SARL compiler has detected an assignment to a field of occurrence. Passing a field of occurrence to a function becomes a warning (See FAQ 0.9).
-http://www.sarl.io/docs/official/faq/SyntaxFAQ.html#1-10-why-is-an-error-or-a-warning-put-on-the-occurrence-keyword
### Equality and identity comparison (`==`, `===`, `!=`, `!==`) in SARL and checking for null: same as Java ?
+Check [here](http://www.sarl.io/docs/official/faq/SyntaxFAQ.html#1-13-equality-and-identity-comparison-in-sarl-and-checking-for-null-same-as-java)
-* `a != b` becomes `!Objects.equals(a,b)`. This is null-safe (part of Google API) and the code of the function is `a == b || (a != null && a.equals(b))`
-Because the SARL `==` operator is mapped to the Java `equals()` function, and the `===` and `!==` operators to the Java `==` and `!=` operators, it is better/safer, and a best practice, to use `===` and `!==` when one of the operands is of primitive type, e.g. `null`, number constants, primitive type variables. These operators are not replaced neither `operator_equals` nor `operator_notEquals` within the Java code.
-Ususally, the SARL compiler generates a warning to push you to use `===` in place of `==`. But with `null == value`, an ambiguous call error occurs before the warning is generated.
* Java’s identity equals semantic is mapped to the tripple-equals operators `===` and `!==` in Xtend.
-Java comes with a `Pair<A,B>` class to build an object for storing two values, nicknamed "key" and "value", but they have no meaning as key/value. It comes useful when a method has to return two values instead of just one. For example, the following function returns the next floor and direction that an elevator has to serve:
-As of Java 8, and as part of JavaFX, Java provides this `Pair<A,B>` class; check [here](https://www.geeksforgeeks.org/pair-class-in-java/) and [here](https://docs.oracle.com/javase/8/javafx/api/javafx/util/Pair.html).
-Note `Pairs` are different from `Map`, which can be seen as a collection of `Pairs` and with a proper key/value semantics.
-There exist more advanced implementations of `Pair`, for example from Apache. See [here](https://commons.apache.org/proper/commons-lang/apidocs/org/apache/commons/lang3/tuple/package-summary.html), [here](https://www.baeldung.com/java-pairs) and [here](https://gangmax.me/blog/2017/10/10/how-to-return-multiple-values-from-a-java-method/).
+Check [here](http://www.sarl.io/docs/official/faq/SyntaxFAQ.html#1-13-equality-and-identity-comparison-in-sarl-and-checking-for-null-same-as-java)
-SARL itself have compact syntax do deal with `Pair`, by using `a -> b` to create a `Pair` object `(a,b)`. There are also compact ways of manipulating `Collection` and `Maps`.
-Check SARL documentation on that [here](http://www.sarl.io/docs/official/reference/general/Operators.html#8-collection-operators).
+**Not anymore an issue from 0.9**, has been resolved in [this issue](https://github.com/sarl/sarl/issues/859).
The `Initialize` event is fired by the `registerBehavior` function. As you could see, this function does not provide a mean for passing initialization parameters.
I think the ability to set the Initialize parameters when registering the behaviors is a missed feature from the SARL API.
-The issue has been resolved in [this issue](https://github.com/sarl/sarl/issues/859)) and should be available in SARL 0.8.0+. For 0.7.x, you could use the following work around:
The owner of the skill is set when the skill is _attached_ to the agent. It means that the owner cannot be known within the constructor of the skill. The function `install` is invoked just after the skill is installed into the agent.
-You can use `@SupressWarning(..)` annotations in the entities you do not want to be warned. For example, a typical warning SARL will give is lack of synchronization for variables that can be accessed/edited concurrently:
- [WARNING] The field noToSpawn should be synchronized for avoiding value inconsistency due to parallel execution. [/home/ssardina/git/soft/agents/MASSIM/AgentsInCity/sarl-agtcity-base.git/src/main/sarl/au/edu/rmit/agtgrp/agtcity/sarl/agents/dummy/BootMultiSWIAgents.sarl:70]
-To get rid of such warnings, assuming you are aware of the potentiall issue and have planned for it, you can do:
-See the [Issue Codes](https://github.com/sarl/sarl/blob/master/main/coreplugins/io.sarl.lang/src/io/sarl/lang/validation/IssueCodes.java) for a complete list of what can be supressed.
+Check [here](http://www.sarl.io/docs/official/faq/GeneralFAQ.html#3-4-how-can-the-warnings-given-by-the-sarl-compiler-be-avoided)
-This is a design choice given that our entities are _agents_ and as such they should not "share" data unless done explicitly in an agent-oriented manner, for example via resources or communication channels.
-It is most probable that such static data can be seen as a _resource_ outside the skill or agent, and as such it should be managed outside it (for example within a class).
-This is the case for exampe if you want a synchronization (lock) among all instances of the skill: the lock should be managed by the resource itself, not by the skill.
+Check [here](http://www.sarl.io/docs/official/faq/SyntaxFAQ.html#1-6-why-can-not-a-static-field-be-defined-in-an-agent-type-declaration-agent-skill-behavior)
-The `on Initialize` behavior handler in agents is a bit special, as it is the code ran when an agent is born. As such, its execution is more "synchronous" than other on-behavior rules. In particular:
-1. Any event emitted within an `on Initialize`, will not be processed until that `on Initialize` code finishes. So, your agent initialization should _not_ depend (and wait) on any emited event being processed, as they won't!
-2. When spawning an agent in `on Initialize`, the spawn instructions will return only after the agent has been created. However, creation of the agent (i.e., of the corresponding object) doe snot include initialization of the agent via its `on Initialize` behaviors. Said so, the Java thread manager may process those initialization processes of the new agent before continuing with the execution of the spawnning agent (and this seems to be the case in many Linux boxes where the executor service of Java tends to have the same behavior during all the runs). If you change computer, it may be different (I have encountered this fact with my students). In the following example, the thread executor service of Java seems to give the priority to the "`on Initialize`" of agent 2 instead of continuing the run of the spawn function.
-Here it appears as the "`on Initialize`" behaviors have been run all before the execution resumes after the `spawn()` statement, but this is just one way and one should not rely on that behavior being guaranteed: once the spawned agent is created, the `spawn()` commands returns.
+Check [here](http://www.sarl.io/docs/official/faq/GeneralFAQ.html#3-3-be-careful-on-the-emit-of-events-in-on-initialize)
2. Once the spawn agent has been created, the initialization process runs within a _separated thread_ from the spawner agent. So, the call `spawn()` is now not locked anymore. Then, the created thread runs all the initialization process, including the synchronous execution of "`on Initialize`". Consequently, the "`on Initialize`" of the spawn agent will not block the spawn caller.
-From 0.9, there is an error if the SARL compiler has detected an assignment to a field of occurrence. Passing a field of occurrence to a function becomes a warning (See FAQ 0.9).
+From 0.9.0, there is an error if the SARL compiler has detected an assignment to a field of occurrence. Passing a field of occurrence to a function becomes a warning (See FAQ 0.9).
Check [this question](https://bitbucket.org/snippets/ssardina/9er67X#markdown-header-my-javasarl-application-cannot-cannot-find-jpl)
-We know that `occurrence` is static, so cannot be changed. However, in the above code, `occurrence.car`, is not being changed/assigned, but just used to refer to another entity where assignment is performed.
-However, SARL compiler will think that you are changing static element `occurrence` and complain with error. Instead do this:
-Presumably yes, but I was not yet successful (have not tried much though!). Check this post: <https://groups.google.com/forum/#!topic/sarl/E_mhpFWyBFo>
+In 0.8.6 I was not successful. Check this post: <https://groups.google.com/forum/#!topic/sarl/E_mhpFWyBFo>
-Use `setLogLevel()` as explained here: <http://www.sarl.io/docs/official/reference/bic/Logging.html>
-There used to be a bug in that `debug()` was passed to the system logging which if it was at level `INFO` it would not display it.
+See [here](http://www.sarl.io/docs/official/faq/SyntaxFAQ.html#1-12-how-do-i-control-the-log-level-of-the-logging-built-in-capacity).
2. Once the spawn agent has been created, the initialization process runs within a _separated thread_ from the spawner agent. So, the call `spawn()` is now not locked anymore. Then, the created thread runs all the initialization process, including the synchronous execution of "`on Initialize`". Consequently, the "`on Initialize`" of the spawn agent will not block the spawn caller.
+From 0.9, there is an error if the SARL compiler has detected an assignment to a field of occurrence. Passing a field of occurrence to a function becomes a warning (See FAQ 0.9).
+http://www.sarl.io/docs/official/faq/SyntaxFAQ.html#1-10-why-is-an-error-or-a-warning-put-on-the-occurrence-keyword
If you are using SARL, you may also refer to the instructions of the [SARL Prolog Capacity](https://bitbucket.org/ssardina-research/sarl-prolog-cap)
+To understand the environment library `LD_PRELOAD` check [this post](https://answers.ros.org/question/132411/unable-to-load-existing-owl-in-semantic-map-editor/) and [this one](https://blog.cryptomilk.org/2014/07/21/what-is-preloading/) about library preloading. Also, check [this](https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=690734) and [this](https://github.com/yuce/pyswip/issues/10) posts.
You can clone a snippet to your computer for local editing. Learn more.
