The First International Conference on Future Computational Technologies and Applications FUTURE COMPUTING 2009 November 15-20, 2009 - Athens/Glyfada, Greece

Tutorials

T1. Event Computing: Towards an Adaptive System Diagnosis
by Prof. Dr. Petre Dini, IARIA / Concordia University, Canada

T2. In Search of Design Patterns for Evolvable Modularity
by Prof. Dr. Herwig Mannaert, University of Antwerp, Belgium

DETAILS:

T1. Event Computing: Towards an Adaptive System Diagnosis
by Prof. Dr. Petre Dini, IARIA / Concordia University, Canada

Complexity of the system behavior, system adaptability and dynamics, as well as continuous changes in user requirement and expectations, raise the complexity of the systems and of their control and management. On top, high speed systems and mission critical or life critical applications and services add to this complexity the accuracy needs in a required period. It appears that human-only driven control and management are far to be reliable and to cover all system situations; while the autonomic and autonomous subsystems intend to cover a part of classically human-based duties, aspects of completeness, trust, and ambiguities add more problems to the existing status.

The tutorial deals with aspects concerning system behavior and its change manifestation, in the light of new control and management paradigms. More precisely, we describe how diagnosis are operated and validated during the run-time in large industrial systems.

The presentation has two complementary parts. The first part deals with event report schema, issues of event processing and potential solutions. The second part presents an adaptive approach to cope with the volume of events and diagnosis actions, reinforcing the notion of usability patterns of successful actions in a given situation.

Part 1 presents an industrial approach of event computing, considering the current status. A multi-level diagnosis approach is presented and discussed. A model-based framework supported by a communication bus is introduced to support a variety of behaviors, for both managed and managing entities. While some control and management functions can be automatically taken care-of by components themselves, there are still main challenges that must be considered. They will be discussed in details, guided by the following steps.

Part 1:
Layered approach for event reporting and processing: button-up and top-down;
Multi-level diagnosis;
Communication bus;
Autonomic computing;
Challenging issues (syntax, semantic, transport, security, reliability);
Case study: Syslog event system.

As the main purpose of control and management is to keep the system state as expected, all undesired, unexpected and abnormal situations must be identified and fixed, suitably, with no discontinuity in services provided to the end users. Part 2 presents an approach where a specialized diagnosis engine handles, in an adaptive manner, the states of a system and validates successful corrective actions, intended for future reuse. The following steps will be considered:

Part 2:
Diagnosis theory;
Adaptive framework for diagnosis;
Situation based diagnosis;
Diagnosis loop;
Validation loop;
Quality of Diagnosis (QoD).

Finally, open issues will be discussed, especially concerning autonomic aspects, cloud computing, and technology-oriented computing.

T2. In Search of Design Patterns for Evolvable Modularity
by Prof. Dr. Herwig Mannaert, University of Antwerp, Belgium

At the 1968 NATO Conference on Software Engineering, Doug McIlroy presented a paper "Mass Produced Software Components", in which he stated to "expect families of routines to be constructed on rational principles so that families fit together as building blocks". This vision of software as being assembled in factories is still very much alive today, and is the main goal of research in software product lines. However, at the same time we have to acknowledge that this vision, even after more than fourty years, has not yet fully materialized.

In the 1970s, Manny Lehman formulated his "Law of Increasing Complexity", in which he stated that "As an evolving program is continually changed, its complexity, reflecting deteriorating structure, increases unless work is done to maintain or reduce it." Though never formally proven, this empirical law is widely accepted by parctitioners worldwide. This law is quite fundamental, as it implies that the marginal cost of a change to a system, is ever increasing over time. Moreover, if Manny Lehman is correct, it means that the vision of Doug McIlroy cannot be realized as the fitting of building blocks into a system will become more difficult over time.

Though many people agree that current infomation systems have significant shortcomings with respect to the required levels of evolvability, they often perceive this as being caused only by timing constraints in the development of information systems. In this tutorial, it will be explained that it is a fundamental flaw of our current technology that we are not able to build evolvable modular structures. Moreover, modularity in other disciplines, like hardware and space, is also static modularity: it does not accomodate continuous changes. Even at the level of design, at the drawing table, it is for instance not possible to add an additional engine to an airplane without making an almost completely new design.

In a first part of the tutorial, it is investigated which effects may actually be responsable for the limited evolvability of software and its manifestation through the law of Manny Lehman. Based on the concepts of stability from system dynamics, and entropy from thermodynamics, it is argued that the occurence of combinatorial effects effects are probably responsible for the law of increasing complexity and for the inability to realize the vision of Doug McIlroy. For four basic combinatorial effects in the modular structure of software, it is explained how they lead to system instability and increasing complexity.

In a second part of the tutorial, several software patterns are proposed that are aimed to limit the combinatorial effects, and to provide the required evolvability with respect to a certain number of changes. These patterns are called elements, and are structured encapsulations of classes, dealing with cross-cutting concerns, and fully separating the element from all other elements. Every one of these design patterns is executable, and can be expanded automatically. It is shown how evolvable software systems can be made composed of these automatically generated elements.