Requirements Capture. We will investigate the mechanical extraction of knowledge from requirements documents, as collections of unambiguous atomic statements. These ``atoms'', given a specific modeling framework (e.g. FSMs, temporal logics, etc.), are interpreted to generate various system models. These interpretations will be done by domain-aware software agents (``modelers''), which produce models that can be visualized, and analyzed in terms of completeness, consistency and fundamental architectural constraints. The crucial concern is to come up with a trustworthy basis for the later detailed design, in a joint effort by experts in the application domain and in system design. In the framework of Abstract State Machines (ASM) the models are expressed by first-order statements and transition rules: we will investigate the usefulness of the machine character of ASMs for early validation and simulation of requirements, when given by use cases.
Techniques developed for the analysis of natural language requirements for software are being used also in analysing natural language policies for autonomic systems, with a particular emphasis on log analysis and problem determination, in the context of a joint project with IBM.
A second strand of research studies application of lexical statistics to requirements capture and management. Of particular interest in this area is the automatic extraction of lexicons from unannotated corpora of requirements documents, and the automatic establishment of relationships between requirements at different levels or stages (e.g., linking market requests to technical requirements in market-driven development processes).
Paradigmatic Architectural Models. We intend to define a collection of ground model templates which capture paradigmatic architectural composition principles and make different system views explicit, in terms of static properties, user interfaces, communication mechanisms and notions of time.
We expect three concrete short-term results: the definition of frequently used web service interaction patterns and mediator schemes and the definition of frequently used ASM composition principles (forms of submachine, conservative extension, lifting). As to the second goal, we will validate the ASM structuring principles through further experiments, e.g. by a complete but succinct high-level architectural definition of the virtual machine underlying C#. As part of our experiments, we are currently collaborating with SFU Vancouver on the design and implementation of an execution environment for a concrete ASM language called CoreASM. The third goal will be about validation of Robotics4.NET, a concurrent programming framework for defining software architectures controlling robots.
Architectures for global computing. We will study which extensions to the existing models of distributed systems are needed to express the basic architectural features of global systems. In particular, we will address issues related to adaptation to changes in the operational environment or in the business domain.
A first issue is the specification of architectures as dynamic composition of services. We plan to define an infrastructure to support modelling at the user level via a high level language to be compiled into the logic. The modal logic DSTL is also the formalism we propose for component specification. We also plan to define an abstract interface for service discovery, to encompass the semantic description of services.
Another issue is the definition of a model to enact the change plans on a running system. We plan to explore the possibility of modelling the reconfiguration of a system in terms of components ``substitution'' or integration of new components, with a consequent change in the communications inside the system itself. Once a source of components is found (like a repository in a service based model), the introduction in the system of a new component is realized via a proper change in the communication patterns, to enact the substitution of a component with a new one or to insert the new component as a new step in a data/communication-flow involving some components of the system.
Finally, there is the issue of policies. A policy is a set of rules that drives run-time decisions. In the SOA context, a policy can constrain access to a service, e.g. on the basis of the client's identity, or his past history, or according to the time of the day, or according to the number of allowed concurrent accesses. When the policies are dictated by several independent subjects, rules incompatibilites may arise, as it happens often in the SOA context. A possible way to face the incurring problems is the extension of the logic, to permit to distinguish between obligation and permission when reacting to a given condition.
Refinement. We will use refinement methods to link ground models and their architectural structure to a hierarchy of specific architectures and code designs, providing well documented and inspectable intermediate design steps. We will identify, as standard (formal) refinement steps, the mappings of the conceptual architecture to lower level architectures.