"I dream my painting, and then I paint my dream." Vincent Van Gogh

Ongoing Research

Autonomous Software Systems Development Approaches
(a joint project with ESA)

ESA is currently employing the autonomic computing (AC) paradigm to the development of special autonomous components for their spacecraft systems (e.g., ExoMars) where to tackle the AC issues, ESA applies traditional development approaches. Experience has shown though, that the traditional software development is inappropriate to such tasks because it pays scant attention to the autonomic features. Therefore, to improve the development process and the quality of the ESA-developed autonomous components, a new AC-aware software development approach must be employed. This research targets such an approach that shall help the ESA developers properly: 1) express "autonomy" requirements; 2) model components or entire systems implementing such requirements; and 3) implement and test autonomous components.

KnowLang - a Formal Language for Knowledge Representation in Autonomic Service-Component Ensembles
(a work package of the ASCENS FP7 project)

Similar to human intelligence, knowledge is the source of intelligence in computer-based systems. In general, when we talk about knowledge, we mean facts, understanding, experience and associations. In computer science, all these notions at their very basic levels are related to data. Hence, the basic building block of intelligence in computer-based systems is data, which takes the form of measures and representations of the internal and external worlds of a system, e.g., raw facts and numbers. When regarded in a specific context (domain of interest), data can be assigned relevant meaning to become information. Consecutively, knowledge is a specific interpretation of information, i.e., knowledge is created and organized by flows of information interpreted and shaped by the intelligent system. Here the most intriguing question is how to represent the data and what mechanisms and algorithms are needed to derive knowledge from it. It should be noted that the knowledge of a system is represented in a way reflecting our understanding about the problem domain and we implicitly choose a way to represent the phenomenon we are studying. This research tackles the problem of knowledge representation in multi-agent systems, such as the Autonomic Service-Component Ensembles (or ASCENS). Our assumption is that knowledge representation can be regarded as a formal specification of knowledge data reflecting the system’s understanding about itself and its surrounding world. To specify knowledge in ASCENS systems, we are currently developing a special formal language termed KnowLang. With KnowLang we provide a development environment that strives to answer fundamental questions related to knowledge representation and reasoning in intelligent systems. Knowledge is structured into knowledge domains each composed of domain ontology and a logical framework providing knowledge vocabulary and logical foundations used for reasoning. Among the grand challenges to overcome are: depth of knowledge, knowledge relevance, explicit versus implicit knowledge, knowledge consistency, experience, reasoning and hybrid reasoning, etc.

Verification of Adaptive Systems
(a prospective joint project with Lockheed Martin and NASA)

Adaptive systems are being proposed for combat, security and other critical missions. Adaptive systems are systems that autonomously adjust their behavior due to unanticipated events, changes in environment, etc. Such systems may exhibit unstable behavior and must be verified before they are used in mission critical situations. However, current verification methods do not scale to support the astronomical state space of adaptive systems. This research focuses on a new approach to verification of adaptive systems that relies on existing and enhanced stability analysis techniques together with high performance simulation, state space reduction and compositional verification.

Patch Generation and Self-healing
(a work package of the FastFix FP7 project)

This research is in the area of autonomic systems and targets a software platform helping developers identify symptoms of execution errors, performance degradation, or changes in user behavior. By using correlation techniques, the platform shall also support failure replication in order to identify incorrect execution patterns and, in particular cases, automatically generate and deploy remedial patches. Thus, after the problem root cause is identified, a way is needed to generate patches to fix that defect, and if possible, do it automatically. Once the patch is ready, a way to deploy it in the application platform must be addressed.

Developing Autonomic Systems

The rapidly growing field of autonomic computing (AC) promises a new approach to developing complex computing systems. Concluding that AC is a viable long-term solution, many major software vendors—such as IBM, HP, Sun, and Microsoft—are researching programs to create computer systems that manage themselves. However, their research efforts focus mainly on making individual components of particular systems more self-managing, rather than solving the problem of autonomic system (AS) development. Thus, 10 years after the initial AC announcement, we still have far to go before establishing an autonomic culture. This goal eludes us because traditional development barely addresses some AC features. Further, the field of AC does not currently provide researchers with a clear idea of what AS development requires. Thus, whereas the AC principles and goals are clear, we still need techniques and technologies that provide programming concepts for implementing ASs. This research focuses on methodologies for developing ASs. The grand challenges to overcome in this research are: self-* requirements, knowledge, awareness, monitoring, adaptability, autonomy, dynamicity, robustness, mobility, etc.
In the curse of this research, we have been working on formal approaches to AC. Formal methods could facilitate AS development, while AC formalisms can help developers craft a well-defined formal semantics that makes the AC specifications a base from which developers can design, implement, and verify autonomic systems.

Part of this research focuses on ASSL (Autonomic System Specification Language), a framework dedicated to autonomic computing (AC) that addresses the problem of formal specification and code generation of autonomic systems. ASSL implies a multi-tier structure for specifying autonomic systems and targets the generation of an operational framework instance from an ASSL specification. This framework is conceived to help the AC researchers with problem formation, system design, system analysis and evaluation, and system implementation.

Both model checking and visual modeling with ASSL form my current research trend on ASSL. The objectives of model checking with ASSL are focused on developing a model-checking mechanism that allows for handling logical errors. Here, the threefold objective is:

  1. Develop a model-checking mechanism for ASSL that takes as input an ASSL specification and produces as output a finite state-transition system such that a specific property in question is satisfied if and only if the original ASSL specification satisfies that property.
  2. Develop a mechanism for ASSL embedding the Java PathFinder tool (developed at NASA Ames) to perform post-implementation model checking on ASSL-generated autonomic systems.
  3. Develop a mechanism for ASSL allowing for mapping ASSL specifications to special Service Logic Graphs supporting reverse model checking and games.
The goal of visual modelling with ASSL is to develop UML-like presentation of the ASSL tiers where a visual environment that implements the ASSL mathematical models will help expert designers to efficiently build autonomic systems via modeling customizable ASSL specifications with the drag-and-drop technique.

Developing and prototyping intelligent swarm systems and sensor networks with ASSL is another research trend I am currently pursuing. Currently, the ASSL framework provides a toolset allowing ASSL specifications to be edited, syntactically and semantically validated, and Java code to be generated. These features of ASSL helped the latter be used successfully to specify autonomic features and generate prototype models for a few systems including two NASA projects - the Autonomous Nano-Technology Swarm Concept Mission and the Voyager Mission. In both cases, the generated prototype models helped to simulate space exploration missions and validate features through experimental results. Here, the benefits come from the ability to simulate exploration missions with hypothesized autonomic features.

Last modified on October 18, 2011