Aspects in Requirements work and Composition-Centric Requirements Engineering Presentation slides

Abstract.It is well accepted that different types of distributed architectures require different levels of coupling. For example, in client-server and three-tier architectures the application components are generally tightly coupled between them and with the underlying communication middleware. Meanwhile, in off-line transaction processing, grid computing and mobile application architectures, the degree of coupling between application components and with the underlying middleware needs to be minimised along different dimensions. In the literature, terms such as synchronous, asynchronous, blocking, non-blocking, directed, and nondirected are generally used to refer to the degree of coupling required by a given architecture or provided by a given middleware. However, these terms are used with various connotations by different authors and middleware vendors. And while several informal definitions of these terms have been provided, there is a lack of an overarching framework with a formal grounding upon which software architects can rely to unambiguously communicate architectural requirements with respect to coupling. This paper addresses this gap by: (i) identifying and formally defining three dimensions of coupling; (ii) relating these dimensions to existing communication middleware; and (iii) proposing notational elements for representing coupling configurations. The identified dimensions provide the basis for a classification of middleware which can be used as a selection instrument.

Paper

Presentation slides

Abstract.Dynamic AOP has been identified as a useful technique to implement an auto-adaptive framework. To supplement this policies based upon Event- Condition-Action rules are used to specify when adaptations should be applied to the underlying system. However, for use in auto-adaptive systems it is advantageous if these policies allow certain relationship information to be specified to ensure the system never encounters undesirable interactions and adaptations are applied in a correct manner. This paper highlights the need for these relationships by giving a series of examples followed by a proposed solution to these problems.

Paper

Presentation slides

Presentation slides

Abstract.Increasingly, a number of applications rely on, or can potentially benefit from, analysis and monitoring of data streams. To support processing of streaming data in a grid environment, we have been developing a middleware system called GATES (Grid-based AdapTive Execution on Streams). Our target applications are those involving high volume data streams and requiring distributed processing of data arising from a distributed set of sources. This paper addresses the problem of resource allocation in the GATES system. Though resource discovery and resource allocation have been active topics in grid community, the pipelined processing and real-time constraint required by distributed streaming applications pose new challenges. We present a resource allocation algorithm that is based on minimal spanning trees. We evaluate the algorithm experimentally and demonstrate that it results in configurations that are very close to optimal, and significantly better than most other possible configurations.

Paper

Presentation slides

Abstract.Sensor network nodes exhibit characteristics of both embedded systems and general-purpose systems. They must use little energy and be robust to environmental conditions, while also providing common services that make it easy to write applications. In TinyOS, the current state of the art in sensor node operating systems, reusable components implement common services, but each node runs a single statically-linked system image, making it hard to run multiple applications or incrementally update applications. We present SOS, a new operating system for mote-class sensor nodes that takes a more dynamic point on the design spectrum. SOS consists of dynamically- loaded modules and a common kernel, which implements messaging, dynamic memory, and module loading and unloading, among other services. Modules are not processes: they are scheduled cooperatively and there is no memory protection. Nevertheless, the system protects against common module bugs using techniques such as typed entry points, watchdog timers, and primitive resource garbage collection. Individual modules can be added and removed with minimal system interruption. We describe SOS's design and implementation, discuss tradeoffs, and compare it with TinyOS and with the Mat¡äe virtual machine. Our evaluation shows that despite the dynamic nature of SOS and its higher-level kernel interface, its long term total usage nearly identical to that of systems such as Mate and TinyOS.

Paper

Presentation slides

Abstract.We consider the problem of deploying and managing federated services that run on federated systems spanning multiple collaborative organizations. In particular, we present a peer-to-peer framework targeted to the construction of self-managing services that automatically adjust the number of service components and their placements in response to changes in the system or client loads. Our framework is completely decentralized, depending only on a modest amount of loosely synchronized global state. More specifically, our framework is comprised of a set of per-node monitoring agents and per-service-component management agents that periodically exchange information about the state of the system and of the service with each other using a gossiping protocol. Each management agent then periodically searches for configurations that are better than the current one according to an application model and explicit performance and availability targets. On finding a better configuration, an agent will enact the new configuration after a random delay to avoid possible collisions. We evaluate our framework by studying a prototype UDDI service. We show that while agents act autonomously, the service rapidly reaches a stable and appropriate configuration in response to system dynamics.

Paper

Abstract.Grid computing has been presented as a way of sharing geographically and organizationally distributed resources and of performing successfully distributed computation. To achieve these goals a software layer is necessary to interact with grid environments. Therefore, not only a middleware and its services are needed, but it is also necessary to offer resource management services to hide the underlying complexity of the Grid resources to Grid users. In this paper, we present the design and implementation of an OGSI-compliant Grid resource broker compatible with both GT2 and GT3. It focuses in resource discovery and management, and dynamic policies management for job scheduling and resource selection. The presented resource broker is designed in an extensible and modular way using standard protocols and schemas to become compatible with new middleware versions. We also present experimental results to demonstrate the resource broker behavior.

Paper

Presentation slides

Abstract.It is usually assumed that the implementation of exception handling can be better modularized by the use of aspect-oriented programming (AOP). However, the trade-offs involved in using AOP with this goal are not yet wellunderstood. To the best of our knowledge, no work in the literature has attempted to assess whether AOP really promotes an enhancement in well-understood quality attributes other than separation of concerns, when used for modularizing nontrivial exception handling code. This paper presents a quantitative study of the adequacy of aspects for modularizing exception handling code. The study consisted of refactoring part of a real object-oriented system so that the code responsible for handling exceptions was moved to aspects. We employed a suite of metrics to measure quality attributes of the original and refactored systems, including coupling, cohesion, and conciseness. We found that AOP improved separation of concerns between exception handling code and normal application code. However, contradicting the general intuition, the aspect-oriented version of the system did not present significant gains for any of the four size metrics we employed.

Paper

Presentation slides

Presentation slides

Abstract.Adaptability is one of the goals that applications and middlewareframeworks are trying to achieve. On one hand, the component paradigm is a way of reaching this goal by enforcing the reusability of functionalities involved in a component-based middleware framework. In particular, reflection could be combined with components to improve the adaptability of the structure of their assemblies. On the other hand, the model driven paradigm provides an efficient way to describe an application with enough abstraction to enable its mapping on various execution platforms. The contribution of this paper is a combination of both model and component paradigms to reach more adaptability in middleware, especially in a component-based framework to build transaction services. The framework presented uses models to describe middleware standards and compiles them to components. These components are coupled with a compliant component-based middleware framework. This approach provides adaptability at various levels with some added values.

Paper

Presentation slides

Paper

Presentation slides

Abstract.Design patterns offer flexible solutions to common problems in software development. Recent studies have shown that several design patterns involve crosscutting concerns. Unfortunately, object-oriented (OO) abstractions are often not able to modularize those crosscutting concerns, which in turn decrease the system reusability and maintainability. Hence, it is important verifying whether aspect-oriented approaches support improved modularization of crosscutting concerns relative to design patterns. Ideally, quantitative studies should be performed to compare OO and aspect-oriented implementations of classical patterns with respect to fundamental software engineering attributes, such as coupling and cohesion. This paper presents a quantitative study that compares aspect-based and OO solutions for the 23 Gang-of-Four patterns. We have used stringent software attributes as the assessment criteria. We have found that most aspect-oriented solutions improve separation of pattern-related concerns, although only 4 aspect-oriented implementations have exhibited significant reuse. This paper also discusses the scalability of the analyzed solutions with respect to separation of concerns, and the determination of a predictive model for the modularization of design patterns with aspects.

Paper

Presentation slides

Abstract.

Presentation slides

Abstract.The next generation Grid will demand the Grid middleware to provide flexibility, transparency. and reliability. This implies the appliance of service level agreements to guarantee a negotiated level of quality ofservice. These requirenients also affect the local resoarce management systems providing resourcesfor the Grid. At this a gap between these demands and she features of today S resource management systems becomes apparent. In this paper we present an approach which closes this gap. Introducing the architecture of the Virtual Resource Manage< we highlight its mainfeatares of runtime responsibility, resource virtualization, information hiding, autonomy provision, and smooth integration of existing resource management system installations.

Paper

Presentation slides

Abstract. Wireless sensor networks are composed of large numbers of tiny networked devices that communicate untethered. For large scale networks it is important to be able to dynamically download code into the network. In this paper we present Contiki, a lightweight operating system with support for dynamic loading and replacement of individual programs and services. Contiki is built around an event-driven kernel but provides optional preemptive multithreading that can be applied to individual processes. We show that dynamic loading and unloading is feasible in a resource constrained environment, while keeping the base system lightweight and compact.

Paper

Presentation slides

Presentation slides

Abstract.We propose a meta-framework called Plastik which i) supports the specification and creation of runtime component-framework-based software systems and ii) facilitates and manages the runtime reconfiguration of such sys-tems while ensuring integrity across changes. The meta-framework is funda-mentally an integration of an architecture description language (an extension of ACME/Armani) and a reflective component runtime (OpenCOM). Plastik-generated component frameworks can be dynamically reconfigured either through programmed changes (which are foreseen at design time and specified at the ADL level); or through ad-hoc changes (which are unforeseen at design time but which are nevertheless constrained by invariants specified at the ADL level). We provide in the paper a case study that illustrates the operation and benefits of Plastik.

Paper

Presentation slides

Dynamically Programmable and Reconfigurable Middleware Services

Abstract The increasing software complexity and proliferation of distributed applications for cell phones demand the introduction of middleware services to assist in the development of advanced applications. However,from the user perspective, it is essential that these new phones provide a smooth error-free experience. Despite of the complexity underlying a cell phone, placing a phone call remains a simple task that can be performed by most users regardless of their technical background. Furthermore, cell phones rarely crash (especially compared to PCs) and carriers are able to correct certain problems remotely without user intervention. We advocate for a middleware infrastructure that allows carriers and developers to correct middleware behavior, configure it, and upgrade it, without requiring user intervention and without stopping the execution of applications. We introduce a new technique we refer to as externalization. This technique explicitly externalizes the state, the logic, and the internal component structure of middleware services. As a result, carriers and developers have full control over these middleware services. They can access, inspect, and modify the state, logic, and structure of middleware services at runtime while preserving the execution of existing applications and providing an error-free experience to users. We claim that externalization is the key for the future evolution of cell phones' middleware infrastructure.

presentation slides

Presentation slides

presentation slides

A Multi-Level Meta-Object Protocol for Fault-Tolerance in Complex Architectures

Abstract.The past decade has seen an increasing use of complex computer systems made of third party components to develop mission critical applications. To insure the dependability of those systems in a sound and maintainable manner, technologies are needed to add fault-tolerance mechanisms transparently, while maintaining efficiency, high coverage, and evolvability. In this presentation, we present a generic framework that addresses this problem and can be used within current industrial software. Our proposal is based on a limited set of core concepts inspired from plant biology and meta-object protocols. It provides separation of concerns for the implementation of adaptive fault tolerance strategies, while maintaining a global inter-level perception of the system runtime behavior. We demonstrate its practicality by using it to control the non-determinism of a CORBA/UNIX system.

Paper

Presentation slides

Engineering adaptable mobile systems using SATIN

Abstract. We have recently witnessed a growing interest in adaptive systems, both in research and in practice. These systems adapt in response to new or changing conditions in the environment. The need for adaptation is often found in mobile applications; these applications are typically hosted in resource-constrained environments and may have to dynamically reorganise in response to changes of user needs, to heterogeneity and connectivity challenges, as wel as to changes in the execution context and physical environment. We argue that physically mobile applications benefit from the use of adaptation primitives. We show that a component model that incorporates code mobility primitives assists in building adaptive mobile systems. We present SATIN, a lightweight component model, which represents a mobile system as a set of interoperable local components. The model supports reconfiguration, by offering code migration services. We discuss an implementation of the SATIN middleware, based on the component model and evaluate our work by adapting existing open source software as SATIN components and by building and testing a system that manages the dynamic update of components on mobile hosts.

Paper

Abstract. Next-generation applications based on Web services impose additional requirements on the use of coordination protocols with various optimizations, such as the two-phase commit protocol (2PC). This paper analyses the well-known 2PC optimizations presumed commit and presumed abort, and presents an improved 2PC that is suitable for Web services based applications. More specifically, the protocol allows every individual service provider to choose dynamically the most appropriate presumption for any distributed transaction. The protocol does not introduce extra overhead to the previous 2PC variants in terms of number of messages and log records, and it is easy to understand and realize.

Paper

Presentation slides

Abstract.

JBoss web site

Presentation slides

Abstract.Embedded systems have become commonplace in recent years, and are increasingly being networked. Middleware offers many advantages to the distributed application programmer, yet there exist very few middleware frameworks for the low end of the embedded systems market. In this paper we describe MicroQoSCORBA. It represents a fundamental, bottomup rethinking of what middleware can and should support for resource-constrained devices. This middleware is tailorable, with a fine degree of granularity, to both the device and the application program's constraints. We describe the multiple Quality of Service domains that MicroQoSCORBA supports, and present an evaluation of our working framework.

Presentation slides

Abstract.

Presentation slides

Abstract. Software that cannot evolve is condemned to atrophy: it cannot accommodate the constant revision and renegotiation of its business goals nor intercept the potential of new technology. To accommodate change in software systems we have defined an active software architecture to be: dynamic in that the structure and cardinality of the components and interactions are changeable during execution updatable in that components can be replaced; decomposable in that an executing system may be (partially) stopped and split up into its components and interactions; and reflective in that the specification of components and interactions may be evolved during execution. Here we describe the facilities of the ArchWare architecture description language (ADL) for specifying active architectures. The contribution of the work is the unique combination of concepts including: a PI-calculus based communication and expression language for specifying executable architectures; hyper-code as an underlying representation of system execution that can be used for introspection; a decomposition operator to incrementally break up executing systems; and structural reflection for creating new components and binding them into running systems.

Paper

Presentation slides

Abstract. Middleware becomes increasingly important in building distributed applications. Today, conventional middleware systems are designed, implemented, and packaged prior to their applications. We argue that with this middleware construction paradigm it is often difficult to meet the challenges imposed by application specific customization requirements. We propose to reverse this paradigm by automatically synthesizing middleware structures as the result of reasoning about the distribution needs of the user application of middleware. We term this type of post-postulated middleware Just-in-time middleware (JiM). In this paper, we present our initial design and present an evaluation of the JiM paradigm through Abacus, a CORBA middleware implementation based on the aspect oriented refactoring of an industrial strength object request broker. In addition, we present Arachne, the Abacus synthesizer, which integrates source analysis, feature inference, and implementation synthesis. Our evaluations show that, through automatic synthesis alone, Abacus is able to support diversified application domains with very flexible architectural compositions and versatile resource requirements as compared to conventional pre-postulated approaches.

Paper

Presentation slides

Abstract. In the rapidly developing field of sensor networks, bridging the gap between the applications and the hardware presents a major challenge. Although middleware is one solution,it must be specialized to the qualities of sensor networks,especially energy consumption. The work presented here provides two contributions: a new operational setting for sensor networks and a middleware for easing software development in this setting. The operational setting we target removes the usual assumption of a central collection point for sensor data. Instead the sensors are sparsely distributed in an environment, not necessarily able to communicate among themselves, and a set of clients move through space accessing the data of sensors nearby, yielding a system which naturally provides context relevant information to client applications. We further assume the clients are wirelessly networked and share locally accessed data. This scenario is relevant, for example, when relief workers access the information in their zone and share this information with other workers. Our second contribution, the middleware itself, is an extension of LIME, our earlier work on middleware f r mobile ad hoc networks. The model makes sensor data available through a tuple space interface, providing the illusion of shared memory between applications and sensors. This paper presents both the model and the implementation of our middleware incorporated with the Crossbow Mote sensor platform.

Paper

Presentation slides

Abstract. Widespread use of the Internet enables a new class of software architectures: dynamically formed, task-specific, coalitions of distributed autonomous resources. The resources may be information, calculation, communication, control, or services. Unlike traditional software systems, which are at least nominally under control of the developer, these coalitions are formed from independently managed network- based resources, and the creator of a coalition lacks direct control over the incorporated resources. Reasoning about these architectures will differ significantly from reasoning about traditional architectures because resource coalitions experience higher uncertainty about component behavior and lower connector reliability. The traditional notion of correctness will give way to an applicationrelative notion of sufficient correctness for the intended use, and the traditional a priori means of validating correctness will give way to architectural provisions for reacting to abnormal behavior through software homeostasis.

Paper pdf

Paper pdf

Presentation slides

Abstract. This paper presents a middleware architecture and a generic orchestrating protocol for implementing distributed atomic transactions for large scale dynamic systems in a self-managing manner. In particular, the proposed solution is fully distributed, allows dynamic changes in the environment, and nodes are neither assumed to be aware of the size of the system nor of its entire composition. The architecture includes two modules and three services. The modules are expected to be instantiated and executed among relatively small sets of nodes in the context of a single transaction and, therefore, can be implemented using known classical distributed computing approaches. On the other hand, services are long lived abstractions that may involve all nodes and should be implemented using known peerto- peer techniques. The proposed architecture is also interesting in the sense that it brings together several seemingly distinct research areas, including distributed consensus, group membership, notification services (publish/subscribe), scalable conflict detection (or locking), and scalable persistent storage.

Paper pdf

Presentation slides

Presentation slides pdf

Abstract. Increasingly, a number of applications rely on, or can potentially benefit from, analysis and monitoring of data streams. To support processing of streaming data in a grid environment, we have been developing a middleware system called GATES (Grid-based AdapTive Execution on Streams). Our target applications are those involving high volume data streams and requiring distributed processing of data arising from a distributed set of sources. This paper addresses the problem of resource allocation in the GATES system. Though resource discovery and resource allocation have been active topics in grid community, the pipelined processing and real-time constraint required by distributed streaming applications pose new challenges. We present a resource allocation algorithm that is based on minimal spanning trees. We evaluate the algorithm experimentally and demonstrate that it results in configurations that are very close to optimal, and significantly better than most other possible configurations.

Paper pdf

Presentation slides

Abstract. Grid Computing is the new highly publicized distributed computing paradigm that aims at federating computing resources across large area networks to provide ubiquitous, on-demand computing power. It has recently evolved towards Web-Services, another very popular distributed computing technology that has been proposed as the means to integrate software over the Internet into large scale added-value chains of services. Grid Computing and Web Services are fairly recent technologies, with multiple facets (SOAP, WSDL, WSRF, etc.), involving numerous building blocks (XML, .Net, HTTP, web servers, J2EE, etc.). It is sometimes difficult to understand how all the different components relate to each other, and how mature these technologies are. In this talk we will report on our attempt to better understand the java core of the Globus platform, a reference implementation of the current grid computing standards. In particular, we will present our efforts in tracking down the causes for amazingly bad performance of the platform. As we had very little knowledge of Globus, which is a large and highly complex piece of software, we had to develop pragmatic approaches to speed up our understanding with appropriate reverse engineering techniques. In particular, we will present the dynamic layering technique we have used to infer the structure of Globus, and how we used this technique to visualize the raw profiling results we obtained and better understand how each component of the underlying Java platform contributed to the system's behavior. This is an ongoing, very practical work, that we think offers interesting insights into modern middleware developments. It may also have us wonder how long known problems might mix with new ones, and to which extend current abstraction and reuse techniques may be useful for rapid software development.

Presentation slides