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:
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.
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.
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.
Develop a mechanism for ASSL allowing for mapping ASSL specifications to special Service Logic Graphs
supporting reverse model checking and games.
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.