Structure and Behaviour of Virtual Organisation Breeding Environments

This paper provides an outline of a formal approach that we are developing for modelling Virtual Organisations (VOs) and their Breeding Environments (VBEs). We propose different levels of representation for the functional structures and processes that VBEs and VOs involve, which are independent of the specificities of the infrastructures (organisational and technical) that support the functioning of VBEs. This allows us to reason about properties of tasks performed within VBEs and services provided through VOs without committing to the way in which they are implemented

Can Component/Service-Based Systems Be Proved Correct?

Component-oriented and service-oriented approaches have gained a strong enthusiasm in industries and academia with a particular interest for service-oriented approaches. A component is a software entity with given functionalities, made available by a provider, and used to build other application within which it is integrated. The service concept and its use in web-based application development have a huge impact on reuse practices. Accordingly a considerable part of software architectures is influenced; these architectures are moving towards service-oriented architectures. Therefore applications (re)use services that are available elsewhere and many applications interact, without knowing each other, using services available via service servers and their published interfaces and functionalities. Industries propose, through various consortium, languages, technologies and standards. More academic works are also undertaken concerning semantics and formalisation of components and service-based systems. We consider here both streams of works in order to raise research concerns that will help in building quality software. Are there new challenging problems with respect to service-based software construction? Besides, what are the links and the advances compared to distributed systems?Comment: 16 page

interActors: A Model for Supporting Complex Communication in Concurrent Systems

In concurrent systems, such as multi-core computers, parallel systems, cloud computing systems, and systems involving mobile devices, processes interact with each other. Protocols for interactions among processes are increasingly complex and diverse, which is in part responsible for making programming of concurrent systems difficult. Particularly, in a concurrent program, the code for communication protocols often intermixes with the code for its functional behaviors, compromising modularity and reusability. There is a growing body of work on separating communication concerns of processes from their functional concerns. Although they achieve some degree of separation, they have some disadvantages. For example, the number of communication participants is fixed in some approaches, or in other approaches, communication mechanisms, such as for establishing the initial rendezvous for communication participants is left to the processes. In other words, existing approaches either offer static protocols that cannot handle dynamically evolving number of participants in interactions, or offer complex initialization steps that are left mixed with functional concerns. I propose interActors, a model for supporting complex communications in concurrent systems. I treat a communication as a first-class object which consists of outlets, through which processes can connect to it, and handlers, which are responsible for handling communication logics. Outlets establish a boundary between communications and processes in an application. New outlets can be created if necessary, to handle dynamically changed communication patterns at run-time. We say communications are self-driven because they have outlets and handlers that are active and therefore they can move interactions forward. More complex communications can be constructed by composing simpler communications. Operational semantics and compositional semantics are developed by extending the Actor model of concurrency with support for complex communication. A prototype implementation is developed using Scala and Akka actor library. With the intention of restricting arbitrarily complex code in communications, I developed Communication Specification Language (CSL), which excludes loops from communications and only allows a small set of statements and expressions. interActors are evaluated using case studies and comparison with Reo, a leading coordination model and language. The evaluation shows that interActors offer advantages in terms of programmability, reusability, and modularity

Adaptive Middleware for Resource-Constrained Mobile Ad Hoc and Wireless Sensor Networks

Mobile ad hoc networks: MANETs) and wireless sensor networks: WSNs) are two recently-developed technologies that uniquely function without fixed infrastructure support, and sense at scales, resolutions, and durations previously not possible. While both offer great potential in many applications, developing software for these types of networks is extremely difficult, preventing their wide-spread use. Three primary challenges are: 1) the high level of dynamics within the network in terms of changing wireless links and node hardware configurations,: 2) the wide variety of hardware present in these networks, and: 3) the extremely limited computational and energy resources available. Until now, the burden of handling these issues was put on the software application developer. This dissertation presents three novel programming models and middleware systems that address these challenges: Limone, Agilla, and Servilla. Limone reliably handles high levels of dynamics within MANETs. It does this through lightweight coordination primitives that make minimal assumptions about network connectivity. Agilla enables self-adaptive WSN applications via the integration of mobile agent and tuple space programming models, which is critical given the continuously changing network. It is the first system to successfully demonstrate the feasibility of using mobile agents and tuple spaces within WSNs. Servilla addresses the challenges that arise from WSN hardware heterogeneity using principles of Service-Oriented Computing: SOC). It is the first system to successfully implement the entire SOC model within WSNs and uniquely tailors it to the WSN domain by making it energy-aware and adaptive. The efficacies of the above three systems are demonstrated through implementation, micro-benchmarks, and the evaluation of several real-world applications including Universal Remote, Fire Detection and Tracking, Structural Health Monitoring, and Medical Patient Monitoring

General framework for service engineering analysis and design

The research produced a General Service Engineering Framework (GSEF), a process guideline for building a service system which covers both the business and informatics aspects. The framework also defines service engineering ontologi, which collects and specifies components of service engineering and its internal relations

A coordination model for service-oriented interactions

Abstract. We present a formal model for the coordination of interactions in service-oriented systems. This model provides a declarative semantics for the language SRML that is being developed under the FET-GC2 project SENSORIA for modelling and reasoning about complex services at the abstract business level. In SRML, interactions are conversational in the sense that they involve a number of correlated events that capture phenomena that are typical of SOC like committing to a pledge or revoking the effects of a deal. Events are exchanged across wires that connect the parties involved in the provision of the service.

A Coordination Model for Service-Oriented Interactions

A Coordination Model for Service-Oriented Interaction