Using B Formal Method to Define Software Architecture Behavioral Concepts

Metric-based Evaluation of Implemented Software Architectures

This special issue is based on a collection of selected papers presented at the Fifth International Conference on Advanced Computing held in Chennai (Madras), India in December 97. The International Conference on Advanced Computing is organized annually in India by the Advanced Computing Society (ACS) which is a premier professional society set up in India to cater to the broad interests in the area of Advanced Computing. One of the significant activities of the Society is to organize regular Meetings/Conferences/Symposia. The Conferences are held annually in India during December. Out of the shortlisted papers presented at the Conference held in Chennai (Madras) during December 97, the following six papers were finally selected after a second round of detailed review of the papers. The first paper On designing and implementing collaborative system using Java-RMI by Rajeev R. Raje, Snehasis Mukhopadhyay, Michael Boyles and Nila Patel describe the use of Java-RMI in designing a collaborative information classifier. The principles of RMI, the details of the prototype, and some preliminary results are presented. The paper primarily concentrates on web-based computing paradigms. In the second paper A framework for performance-based program partitioning , Ram Subramanian and Santosh Pande present an efficient and accurate performance model based program-partitioning approach for parallel architectures. The interactions between computation and communication are captured through behavioral edges . The approach yields significant performance improvement. The third paper DDSCHED: a distributed dynamic real-time scheduling algorithm by Anup K. Bhattacharjee, K. Ravindranath, R. Mall and A. Pal presents a dynamic soft real-time scheduling algorithm for distributed systems. The algorithm is based on a local scheduler and a distributed scheduling scheme. The algorithm takes care of the network delays assuming that the communication protocol is CSMA/CD. In the fourth paper Generic operational decomposition for concurrent systems semantics and reflection , Annie Marcoux, Christine Maurel, Frederic Migeon and Patrick Salle discuss about the reflection in concurrent languages, particularly in actor-based languages. The main objective of the paper is to extend concurrent systems to reflection. The authors present a modular and dynamic description of entity operational management, and extend the decomposition to obtain reflective entities. The fifth paper Parallel programming using visual patterns by A. S. M. Sajeev proposes a two level approach to parallel programming within the context of a visual environment. The first level is the specification of patterns encapsulating process communation and synchronization, and the second level is the use of patterns for parallel programming. The approach encourages reuse of patterns. In the sixth paper An application framework for dynamic distributed software architectures , G. R. Ribeiro-Justo and P. R. F. Cunha present an object-oriented application framework for developing evolving (reconfigurable) software architectures for distributed systems. The application framework is called C++CL. Such a requirement is encountered in banking, industrial control and telecommunications applications. We are extremely thankful to the following reviewers who have helped us in reviewing the papers submitted for this special issue: Lawrence Jenkins N. Mohan Ram Nishit Narang Rajeev Shorey Sameer Adhikari K. Balaji K. Rajan Sumit Kasera Subhrajyothi Bhar Pankaj Sethi Ravindranath Kokku Guest Editors: L. M. Patnaik, Ravi Mittal and K. M. Mehta

The situation of telecommunications systems is rapidly evolving towards a state characterized by the presence of a multitude of services integrated in a single network structure. In order to ease their integration, it is important to provide an unambiguous description of the organization, of the functionality, and of the relationships existing among services. Since it is not possible to completely foresee the situation of services in the future, the description should be modular, so that the task of adding new services to an existing environment is simplified. Formal description techniques are languages designed to handle such descriptions. Their goal is to produce correct and unambiguous specifications, understanding and modeling the system and the domain within which it operates. Their input is a set of required statements and a conceptual overview of the system. Their output is a formal representation that captures the functional behavior. On the other hand, the throughput of physical networks is constantly growing, reaching the order of Gbit/s. In the meantime, services needing high throughput, like multimedia conferencing systems are being designed, creating a need for flexible, high performance communication systems. An important feature of new high speed services is their increased need for guarantees. Therefore, the use of powerful performance modeling techniques becomes of prime importance. Their goal is to obtain some notion of how the system will perform under a given set of conditions. Performance evaluation theorists have long been using system specifications to make a heuristic model of the system and then an analysis of the model. When system specifications exist, the question arises whether a more direct path to performance analysis can be found. Our scope is to provide a methodology that fully and consistently integrates formal specification and performance evaluation. A problem is that many of the bottlenecks and impediments to smooth data flow have to do with implementation issues not directly dealt within the system specification itself. Therefore, prior to generating a performance model, the formal specification should be enhanced with the relevant non-functional information. It is essential to assure a smooth specification of the non-functional information. Thus, it is necessary to consistently add this information to the formal specification. Besides, the extended formal method should focus on conserving the semantics of the original one, and on providing a coherent extension of the semantics and syntax for the new concepts. Since all relevant required information is integrated within the formal extended representation, we provide a mapping technique that translates the extended formal representation into a performance modeling conserving the properties of the formal model. In parallel to the development of a performance model, the formal model can be validated and verified, and their implementation can be tested for conformance towards the original formal model. Finally, the performance modelling is implemented in a programming language, and then simulated. The results from simulation can be reused as inputs for the optimization of the formal specification (functional optimization) or the extended formal model (design optimization). To sum up, the goal of this work is to: Define extensions to current formal methods that allow to enhance the formal specification with performance modeling related information. Develop a method to translate the extended formal specification into a performance modeling. Develop rules and guidelines to automatically implement the performance modeling for the purpose of a performance evaluation (we use the commercial tool Opnet). Develop a consistent and coherent methodology for the integration of performance modeling and formal specification.

A major cause of many complications in the field of software architectures is the lack of appropriate abstractions for separating, combining and encapsulating concerns of various kinds in architectural descriptions. Architectures of most complex software-intensive systems involve concerns that inherently crosscut the natural boundaries of the elements composing the architecture descriptions. Crosscutting concerns intersect the common modularity of systems as prescribed by their architecture descriptions, by traversing both the components and connectors, i.e., the relationships among the components. Crosscutting concerns are critical aspects of many architectural problems. However, architectural descriptions written in special-purpose languages (ADLs) like Wright, Darwin, Rapide and Acme should support descriptions of multiple structures, which include diagrams, models and views, that intentionally address different kinds of concerns. ADLs should show how various concerns affect each other in architectural designs; they should also allow one to identify, analyze and elaborate architectural concerns that cut across several software components, such as transactions, security, load balancing, synchronization, reuse, customization, scalability, etc.; they should, but they do not. This dissertation presents a new approach to software architecture that is suitable for supporting concern-oriented development and documentation of architectures for software-intensive systems. This approach allows for creating and documenting a multidimensional software structure that is referred to as concern-oriented software architecture; it provides new mechanisms for encapsulating individual concerns into independent architectural constructs. The ultimate goal of this new approach is to provide support for achieving design by concerns all through the development and description of software architectures. Moving towards this goal, we present a particular concern-oriented architectural framework called Perspectival Concern-Spaces (PCS). The PCS Framework offers a flexible and extensible means a) for supporting advanced separation of concerns in architectural design, and in the construction and evolution of software-intensive systems; and b) for filling the gap between architectural descriptions and modern software development artifacts. To show the feasibility of the proposed approach, we provide new modeling techniques that are used to describe and apply an aspect-oriented architectural pattern, called the On-demand Remodularization pattern. We give several examples of how the PCS Framework can be used to integrate concern-oriented architectural documentations with mainstream software development artifacts.

Integration of architectural descriptions in development tools and environments, in order to take architectural descriptions into account, is a topical issue. Nowadays, the existing formalisms to represent software architecture fail in providing a clear semantics and only give an intuitive graphical representation of the system as a whole. More specifically, the framework architectures should show the overall design and the specification of the points of the variability of the framework, making easier the reuse of the architectures, integration with others frameworks and a reference to measure the changes in subsequent versions of the frameworks. In this paper we propose an approach to describe the architecture of frameworks, combining formal and non-formal formalisms: Wright, an architectural description language developed at Carnegie Mellon University, and architectural patterns. Based on the study of several frameworks, our objective was to produce a complete description of a framework, to show the expressive power of both approaches and to consider complementarity and flexibility regarding to other approaches.

Software architecture is high-level software design, dealing with the structure and organization of software systems. A software architecture is defined in terms of computational components and interactions among those components. Architecture description languages (ADLs) represent architecture-level software designs. Different ADLs often have different intents; e.g., Rapide supports architecture simulation and Acme is intended to be both an ADL and an ADL interchange format. Experimental applications of two ADLs were conducted to determine the effectiveness of ADLs for architecture-level analysis of simulation systems; one of them is reported. Acme was used to model the architecture of ModSAF and to analyze its run-time performance. The model was used to analyze execution time at the component and federate levels and to estimate the maximum number of internal and external simulation entities that could be supported by the ModSAF architecture. The experiment showed that ADLs could model important features of simulation system architectures.

Large and complex software systems cannot be created in one piece. They need to be separated into manageable units, i.e., modules, which can be developed independently from each other. Precise definition and documentation of the modules and other software artifacts is essential for a successful software project. The module documentation is part of the overall software architecture documentation. However, nowadays most of the utilized tools for documenting software architectures (e.g., word processors) are not fully sufficient for this task. This thesis provides a concept for an extensible tool, which is specialized for documenting software architectures and modules. The concept supports management and visualization of explicitly definable relations, e.g., dependencies among modules or references to external implementation artifacts. Moreover, this thesis suggests a template for module documentation based on its concept. Finally, a proof of concept prototype is implemented and evaluated with promising results.

In this paper we propose P/S-CoM+, a formal approach that helps architects to model correct publish/subscribe architectural styles (PSAS). We extend P/S-CoM formal approach, that focuses on the correct by design of PSAS structure, by behavioral aspect. We specify communication schemas including the state of component types and ensuring no loss of events. We formally model behavioral properties namely delivery semantics, ordering and persistence of notifications. We set up a formal method for composing communication schemas and building correct PSAS. We develop an ECLIPSE plugin P/S-CoM'SD that assists architects in graphically conceiving the desired PSAS. We describe the dynamic behavior of component types by specifying interaction rules. All the specifications are coded in Z notation and proved under Z-Eves theorem prover.

Introduction: The introduction of Clinical Information Systems (CIS) to manage and store patient information has deeply modified the workflow of caregivers. As the information is no longer stored on a physical medium, caregivers depend on the presence of a computer to access patient data. This constraint has built up an invisible barrier between the source of information and the place of its use. The popularisation of mobile devices offers an oportunity to break this barrier by providing a ubiquitous access to information. The use of a mobile platform merges the advantages of a modern CIS and the mobility offered by paper. We have developed an application on a mobile device that nurses can carry along on all their visits. It allows the information gathered during their visits to be entered directly into the system. Method: The tool we present aims to manage the daily interventions of nurses. The interventions concern all kinds of treatments provided by nurses to patients. In the current organisation, nurses start their day by printing out all the daily interventions and use it as a procedure to follow. Every time a nurse performs an intervention, she takes a note indicating that the task has been done properly. When they have some spare time, nurses enter all the gathered information in the CIS. Once nurses are equipped with mobile devices, paper becomes useless. Consequently, the process is simplified. Replacing the paper by a mobile device application is not straightforward. In order to access patient information, the tool must be linked to the existing CIS of the hospital without creating too strong dependencies. Moreover, the mobile interface must be adapted to the specificities of the mobile device such as a smaller display size, a reduced computational power, a tactile-based interaction and a real-time usage. Results: In order to link the mobile application to the existing CIS, we relied on a Service Oriented Architecture (SOA). It was mandatory to think of a software architecture that would not create a dependency with any legacy system. Thus, we defined a gateway server providing centralised access for the mobile application to any required information to or from the CIS. Integrating any mobile application would only require integrating this bridge. The gateway server also clearly separates the services that are available remotely from the ones proposed as usual Web services. The developed application not only allows the validation of the interventions and the input of measures, but it also offers a simple way to define the context in which nurses are working. This context is necessary to identify the specific list of interventions for the patients under the caregiver’s responsibility. The current CIS of the HUG includes a module that provides information concerning the interventions. Its interface is adjusted for a personal computer screen. Since caregivers are accustomed to this organisation of the information, we aimed to develop an interface on a mobile device that guarantees a certain level of homogeneity with the existing PC application. However, a mobile device’s screen is of limited size, therefore the interface has been completely rebuilt to be adapted to the new display. To deal with the limited display size, we rely on hierarchy and indexicality principles. For instance, based on the hypothesis that all tasks belonging to one category and planned at the same time can be regrouped under a single item; we regroup the interventions of similar top level in a common item. Moreover, to minimise user manipulations, relevant items are automatically moved to the top. Conclusion: The current daily workflow of nurses cannot be managed consistently using a unique tool. The need to switch from paper to computer induces work overload and is a source of errors. Therefore, we have developed a program running on a mobile device that nurses can carry during their visits. This program allows to manage nurses' daily interventions in real-time. The development of such a tool has required a complete reconstruction of the classical personal computer interface. This new interface takes into account a smaller display size, an innovative interaction paradigm, and real-time constraints.

In the past decade, software architecture research has mainly focused on the concept formulation and the development of various architecture description languages. This field has now matured enough and thus requires more emphasis on techniques for developing and analyzing software architecture specifications. SAM is a general software architecture model for developing and analyzing software architectures. In this paper, we show how to integrate high-level Petri nets and first-order temporal logic as the foundation of SAM to establish a unified framework for specifying and analyzing all aspects of a software architecture. We provide a set of heuristics, which are supported by well-defined existing methods and techniques developed by other researchers as well as our own, for software architecture development and analysis. We demonstrate the application of this framework and the heuristics with an example.

The DREAM [1] software architecture model describes a reference class model and sequence diagrams, derived from use cases, that aid in integrating the different components for active distribution grids to applications. DREAM can be used in the commercial and grid operation application domains. It is designed to support the simulation (proof-of-concept) to the implementation stage (proof-of feasibility) of systems. The framework facilitates interoperability on the software and hardware level as well as from the communication technology level. The framework was designed from a use cases perspective. The major functionality implemented relates to flexible, heterarchic aggregation and coordination of devices involved in demand and supply of electricity. In the grid context, aim is to achieve a common objective, prioritize actions and operate on various timescales of grid operational and market functions. To that end, in the framework, monitoring data are handled and stored in a distributed fashion in order to directly steer or coordinate the operation of devices. These persistent data also allow handling forecasts and create interaction possibilities with actors or communities of actors on global and local markets and with operations in active distribution grids and customer energy management. A first implementation is now being built.

Privacy-enhancing personalized (PEP) systems address individual users' privacy preferences as well as privacy laws and regulations. Building such systems entails modeling two different domains: (a) privacy constraints as mandated by law, voluntary self-regulation, or users' individual privacy preferences, and modeled by legal professionals, and (b) software architectures as dictated by available software components and modeled by software architects. Both can evolve independently, e.g., as new laws go into effect or new components become available. In prior work, we proposed modeling PEP systems using a product line architecture (PLA). However, with an extensional PLA, these domain models became strongly entangled making it difficult to modify one without inadvertently affecting the other. This paper evaluates an approach towards modeling both domains within an intensional PLA. We find evidence that this results in a clearer separation between the two domain models, making each easier to evolve and maintain.

Software development has undergone various stages of paradigms - the very last one is called Object-Oriented (O-O) paradigm. Typical of this paradigm has been culminated by several OO programming languages such as C++, Java and VB. With the advent of Internetworking and evolvement of web technologies, business needs, especially isolated service requests/components, put a new demand on new software architecture. Existing models are examined in the light of their constraints and limitations to meet these constant changing business requirements. Service-oriented Architecture (SOA), as the next generation software architecture and through the utilization of the web service, XML and other related technologies provides viable working solution to implement dynamic e-business. This paper discusses SOA model and how it fits into implementing dynamic e-business solutions.

Self-organisation is increasingly being regarded as an effective approach to tackle modern systems complexity. The self-organisation approach allows the development of systems exhibiting complex dynamics and adapting to environmental perturbations without requiring a complete knowledge of the future surrounding conditions. However, the development of self-organising systems (SOS) is driven by different principles with respect to traditional software engineering. For instance, engineers typically design systems combining smaller elements where the composition rules depend on the reference paradigm, but typically produce predictable results. Conversely, SOS display non-linear dynamics, which can hardly be captured by deterministic models, and, although robust with respect to external perturbations, are quite sensitive to changes on inner working parameters. In this thesis, we describe methodological aspects concerning the early-design stage of SOS built relying on the Multiagent paradigm: in particular, we refer to the A&A metamodel, where MAS are composed by agents and artefacts, i.e. environmental resources. Then, we describe an architectural pattern that has been extracted from a recurrent solution in designing self-organising systems: this pattern is based on a MAS environment formed by artefacts, modelling non-proactive resources, and environmental agents acting on artefacts so as to enable self-organising mechanisms. In this context, we propose a scientific approach for the early design stage of the engineering of self-organising systems: the process is an iterative one and each cycle is articulated in four stages, modelling, simulation, formal verification, and tuning. During the modelling phase we mainly rely on the existence of a self-organising strategy observed in Nature and, hopefully encoded as a design pattern. Simulations of an abstract system model are used to drive design choices until the required quality properties are obtained, thus providing guarantees that the subsequent design steps would lead to a correct implementation. However, system analysis exclusively based on simulation results does not provide sound guarantees for the engineering of complex systems: to this purpose, we envision the application of formal verification techniques, specifically model checking, in order to exactly characterise the system behaviours. During the tuning stage parameters are tweaked in order to meet the target global dynamics and feasibility constraints. In order to evaluate the methodology, we analysed several systems: in this thesis, we only describe three of them, i.e. the most representative ones for each of the three years of PhD course. We analyse each case study using the presented method, and describe the exploited formal tools and techniques.

Software architecture research focuses on models of software architectures as specified in architecture description languages (ADLs). As research progresses in specific areas of software architectures, more and more architectural information is created. Ideally, this information can be stored in the model. An extensible modeling language is crucial to experimenting with and building tools for novel modeling constructs that arise from evolving research. Traditional ADLs typically support a small set of modeling constructs very well, but adapt to others poorly. XML provides an ideal platform upon which to develop an extensible modeling language for software architectures. Previous XML-based ADLs successfully leveraged XML's large base of off-the-shelf tool support, but did not take advantage of its extensibility. To give software architecture researchers more freedom to explore new possibilities and modeling techniques, while maximizing reuse of tools and modeling constructs, we have developed xADL 2.0, a highly extensible XML-based ADL. xADL 2.0 supports run-time and design time modeling, architecture configuration management and model-based system instantiation. Additionally, xADL 2.0 has a set of extensible infrastructure tools that support the creation, manipulation, and sharing of xADL 2.0 documents.