Agent Building and Learning Environment

## Readme

### Version 2.3 July 14, 2004

ABLE 2.3 requires Eclipse 3.0 and JDK1.4, includes new Eclipse plugin administration console for distributed agent platform, updated Eclipse rule and agent editors, new PetriNet agent, and updated example project.

Topics are:

> Welcome
> Release Contents
> Requirements
> Installation and Running
> Known Problems and Limitations
> Support
> Change History
> Acknowledgements

### Welcome to the Agent Building and Learning Environment

The Agent Building and Learning Environment (ABLE) is a Java framework, component library, and productivity toolkit for building intelligent agents utilizing machine learning and reasoning. The ABLE research project is provided by the IBM T.J. Watson Research Center. ABLE has been named one of IBM's core technologies for Autonomic Computing.

The ABLE framework provides a set of Java interfaces and base classes used to build a library of JavaBeans called AbleBeans. The library includes AbleBeans for reading and writing text and database data, for data transformation and scaling, for rule-based inferencing using Boolean and fuzzy logic, and for machine learning techniques such as neural networks, Bayesian classifiers, and decision trees. Developers can extend the provided AbleBeans or implement their own custom algorithms.

Rulesets created using the ABLE Rule Language can use any combination of rule engines from simple procedural if/then/else scripting and decision trees, to inference engines that do backward or forward chaining, to inference engines that also use predicate logic, fuzzy logic, and pattern matching within working memory. The newest engines are specific to planning and policy applications. Java objects can be created and manipulated using Able rules. An Eclipse plugin provides rule editing and debug capability.

Core beans may be combined to create function-specific JavaBeans called AbleAgents. Agents are provided for classification, clustering, prediction, and genetic search. Developers can implement their own AbleBeans and AbleAgents and plug them into Able's Agent Editor. Graphical and text inspectors are provided in the Agent Editor so developers can view bean inputs, properties, and outputs as machine learning progresses or as values change in response to methods invoked in the interactive development environment.

Application-level agents can be constructed from AbleBean and AbleAgent components using the Able Agent Editor or a commercial bean builder environment. AbleBeans can be called directly from applications or run autonomously on their own thread. Events can be used to pass data or invoke methods, and can be processed in a synchronous or asynchronous manner.

#### The distributed AbleBeans and AbleAgents are:

Data beans |
AbleImport | reads data from flat text files
AbleDBImport | reads data from SQL databases
AbleFilter | filters, transforms, and scales data using translate template specifications
AbleExport | writes data to flat text files
AbleDBExport | writes data to SQL databases
AbleTimeSeriesFilter | collects periods of data for use in predicting future values
Learning beans |
Back Propagation | implements enhanced back propagation algorithm used for classification and prediction
Decision tree | creates a decision tree for classification
Naive Bayes | learns a probabalistic model for classification
Radial Basis Function | uses radial basis functions to adjust weights in a single hidden layer neural network for prediction
Self-Organizing Map | clusters data using Gaussian neighborhood function
Temporal Difference Learning | uses reinforcement learning for time series forecasting; gradient descent is used to adjust network weights
k Nearest Neighbors | classifies patterns according to nearest neighborhood calculation
Rules beans | Inferencing engines include: Backward chaining Decision tree Forward chaining Forward chaining with working memory Forward chaining with working memory and Rete'-based pattern matching Fuzzy logic Planning Policy Predicate logic Script
Agents |
Genetic search | manipulates a population of genetic objects which may include AbleBeans
Neural classifier | uses back propagation to classify data
Neural clustering | uses self-organizing maps to segment data
Neural prediction | uses back propagation to build regression models
Rule | contains a ruleset whose ruleblocks are processed when the agent's corresponding methods are executed.
Script | runs rulesets you name when its init, process, and timer methods are called.
JavaScript | runs JavaScripts you name when its init, process, or timer methods are called.
RemoteAgent | agent which can wrapper any AbleBean for remote access
Autotune | includes an AutotuneAgent, Neural2WayLoadBalanceController, BasicNeuralAutotuneController, and Fuzzy2WayLoadBalanceController
Conversation | includes an AblePlatformConversationAgent, and AutoConversationSetup and DefaultDecisionMaker beans
PetriNet | used for state machines, workflow, and simulations; includes the agent itself and place beans to contain tokens, and transition beans to permit the movement of tokens from place to place.

### Release Contents

ABLE 2.3 requires Eclipse 3.0 and JDK1.4, includes new Eclipse plugin administration console for distributed agent platform, updated Eclipse rule and agent editors, new PetriNet agent, and updated example project.

1. Prerequisite changes: ABLE core requires JDK 1.4, and Eclipse plugins require Eclipse 3.0.
2. The new ABLE Platform Console connects to a running ABLE distributed agent platform, allowing you to create, control, and monitor agents running within that platform.
3. The ARL rule editor Eclipse plugin can now set or remove breakpoints on rules and on actions in body of rules.
4. The Agent editor for Eclipse produces .agent, .ser, and .env files - relationship to swing editor output?; saves and restores inspectors.
5. The new PetriNet agent can be used for state machines, workflow, and simulations; beans for places and transitions are included.
6. The Eclipse example project now creates a plugin project in order to simplify installation.
7. New static methods Able.sendMail can be used to send email using the SmtpRelay property in able.preferences.
8. Eclipse documentation was previously a separately downloadable feature. It has now been merged with binary so there is only one file to download and unzip, and only one feature in that zip.

See the Change History for previous release content.

### Requirements

Platform: JDK 1.4 or later. You can obtain JDK's built by Sun at http://java.sun.com/j2se/ and by IBM at http://www.ibm.com/java/jdk/download/index.html. Follow the installation instructions provided at those sites.

The agent editor and ruleset editor plugins for Eclipse require Eclipse 3.0.

Computer: Any Java2-supported system.

### Installation & Running

Please read the License Agreement and agree to the terms and conditions before installing this software.

#### ABLE Swing Installation Procedures

1. Download executables with the AbleAll_2.3.0.zip file or the AbleAll_2.3.0.tar.gz file as appropriate.
2. Unzip (or untar) the file(s) to a specified drive. The .../able_2.3.0 directory tree will be created and populated.
3. Script files to start the Able Agent Editor are in the .../able_2.3.0/bin directory.
4. To reduce download times, help and documentation is provided in a separate file, docs, which must be downloaded separately. Unzip or untar the doc.zip file into the .../able_2.3.0 directory. This will create a directory named .../able_2.3.0/references.
5. The documentation root is .../able_2.3.0/index.html file. If you have not downloaded the separate documentation, some links will not be available.

#### Running the Swing Able Agent Editor

1. Change to the .../able_2.3.0_/bin directory.
2. Run the runnit script appropriate for your operating system.

#### Running the Swing Able Agent Editor with Distributed Agents

1. Follow instructions in the Platform Guide to set up your ableplatform.preferences file and for more details.
2. Change to the .../able_2.3.0_/bin directory.
3. Run the startPlatform script appropriate for your system.
4. In a new command interpreter window, change to the .../able_2.3.0/bin directory.
5. Run the runPlatform script appropriate for your operating system.

#### ABLE Eclipse Installation Procedures

1. Download the com.ibm.able_2.3.0.bin.dist.zip file.
2. Remove any previous versions by deleting any folders starting with com.ibm.able from your eclipse/features and eclipse/plugins directories.
3. Unzip the distribution in your eclipse subdirectory. This will create an entry in the eclipse/features directory as well as in the eclipse/plugins directory for the core, platform, extensions, agent and ruleset editor, bean customizers, documentation, and examples.
4. Restart your Eclipse platform.

### Known Problems and Limitations

This is an alpha level release and not all function and documentation is complete. General limitations:

1. Serialized inspectors which used JDK 1.3 Swing components will not be reserialized due to JDK 1.4 Swing limitations.
2. JDK1.5 has both similar and additional issues with inspectors. Recommend using JDK 1.4 at this time.
3. Ruleset limitations:
   1. Due to limitations of the antlr-based parser:
      - Ruleset identifiers cannot begin with an underscore (_) character.
      - Numeric values cannot begin with a period ('.'); use 0.5 instead of .5.
      - The value 0xFF does not parse.
   2. Calling non-static methods in a static way is not detected until runtime; ideally "Aclass.aNonStaticMethod()" would produce a parse error stating "Method <aNonStaticMethod> in class <Aclass> is not static."
   3. Sometimes intermediate assignments are needed. If you find a parse error for instance when assigning the result of a method to a variable of a specific class, try assigning the result to a java.lang.Object, and then assign that java.lang.Object to the class-specific variable in a second rule. We would like to remove this limitation so let us know if you see this situation.
4. The ARL Editor for Eclipse supports text edit of ARL files with outline view, compiles when saving, and shows errors with markers and task entries. It can run or debug rulesets by configuring a launch with the project and ruleset name. Any imported classes must be in the project classpath. Debug supports variables view (including working memory variable wm), setting and clearing breakpoints on rules, step into, over, and return at rule level in specific engines. A wizard to create ARL source is available at New->ABLE->AbleRuleset. Known limitations and bugs are:
   1. Launch shortcuts for run/debug do not work. You must create and configure a Launch to run/debug a ruleset, specifically the ruleset path and file.
   2. Breakpoints are set on the source ruleset. However, when stepping through a ruleset, the ruleset shown is the output ruleset. Breakpoints set in the output ruleset are not used.
   3. Breakpoints can be set on rules or actions of rules. A rule breakpoint is only triggered when that rule is selected to fire - breakpoints are not applied when evaluating antecedent or selector clauses.
   4. Breakpoints set on rules in the init ruleblock do not pause processing.
5. The ABLE Agent Editor for Eclipse can drag/drop beans and agents onto an agent. It provides a context menu from which you can open a Swing inspector on beans/agents, open Swing Customizer on beans/agents, run the container agents Step/Cycle/Run/Halt, import/export an agent/bean from or to a serialized file, initialize an agent, and set certain properties using Eclipse property sheet when bean/agent is selected. When an Agent is selected, the Step/Cycle/Run/Halt buttons on the toolbar are activated and work like in the Swing agent editor. A wizard to create an Agent is available at New->ABLE->Able Agent. Known limitations and bugs are:
   1. Launch shortcuts for run/debug do not work. You must create and configure a Launch to run/debug an agent.
   2. There is no support for adding your own agents and beans to the palette.
   3. Icons representing generated beans may overlap and can be moved manually if desired for visibility.
   4. When Inspectors are open and you regenerate the beans in an agent, the old Inspectors are not automatically shut down.

See the FAQ if you encounter problems installing or using ABLE. The later questions are designed to assist you with troubleshooting.

### Support

We are interested in any feedback you are willing to provide, whether it is problems you encounter while using this software or suggestions for future improvements. Please send comments and questions to ableinfo@us.ibm.com or post them in the Able discussion forum at http://www.alphaworks.ibm.com/tech/able. Internal IBM users may post or subscribe to the software.able forum at http://w3.ibm.com/forums/forumlookup/forums.software.able or the newsgroup news://forums.ibm.com/forums.software.able.

### Change History

Able release | Posted at alphaWorks | Build timestamp | Content highlights
1.0a | 05/04/2000 | 04/28/2000 | Initial release to alphaWorks.
1.1b | 09/28/2000 | 09/28/2000 | New NaiveBayes, RadialBasisFunctionNet and TemporalDifferenceLearning beans. Neural network auto-training. Java2 required.
1.2a | 12/07/2000 | 12/06/2000 | Inference engines redesigned; support for user libraries and Java object scripting, new DecisionTree bean.
1.3a | 10/24/2001 | 10/17/2001 | ABLE Rule Language includes new rule types, new inference engines (Rete', Prolog), temporal reasoning, and a rule debugging framework; new Script and JavaScript agents and a database Import bean; tracing and logging support.
1.3b | 01/22/2002 | 01/11/2002 | Consistent rule validation in all inferencing methods, String function library added for rule writers, transaction event support.
1.3c | 03/29/2002 | 3/27/2002 | Able Rule Language modified to be more Java-like. Old form converted automatically and supported in this release.
1.4.0 | 10/14/2002 | 10/16/2002 | Major enhancements to Able Rule Language and AbleRuleSet bean. New features include FIPA-compliant distributed agent platform, conversational agents, Autotune feedback control agents, and Eclipse rule editor plugin.
1.5.0 | 3/15/2003 | 3/17/2003 | Enhancements to Able Rule Language, AbleRuleSet bean and agent platform. Includes new rule template support, DBExport bean, RuleAgent bean, and pluggable rule engines, performance tuning, updated docs, bug fixes.
2.0 | 7/7/2003 | 7/2/2003 | ABLE 2.0, a core IBM Autonomic Computing technology, has enhanced rules function, new Eclipse-based tooling, and major enhancements to the agent platform, including life cycle services, security, and persistence. Updated Javadocs and bug fixes.
2.0.1 | 10/21/2003 | 10/14/2003 | ABLE 2.0.1 has a new planning engine, updated Eclipse tooling including enhanced text rule editor and debugger, GEF 2.1-based agent editor, Eclipse-based help, updates to the agent platform and minor bug fixes.
2.1 | 4/1/2004 | 3/24/2004 | ABLE 2.1 has chained method/field expression support in its rule language, enhanced planning engine with HTN support, new policy and decision tree rule engines, an example Eclipse project, performance tuning and bug fixes.
2.2 | 12/17/2004 | 2/1/2005 | ABLE 2.2 includes enhanced planning engines, rule language enhancements to scale rule/policy applications, switch statement, nested if/then/else support, new rule XML representation, improved async event/timer logic, enhanced agent platform services, and miscellaneous fixes.

#### Release 2.2 December 17, 2004

ABLE 2.2 includes enhanced planning engines, rule language enhancements to scale rule/policy applications, switch statement, nested if/then/else support, new rule XML representation, improved async event/timer logic, enhanced agent platform services, and miscellaneous fixes.

1. Major changes to the planning engine include much better performance in the classical planner due to a series of internal changes and a new feature to detect unsolvable problems up front.
2. Rulesets now can include other rulesets and/or extend rulesets so that applications can share both rules and rulesets.
3. The Able Rule Language (ARL) now includes a switch statement, and allows nesting of conditional rules.
4. Ruleblocks can now have local variables and parameters for ruleblocks are supported.
5. The XML representation of rules has been improved and simplifed; the file extension is now ".arml" for Able Rule Markup Language.
6. The agent platform package has two new services, Agent Logging Service & Platform Support Service.
7. The AblePlatformDefaultAgent supports agent capabilities, situations, and logging.
8. The assert method in the AbleWorkingMemory interface is now assertFact rather than assert since in JDK 1.4 assert is a java keyword. Either assert or assertFact will work in ARL but it is recommended that you use assertFact.
9. When no domain actions class is specified, the plan retrieved from the planning engine is now an array of Strings for each plan step.
10. A bug was fixed in the AbleEventQueue that prevented timer events and asynchronous events from being used at the same time, and this resulted in some behavior changes. See AbleEventQueue's java doc for details.

#### Release 2.1 April 1, 2004

ABLE 2.1 has chained method/field expression support in its rule language, enhanced planning engine with HTN support, new policy and decision tree rule engines, an example Eclipse project, performance tuning and bug fixes.

1. New policy and decision tree inferencing engines.
2. Planning engine enhanced to support Hierarchical Task Network (HTN).
3. Able Rule Language supports chained method/field expressions.
4. Example project for Eclipse provided including example ARL rulesets and Java source.
5. Performance improvements for rule processing, particularly Rete' pattern matching.
6. Memory management improvements in the rules package.

#### Release 2.0.1 October 13, 2003

ABLE 2.0.1, a core IBM Autonomic Computing technology, has a new planning engine, updated Eclipse tooling including enhanced text rule editor and debugger, GEF 2.1-based agent editor, Eclipse-based help, updates to the agent platform and minor bug fixes.

1. A new inferencing engine for planning is provided.
2. The Able Rule Editor for Eclipse now includes a launcher which uses project classpath and supports debugging modelled after JDT debug. Prior perspectives and views are obsolete.
3. The Able Agent Editor for Eclipse has been enhanced.
4. Eclipse tooling, rule editor and agent editor, are now packaged as an ABLE feature.
5. A separate documentation plugin download provides help and documentation in the Eclipse help contents.

#### Release 2.0 June 30, 2003

ABLE 2.0, a core IBM Autonomic Computing technology, has enhanced rules function, new Eclipse-based tooling, and major enhancements to the agent platform, including life cycle services, security, and persistence. Updated Javadocs and bug fixes.

1. The Able Rule Language (ARL) updates include:
   1. Added getControlParameter() AbleRuleSet methods.
   2. Changed syntax on Categorical and Discrete variables to use standard Java object syntax.
   3. Removed AbleBeanLib, AbleCalendarLib, AbleMathLib, AbleStringLib, and AbleUtilLib from driver and moved selected methods into the ARL.java built-in class.
   4. Added a number of new ISO Prolog compatible built-in predicates for use by the Predicate inference engine.
   5. Note that these changes mean that agents containing results are not reserializable from release 1.5.0.
   6. New APIs available in the AbleRuleset to reset bound variables, specifically for repetitive calls using backward chaining inferencing.
2. Enhancements to the com.ibm.able.platform package include new life cycle services support, new support for secure transactions, and database persistance.
3. Javadoc has been reviewed and updated, specifically for the com.ibm.able and com.ibm.able.platform packages.

#### Release 1.5 March 15, 2003

Enhancements to Able Rule Language, AbleRuleSet bean and agent platform. Includes new rule template support, DBExport bean, RuleAgent bean, and pluggable rule engines, performance tuning, updated docs, bug fixes.

1. The Able Rule Language (ARL) has undergone some syntax changes, libraries have been eliminated where methods can now be called directly, and built-in user-defined functions have been minimized to improve performance. New functions include templates, pluggable inference engines, rule priorities now support variables, and new agent AbleRuleAgent.
2. Tracing in the AbleRuleSet was found to be impacting performance so a new method of gating trace statements was designed and applied.
3. Performance improvements and bug fixes in the PatternMatchRete inferencing engine completed.
4. Redesigned which beans are remoteable, adding a new AbleRemoteAgent and additional remote interfaces.
5. Improved formatting of ruleset parsing exceptions.
6. AbleDefaultAgent moved from com.ibm.able.agents package to com.ibm.able. This unfortunately breaks most serialized agents.
7. The rules package is moved from com.ibm.able.beans.rules to com.ibm.able.rules.
8. Messages used for tracing while a ruleset is inferencing moved externally to a message bundle.
9. The AbleBean interface included more methods than were understandable. Intermediate interfaces have been provided for AbleDataBufferManager, AbleEventListenerManager, AbleEventQueueManager, AblePropertyChangeManager, and AbleSerializable. AbleBean extends each of these intermediate interfaces which were added largely for documentation.
10. Packaging has been revised to eliminate redundancy between jars, including eliminating the ableall.jar, placing the rules package in its own jar, and creating a new ablex.jar for experimental, prototype, or deprecated beans. The ablejas.jar is renamed ableplatform.jar. A major goal was to reduce the size and number of able jars required to deploy agents.
11. Reduced reliance on JAS reference implementation, reflected in renaming of many components that included the acronym JAS to Platform. The command files run/startjas are now run/startplatform. Preferences stored in ablejas.preferences are renamed and significantly changed in ableplatform.preferences. See Platform Guide and example ableplatform.preferences.
12. Tips section added to documentation for the ARL editor plugin to the Eclipse tool com.ibm.able.ui includes tips for setting able.home in eclipse and for developing Java classes in conjunction with rulesets.
13. New bean for writing to SQL database AbleDBExport, and a new interface AbleDataSink for beans which write data.
14. Fixes to the Inspector scatterplot view.
15. Xerces version 3.2.3 has replaced the former 3.0.1 in the shipped xerces.jar.

#### Release 1.4.0 October 14, 2002

Major enhancements to Able Rule Language and AbleRuleSet bean. New features include FIPA-compliant distributed agent platform, conversational agents, Autotune feedback control agents, and Eclipse rule editor plugin.

1. The Able Rule Language (ARL) evolution to Java is complete. Examples of the new syntax are provided with a comparison to the 1.3b version.
   1. Java-like syntax -- ARL subset uses equivalent Java syntax, with ARL-specific additions.
   2. Arbitrary nesting of AND/OR/NOT expressions.
   3. Function nesting (e.g. Math.sin ( Math.tan (1.4) )).
   4. Arbitrary math expressions x = x + 1; and y = ( z * 4 ) / k.
   5. Data Types - add TimeStamp, TimePeriod, Integer, Double, Float.
   6. Inference method names (Forward2 is now PatternMatch, Forward3 is now PatternMatchRete).
   7. Add return parameter from ruleblock ... use returnFromRuleBlock() built-in function.
   8. Define simple inner classes in ARL: use JikesBT, front-end completed.
   9. RuleBlock supports inference method on each rule block.
   10. Dot notation on method invocation on object variables.
   11. Inference engine controls set using built-in function setControlParameter; are variables rather than constants.
   12. Added match() function to do queries against WM (need Selector data type); use find() findAll() in wm.
   13. Added named patterns (Expressions) and Selector (added as built-in type).
   14. Exception rule block handles exceptions from AbleRuleSet process().
   15. Added enabled/disabled flag to rules to allow rules to be turned on/off as necessary (like by date/time).
   16. Added start/stop Date/Time stamps to each rule (implemented IETF TimePeriods).
   17. Added array support for built-in and user-defined data types, including array initializer support in ruleblock.
   18. Remove AbleListVariable and AbleListLib - use java.util.Vector instead.
   19. Slash '/' as legal char in identifiers ... changed functions{ } to look for (ident '/' int ), remove '/' from identifier list.
   20. Built-in data types are implicit imports rather than keywords (treated similar to imported types).
   21. Allow variable definition with null value such as MyType var1 = null ; or MyType var1 ;
   22. Added comment field to AbleRuleSet, AbleRuleBlock, Rules, and Variable using JavaDoc style.
   23. Implemented do/while , and add for-loop rule.
   24. Added ARL.constants to com.ibm.able.beans.rules.ARL class.
   25. Added support for bitwise operators &, |, ^, ~ and modulo %.
2. A new package, com.ibm.able.jas, provides a distributed agent platform compliant with JSR87.
3. A new package, com.ibm.able.conversation, provides conversational beans, agents, and examples.
4. A new package, com.ibm.able.autotune, provides agents, beans, and metrics for generic adaptive control applications.
5. A plugin to the Eclipse tool, com.ibm.able.ui, is provided for editing Able RuleSets within the Eclipse and Websphere Studio Workbench development environments.
6. New beans and agents for classification are included using a k-nearest neighbors algorithm, and alternate algorithms for decision trees and naive Bayes.

#### Release 1.3c March 29, 2002

Able Rule Language modified to be more Java-like. Old form converted automatically and supported in this release.

1. The Able Rule Language (ARL) has been significantly modified to make it more Java-like. Rulesets are now written to files with an extension of .arl rather than .rs. The Ruleset Editor includes a conversion utility to convert the old form to the new.
2. A new method added to AbleWorkingMemoryLib, assertDataSource, allows elements in a text file or database to be converted into objects and added to working memory.
3. A new rule library, AbleUtilLib, provides limited access to objects and methods in the java.util package. Note that the next release will allow methods to be called directly on Java objects without such wrappers; hence limited function has been added.
4. New boolean logic methods bAnd, bOr, bXor, and bNot added to the AbleMathLib.
5. The following changes were made to the Rule Editor:
   - After an old ARL ruleset is parsed, the ruleset may be converted to the new ARL format. The option is under the Edit dropdown menu.
   - Additional templates added for while and do/until rules.
6. The following documentation changes were made:
   - Documentation for the new ARL syntax is only partially complete.
7. Significant fixes include:
   - Fixes to the AbleGeneticAgent related to the conversion from separate sensor and effector classes to the AbleUserDefinedFunction design.
   - AbleWorkingMemoryLib serialUID field added.
   - Updated to JLog 2.2.

#### Release 1.3b January 11, 2002

Consistent rule validation in all inferencing methods, String function library added for rule writers, transaction event support, inspector and exception enhancements, and fixes for predicate inferencing.

1. Each inferencing method now consistently validates rules and reports errors during parsing.
2. A new function library, AbleStringLib, provides string operations for rule writers.
3. The AbleBeanLib function library now includes methods to invoke platform-specific and generic commands.
4. New fields in AbleEvent for replyTo, replyWith, and transactionID. Support for send/respond transaction events.
5. New field in AbleException allows an exception to retain a reference to a bean, or contain a list of exceptions when processing a collection of beans. This enables an agent to identify failing beans and take action to recover.
6. The following changes were made to the Agent Editor:
   - Custom inspector views are preserved when an agent is serialized.
   - Inspector Data menu appropriately displays the data type inspected when an agent is reserialized.
   - The connection view is preserved in user preferences.
   - An 'all' connections view is available.
7. The following documentation changes were made:
   - A new chart illustrates the degree of support that each inferencing engine provides for specific Able Rule Language features.
   - JavaDoc for the AbleScriptAgent and AbleJavaScriptAgent.
8. Significant fixes include:
   - Fixes for predicate inferencing to the rulesets themselves to import the AblePredicateLib and to the inferencing engine itself to prevent a null pointer error.
   - Fix to the AbleNeuralClassifierAgent - test import did not contain data fields.
   - Fixes for the AbleJavaScriptAgent.
   - Dangling reference to an AbleDataSource in AbleDefaultAgent caused AbleDataImports to be serialized even though deleted.
   - AbleObject.notifyAbleEventListeners continues to notify listeners of events even if one listener throws an exception; all exceptions logged, collected and rethrown.

#### Release 1.3a October 17, 2001

This release includes major enhancements to the ABLE Rule Language including new rule types, new inference engines (Rete', Prolog), temporal reasoning, and a rule debugging framework; new Script and JavaScript agents and a database Import bean; tracing and logging support; AbleEditor and Inspector enhancements.

1. The com.ibm.able.beans.rules package has undergone extensive changes:
   - The binary and fuzzy rules objects and editors have been merged into a RuleSet object and a RuleSet Editor.
   - New inferencing methods provided for forward chaining with working memory; forward chaining with working memory and Rete'-based pattern matching; script; JavaScript; and predicate logic.
   - The period, or dot, character (.) is no longer a valid character in IDs. For example, if you have a variable named var.Test.1, you must change the name so that there are no dots in the name.
   - Variables may be declared as "static". Static variables are not reset on each process call to the ruleset.
   - There is a new variable type List, for maintaining lists of objects.
   - There is a new variable type, called User-defined type, that allows you to define variables of any type. This is accomplished in two steps:
     1. Use the new Types statement to assign a type to a Java class. For example, Types(hammer: "com.binford.tool.Hammer"). This equates the hammer variable type with the Java class com.binford.tool.Hammer.
     2. Define variables of the new type. For example, myHammer hammer("Claw"). Note that you can pass arguments to the constructor of a user-defined variable, as shown here.
   - You can access fields within a typed variable by using a new dot notation. For example, if the hammer class contains the fields "length" and "weight", you can access those fields by writing myHammer.length and myHammer.weight.
   - The following variables are built-in:
     1. this Refers to the ruleset itself.
     2. parent Refers to the object that contains the ruleset.
     3. functionList Refers to the set of imported functions.
     4. variableList Refers to the set of global variables.
     5. inputBuffer Refers to the ruleset's input buffer.
     6. outputBuffer Refers to the ruleset's output buffer.
     7. wm Refers to the ruleset's working memory, if any.
     8. null A null value.
   - The Import statement now requires double quotes (") around the package name. For example, Import("com.binford.tool.ToolLib").
   - The following libraries are considered built-in, and do not need to be explicitly imported: AbleBeanLib, AbleListLib, and AbleMathLib. Libraries that must be imported are: AbleCalendarLib, AbleDebugLib, AbleGUILib, AblePredicateLib, and AbleWorkingMemoryLib.
   - The following ruleset functions are available as built-in methods: getRuleSetName(), getVariable(), getNumInputVars(), getNumOutputVars(), getOutputVars(), setInferencingTraceActive(), isInferencingTraceActive(), trace(), and most importantly, invokeRuleBlock().
   - The Sensors and Effectors statements have been replaced with a single UserDefinedFunctions statement since there is really no need to distinguish between what was arbitrarily considered to be a sensor or an effector.
   - Multiple, named, rule blocks are allowed within a single ruleset. The previous, unnamed, rule block is considered to be the "Main" rule block. Two other rule blocks have reserved names: "Init" and "Idle". The init rule block, if present, is processed once, and only once. The idle rule block, if present, is processed each time the main, or unnamed, rule block quiesces. There may be other rule blocks with arbitrary names. These are never processed unless explicitly called from a rule that uses the new invokeRuleBlock() built-in function.
   - Assertions are now processed after input variables are set. To obtain the previous behavior, place all assertions in a rule block labelled "Init".
   - There is an additional rule syntax: When-Do, that is used with new forward chaining inferencing algorithms.
   - And more additional rule syntax: predicate logic rules, used with a new predicate logic inferencing algorithm.
   - Additional rule options statements Predicates and GoalPredicates.
   - The "=" operator is no longer valid in comparison clauses. Existing rulesets must be updated to use "==" instead. Assignment clauses continue to use "=" as before.
   - A debug console is provided to display progress and step through statements in a ruleset.
   - Error messages are more meaningful.
   - Additional rulebases and sample code are provided in the examples/rules directory.
2. New beans include:
   - A Database Import bean to obtain data from SQL databases.
   - A Time Series Filter bean, provided to collect a set of input records for the prediction agent's use in forecasting.
   - A Script Agent with rulesets to define its init, process, and timer actions.
   - A JavaScript Agent whose init, process, and timer actions call user-supplied JavaScripts.
3. Changes in the import data design and implementation include:
   - A new abstract class, AbleAbstractImport, allows data-specific information to be consolidated in extending beans while sharing Able behaviors such as randomized presentation of data and record blocking.
   - A new property, computeStatistics, for the text import and database import beans allows import beans that reference a subset of a data source to share the computed statistics and data dictionaries gathered from another data source. If an import is initialized with computeStatistics off, its statistics values are obtained from the first import bean in its parent container's processing list.
4. The Self-Organizing Map bean, AbleSelfOrganizingMap, includes properties for labelling cluster patterns.
5. Logging and tracing improvements include:
   - Addition of a static message logger for logging translated user-level messages. Message logging is sent to the console by default but may also be directed to file. Three levels of severity are provided with the desired severity stored in preferences. Error is the default.
   - Addition of a static trace logger for logging programmer-level trace statements for debugging. Tracing is off by default but three levels of detail are available.
   - Beans may have their own unique trace logger to trace their individual execution.
   - Updated to JLog 2.1.2. Any beans using the IEventType class needs to change to IRecordType.
6. The following changes were made to the Agent Editor:
   - Addition of a static message logger for logging translated user-level messages. Message logging is sent to the console by default but may also be directed to file. Three levels of severity are provided with the desired severity stored in preferences. Error is the default.
   - Loading beans in the Agent Editor has changed somewhat. There is a preference value, PlugInJarDirectory, and now a default value is provided as lib\plugin. Any beans in jar files located in this directory will be added to the Agent Editor palette. If a bean is found, but cannot be loaded because of a classpath dependancy, the name of the unloadable class will be logged if the logging level is warning or informational. You may have to change your logging level and either restart the editor or add the jar to the palette from the Tools menu to view the message. If you develop your own beans, it is suggested that your logging level be set to warning or your trace level to low.
   - The Agent Editor bean tree includes context menus.
   - The Agent Editor Windows menu pulldown now includes the Rule editor, and the object icon is included to aid in identifying the window.
   - Properties for the Agent Editor are now maintained in a separate file, ablegui.preferences. Both preferences files, including the runtime properties file able.preferences, are written to the directory where the able package is installed. Commented examples for both files are located in the examples directory.
7. The following documentation changes were made:
   - Additions to the Tutorial now describe the Rule Editor, and both forward chaining and fuzzy solutions for the mortgage underwriting example are included.
   - The root documentation index has added links to the tutorial, examples, rules documentation, and agent editor. These links have been removed from what was termed the User Reference which is now limited to a reference for beans and agents.
   - A bibliography of references has been added.
   - The Agent Editor help pulldown menu has been modified to mirror the root documentation index.
   - The inspectors chosen for the serialized examples have been configured for better demonstrations.
8. Significant fixes include:
   - Changes to the AbleDefaultAgent class to fix a problem that prevented an agent that extended AbleDefaultAgent from passing data via buffers when in run mode, which included the neural agents.
   - Serialized agents distributed as examples now use a platform and release independant means of storing file path information. Examples will work as distributed on AIX.
   - All beans have been examined for serialization issues. Future releases of Able will attempt to maintain compatibility with previously serialized files.
   - Some reflection-related issues were resolved which prevented the Agent Editor from functioning in JDK 1.4.

#### Release 1.2a December 7, 2000

A major redesign of inference engines adding support for user libraries and Java object scripting, new CommonRules and DecisionTree beans, bug fixes and other enhancements.

1. The com.ibm.able.beans.rules package has been extensively enhanced:
   - All the functionality of the com.ibm.able.beans.fuzzy package can now be found in the enhanced rules package. The fuzzy package is deprecated and will be removed in the next release.
   - All data, clause, and rule representations use the data model from the com.ibm.able.data package.
   - Boolean and fuzzy rulesets use common rules, parsers, and a common ruleset editor.
   - Multiple inference engines are provided to operate on rules: backward chaining, forward chaining, mixed chaining, and fuzzy logic.
   - Rulesets can import complete sensor and effector libraries, without having to individually name each sensor and effector.
   - Two built-in sensor/effector libraries are available: com.ibm.able.beans.rules.AbleMathLib, which provides almost all the methods of java.lang.Math to rule writers, and com.ibm.able.beans.rules.AbleBeanLib, which allows, from within rules, arbitrary Java objects to be created, methods invoked, and members accessed.
   - Rule writers can declare and use "object" variables, which can hold any data type.
   - Rule writers can use the built-in variables "this" and "parent" to pass to sensors and effectors, or use in other ways. "this" refers to the current ruleset, and "parent" is the ruleset's containing object, if there is one.
   - Input- and OutputBuffers are Object[] arrays instead of String[] arrays.
2. A new learning bean, AbleDecisionTree, was added for classification.
3. An AbleBean is provided to wrapper the CommonRules package available from IBM alphaWorks. CommonRules is a rule-based development system for eCommerce applications. After installing CommonRules, follow these instructions to unzip the AbleCommonRules bean.
4. JDK version 1.3 is recommended. Version 1.2.2 works with most Able functions but there are problems when using the new rule development environment.
5. The list of Filter Editor operators has been verified, and those implemented are: absolute value, acosine, add, asine, atangent, bit-and, bit-complement, bit-or, bit-xor, ceiling, cosine, discretize, divide, exponent, floor, log, max and min for one-of-n data, modulo, none, round, scale, sine, squareroot, square, table, tangent, threshold, translate, and truncate. Only those operators appropriate for a datatype display in the combobox. The Math class is used rather than StrictMath. Other operators could be implemented on request including hyperbolic trig functions, normalization, and base 10 log and exponential.
6. Example data definitions and files have been centralized in the examples\datafiles directory. Examples of serialized agents are located in appropriately named subdirectories under examples.
7. The Generate button on the AbleImport bean creates a convert and revert AbleFilterBean. The convert bean is attached to the import bean with a data connection.

#### Release 1.1b September 29, 2000

Major changes are:

1. JDK 1.1.8 is no longer supported; minimum JDK version is 1.2.2 with 1.3 recommended. Agents serialized with prior Able releases will not be compatible.
2. Rule languages support XML, which requires developers to add the xerces.jar file to the CLASSPATH setting.
3. The Able package is now split into code and documentation to make downloads faster.
4. Learning beans have been expanded with the addition of AbleNaiveBayes, AbleRadialBasisFunctionNet and AbleTemporalDifferenceLearning, and a new network graphic inspector.
5. Neural agents have autotrain capability, which switches modes between train and test as well switching data inputs between import beans.
6. A description of how to extend Able by providing your own beans is added to the user reference, and is available separately in PDF format. It refers to a new sample bean AbleFileWatcher provided for monitoring file changes.
7. The Able Data Model has been externalized in a new package com.ibm.able.data which will allow people to create new data types for inferencing/filtering/importing/exporting by extending the newly exposed data types. A description in PDF format is available.
8. A new definition file format is in use. The previous version is read and converted to the new format; the old design did not support multiple target outputs and did not share well between algorithms. Import beans can now read data in sequential or random order.
9. Miscellaneous Agent Editor enhancements and cleanup such as displaying bean state in the tree view, better handling of the icons on the canvas, able to define a directory from which to read user-provided jars, user-provided beans can specify their own tab on the editor bean palette, consistent look and feel throughout.
10. Removed examples/neural/* file from ableall.jar and ableexamples.jar which caused "class not found errors" with some JDK versions on Windows.
11. Workaround provided for JDK bug which prevented help browser from opening for JDK 1.2+ users.

#### Release 1.0a April 28, 2000

This is the first release of the ABLE package.

### Acknowledgements

The Agent Building and Learning Environment (ABLE) includes a parser for its Able Rule Language which is built using ANTLR, ANother Tool for Language Recognition, by Terence Parr.