Before the advent of software engineering, the lack of memory space in computers and the absence of established programming methodologies led early programmers to use self-modification as a regular coding strategy. Although unavoidable and valuable for that class of software, solutions using self-modification proved inadequate while programs grew in size and complexity, and security and reliability became major requirements. Software engineering, in the 70’s, almost led to the vanishing of self-modifying software, whose occurrence was afterwards limited to small low-level machinelanguage programs with very special requirements. Nevertheless, recent research developed in this area, and the modern needs for powerful and effective ways to represent and handle complex phenomena in hightechnology computers are leading self-modification to be considered again as an implementation choice in several situations. Artificial intelligence strongly contributed for this scenario by developing and applying non-conventional approaches, e.g. heuristics, knowledge representation and handling, inference methods, evolving software/ hardware, genetic algorithms, neural networks, fuzzy systems, expert systems, machine learning, etc. In this publication, another alternative is proposed for developing Artificial Intelligence applications: the use of adaptive devices, a special class of abstractions whose practical application in the solution of current problems is called Adaptive Technology. The behavior of adaptive devices is defined by a dynamic set of rules. In this case, knowledge may be represented, stored and handled within that set of rules by adding and removing rules that represent the addition or elimination of the information they represent. Because of the explicit way adopted for representing and acquiring knowledge, adaptivity provides a very simple abstraction for the implementation of artificial learning mechanisms: knowledge may be comfortably gathered by inserting and removing rules, and handled by tracking the evolution of the set of rules and by interpreting the collected information as the representation of the knowledge encoded in the rule set.
This section summarizes the foundations of adaptivity and establishes a general formulation for adaptive rule-driven devices (Neto, 2001), non-adaptivity being the only restriction imposed to the subjacent device.
Some theoretical background is desirable for the study and research on adaptivity and Adaptive Technology: formal languages, grammars, automata, computation models, rule-driven abstractions and related subjects.
Nevertheless, either for programming purposes or for an initial contact with the theme, it may be unproblematic to catch the basics of adaptivity even having no prior expertise with computer-theoretical subjects.
In adaptive abstractions, adaptivity may be achieved by attaching adaptive actions to selected rules chosen from the rule set defining some subjacent non-adaptive device.
Adaptive actions enable adaptive devices to dynamically change their behavior without external help, by modifying their own set of defining rules whenever their subjacent rule is executed.
For practical reasons, up to two adaptive actions are allowed: one to be performed prior to the execution of its underlying rule, and the other, after it.
An adaptive device behaves just as it were piecewise non-adaptive: starting with the configuration of its initial underlying device, it iterates the following two steps, until reaching some well-defined final configuration:
While no adaptive action is executed, run the underlying device;
Modify the set of rules defining the device by executing an adaptive action.
Key Terms in this Chapter
Context-Dependency: Reinterpretation of terms, due to conditions occurring elsewhere in a sentence, e.g. agreement rules in English, type-checking in Pascal.
Subjacent (or Underlying) Device: Any device used as basis to formulate adaptive devices. The innermost of a multilevel subjacent device must be non-adaptive.
Adaptive Rule-Driven Device: Adaptive device whose behavior is defined by a dynamically changing set of rules, e.g. adaptive automata, adaptive grammars, etc.
Hierarchical (Multilevel) Adaptive Device: Stratified adaptive structures whose involving layer’s adaptive actions can modify both its own layer’s rules and its underlying layer’s adaptive functions.
Adaptive Computation Model: Turing-powerful abstraction that mimic the behavior of potentially self-modifying complex systems.
Adaptivity: Property exhibited by structures that dynamically and autonomously change their own behavior in response to input stimuli.
Adaptive Mechanism: Alteration discipline associated to an adaptive device’s rule set that change the behavior of its subjacent device by performing adaptive actions.
Adaptive Device: Structure with dynamic behavior, with some subjacent device and an adaptive mechanism.
Adaptive Functions and Adaptive Actions: Adaptive actions are calls to adaptive functions, which can determine changes to perform on its layer’s rule set and on their immediately subjacent layer’s adaptive functions.
Context-Sensitive (-Dependent) Formalism: Abstraction capable of representing Chomsky type-1 or type-0 languages. Adaptive Automata and Adaptive Context-free Grammars are well suited to express such languages.