Developing Adaptvie Systems

/* This is not a solely authored paper, but some personal reflections alongside the cited throughout the paper sources */

 

Abstract

 

In this paper the main idea would be to provide a good amount of understanding about Adaptive Systems, more specifically certain aspects that have to do with the development of such systems. There would be some introduction to the basic ideas going behind the field of Adaptive Systems as a whole and then examples would be provided that go into further details about the processes of development.

 

Introduction

 

Modern day computers and computational devices as a whole have been built with the idea of mimicking how the human brain would function, if it were to be put to perform various, in a broad spectrum of complexity, computational calculations that through their completion would benefit a given field of study or/ and work. The next and logical step that follows is the development of computer systems, such that would try to closely resemble a human being, as far as it goes to the ability to perceive the surroundings and act upon previous knowledge, or as is the case with computers – computational logic. The previously mentioned next step is the development of computer/ computational systems called Adaptive Systems that re-organize their current work upon an encounter with changes in their environment through means of self-act and not through explicit external command.

The concept of Adaptive Systems in the computational world, their various applications, and ways to be created have existed from some time, nonetheless that stated, there are certain problems and ongoing development challenges that stand.

One of the main issues that stand is in regards to the software components (or agents) that are the main building block of adaptive systems. It is from the developer’s perspective both a question of architectural implementation and of general usefulness for the overall software solution to be decided, if these agents would be built to act in a selfish or cooperative manner [1] in terms of their designated programmed purpose.

Other issues include: management of uncertainty – or how the system would react upon adverse external environmental events that have been unforeseen in the computational logic; interactions – how are the diverse software modules to interact with each other when executing their ongoing tasks, after certain known or/ and unknown conditions have occurred or not; control – how is the overall process of independent decision-making and solution-reaching being put into some measureable or quantifiable values of guiding the system, so that to make sure it is “adapting as designed” and not being led astray from its purpose to be correct, stable and perform; [1]

All of the above mentioned are ongoing, debatable and important issues that need answers in some form of development framework or an agreed upon concept of work. The so far said is important to be pointed out as it gives perspective of the so far argued upon field of software development, as well as it puts forward the following sections of this paper that are going to provide insight into some of the mentioned in terms of their development as software for adaptive systems.

Firstly, there would be an introduction of the way an adaptive system works and one approach into the development would be cited and explained. Then, there would be a certain model of such given as a detailed overlook of the most important aspect in every adaptive system – the constant loop of an adaptive system’s work, the process of receiving a feedback from the external environment, the analysis, the decision-making and acting upon the provided conditions.

 

Adaptive Systems, the Basics

 

Most adaptive systems, including autonomic systems, are made of three key elements: monitoring, decision-making, and reconfiguration. [2]They are key, because they represent the foundational idea for making adaptive systems work as self-organizing and self-acting systems. Each one of them must be carefully implemented from the concept on paper of what it is supposed to perform, to the solid foundation of a software unit. The monitoring part, takes care for the environment in which the system operates, it provides the necessary information for the decision-making part to do its job. In order for the lastly said to happen, the monitoring must be well developed so that it does not give incorrect information to the decision-making part that may wrongfully conclude to enact an unnecessary reconfiguration. Not too long ago, most development approaches have addressed adaptation by using ad hoc techniques that would work for just the given case. In order to address this problem, researchers have developed adaptation-enabling frameworks, middleware, and language-based support. [2] These approaches, however, come to be for the most part tightly coupled with specific domains or technologies, thus limiting their applicability with respect to the specific problem being addressed. Design patterns, on the other hand, work at the modeling and design level of abstraction, thereby potentially increasing the amount of design reuse when compared to other approaches.

One such design pattern for development of adaptive systems would be described on the following lines.

In its development process, it separates the adaptive behavior and the non-adaptive behavior specications of adaptive programs. By doing so, the respective models are easier to be specified and more agreeable to automated analysis, visual inspection, and modification. [2] As the bellow given Figure 1: Model Based Development Process [2] illustrates, the process starts with high-level system goals (G) and progresses through design models (Mi, Mj) to code. The focus of the process is the specication of key properties (e.g., Фi, Фj) at each of the major development phases. While the original work used Petri-nets to illustrate the design phase, the process itself is compatible with other state-based modeling approaches such as the Unified Modeling Language (UML).

Image

Figure 1: Model Based Development Process [2]

The model-based development process comprises of six key steps:

  1. Specify global properties, INV, using a high-level specication language such as temporal logic.
  2. Identify the diferent domains, Di, or environmental conditions under which a program with requirements Ri will execute.
  3. Using a high-level specification language, specify local properties, Фi for each domain identied in step (2).
  4. Build state-based models (Mi and Mj) of the non-adaptive programs in each domain. Simulations and verification can be applied to verify and validate the models against both the local (Фi, Фj) and global properties (INV) previously specified.
  5. Identify the possible scenarios in which dynamic changes may occur. Build adaptive models, Mi;j and Mj;i, to safely transfer execution from a source program to a target program. Specify transitional properties, Фi;j and Фj;i, to indicate the properties that must be satisfied during the adaptation process. As with step (4), simulations and verifications can be applied to verify and validate the adaptive models against global and transitional properties.
  6. The state-based models can be used to either generate rapid prototypes or to guide the development of adaptive programs. [2]

The above cited and described model gives a very valuable approach that is not too difficult to implement in the process of development adaptive systems. It is quite intuitive to follow and I consider its logical separation, and at the same time interconnection in the development, of the adaptive and non-adaptive modules to be the focal point – where through this simplification, a more complex adaptive system is created.

 

Adaptive Systems, the work process loop

 

First, it is important to point out some of the thought processes that go about when one/ team of developer/ s work/ s on a software product, as the general software development approaches differ quite significantly from the way an adaptive system should be considered in its development stages. The general way of thinking would be to provide clear goal/ direction for the intended system, where it should do “this and that, but not some other thing“. The lastly said is a fine way to think for regular systems and their applications, as they have a somewhat linear approach of interaction with the environment they are in, as well as among themselves. On the other hand, the adaptive systems require more of “guessing” pattern of approach towards the definition of its function/ s, where the end state/ result of a given input information is uncertain and stands something like this: “it might perform this, the system might act that way, but if not it is possible to be eventually doing this and might be expecting such results, etc.” The so far discussed goes to call attention to the new attitudes that must be harnessed from the developers’ point of view, where they should be asking rigorously many questions, broaden the spectrum of their regular linear idea generation and strive to provide as many answers as possible, so that to create a truly automated autonomous adaptive system. What follows to be put forward is a detailed formal expression of the thought processes that encompass the work of an adaptive system.

From the so far mentioned statements about self-adaptive systems, it is reasonable to conclude that two of the most common characteristics that an adaptive system possess are (1) that its decision-making is done at run-time and (2) that the system has to reason with its state and environment. The system reasons by following a feedback loop process that involves the listed endeavors: collect, analyze, decide and act – as given in Figure 2: Activities of the control loop [3].

Image

Figure 2: Activities of the control loop [3]

In this case, what the figure describes is actually the process of carrying-back the feedback messages in order to control (the loop of) the adaptive system’s dynamic behavior.

Per example, in order to keep a web services up and running for a given time, it requires the collection of information about the current state of the system, analyzing that information to diagnose possible performance problems or to detect failures, then to decide if need be how to resolve the problem (e.g., via dynamic load-balancing or healing), and to act on those decisions. The generic model of a control loop as shown on Figure 2: Activities of the control loop [3] provides an overview of the main activities around the control loop, however it ignores the properties of the control and the data flow around the loop. When engineering a self-adaptive system, questions about these properties become important. Now, such questions are to be identified and it must be argued that in order to properly design self-adaptive software systems, these questions must be brought to the forefront of the design process. [3]The feedback cycle starts with the collection of relevant data from environmental sensors and other sources that reflect the current state of the system. Certain engineering questions that are missed on Figure 2: Activities of the control loop [3] are ignored with respect to collection of environmental information, nonetheless they are important to the engineering process: What is the required sample rate (how many, one, two or an xy amount of data is needed to determine via an analysis a decision-making after a collection of data)? How reliable is the sensor data? Is there a common event format across sensors?

The next step would be the system’s analyses the collected data. Nevertheless, there are many approaches to structuring and reasoning about the raw data (e.g., using applicable models, theories, and rules). Some of the important questions here are: How is the current state of the system inferred? What amount of past states may be needed in the future? What data needs to be archived for validation and verification? How faithful is the model to the real world? Can an adequate model be derived from the available sensor data? [3]

Then, what comes is the system making a decision about how to adapt in order to reach a desirable state. Approaches such as risk analysis can help make this decision. Once again, there are important questions that must be answered: How is the future state of the system inferred? How is a decision reached (e.g., with off-line simulation or utility/ goal functions)? What are the priorities for adaptation across multiple control loops and within a single control loop?

And lastly, to implement the decision, the system must act via available actuators and effectors (controlling mechanisms and available end means to act). The important questions here are: When should the adaptation be performed safely? How do adjustments of different control loops interfere with each other? Does centralized or decentralized control help achieve the global goal? Does the control system have sufficient command authority over the process—that is, can the action be implemented using the available actuators and effectors? The above questions—as well as others—regarding the control loop should be explicitly identified, recorded, and resolved during the development of the self-adaptive system. [3]

 

Conclusion

 

Adaptive systems are to play a major role in the future of computational machines that people use on a daily basis, the most obvious example would be the multi-purpose mobile devices. The development processes that were discussed in this paper (and the others that were not mentioned) are still being refined into better and better frameworks and general-purpose communication system to build applications for everyday use, for every person and be tailored to his/ her needs. The area of adaptive systems has long been of great benefit to the network and communications technologies, as they rely on the basic principles of adaptation to perform network routing trafficking, peer-to-peer networking, firewall protection and others.

One important aspect of adaptive systems that, so far in this paper has been partially depicted, and needs to be put into attention, is the fact that adaptive systems have been studied within numerous research areas of software engineering, programming languages and many others, yet most of these endeavors have been isolated. There are other research communities that have also explored this topic from their own respective interests and expertise. They all have varied ideas: fault-tolerant computing, distributed systems, biologically inspired computing, distributed artificial intelligence, integrated management, robotics, knowledge-based systems, machine learning, control theory, etc. With the lastly said, it must stressed that the development of adaptive systems is of interest and takes its information from many disciplines of science and what software developers of such systems must learn is that they have to be ready to gather knowledge and ideas for implementation from sources outside their immediate field of study.

However, there still lies the challenge into the development of adaptive systems, handling the uncertainty and in respect the inherent dynamism in this type of systems. As pointed out by some examples in this paper, there are some solutions to this problem, found in regular programming principles, used in conjunction with other methods.

What must be taken as an outline of the overall discussed problems, solutions and ways to design and implement adaptive systems, is that there seems to be not one method, model or framework that gives the solution of how to best develop them, but through them and the needed new discoveries in this field, are to put a clearer and more orderly perspective.

 

Works Cited

 

[1] G. D. M. Serugendo, “Adaptive Systems,” 2009. [Online]. Available: http://www.dcs.bbk.ac.uk/~dimarzo/courses/as/EngineeringAdaptiveSystems2.pdf. [Accessed 6 January 2013].
[2] A. J. Ramirez and B. H. Cheng, “MSU Technological Publications,” 2009. [Online]. Available: http://www.cse.msu.edu/publications/tech/TR/MSU-CSE-09-8.pdf. [Accessed 6 January 2013].
[3] S. Jamin and J. Laird, 8 September 2006. [Online]. Available: http://web.eecs.umich.edu/~sugih/courses/eecs494/fall06/lectures/lecture2-design-arch.pdfoMU1jM67AY5Q. [Accessed 6 January 2013].
Advertisements

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s

  • Blog Stats

    • 320 hits
  • My Twitter Stuff

    Error: Twitter did not respond. Please wait a few minutes and refresh this page.

%d bloggers like this: