Michael Kircher

Pattern Oriented Software Architecture: Patterns for Resource Management

This tutorial uses design patterns to present techniques for implementing effective and efficient resource management in a system. The tutorial is based on the third volume of the POSA (pattern-oriented software architecture) series. The tutorial presents a thorough introduction to resource management along with two case studies in which the patterns are applied to the domains of ad hoc networking and mobile radio networks. The presented patterns are independent of any implementation technique, such as .NET, Java or C++, even though the examples are given in Java and C++. The patterns are grouped by different areas of resource management and address the complete lifecycle of resources: acquisition, management, and release.

The Design and Performance of a Scalable ORB Architecture for CORBA Asynchronous Messaging

Historically, method-oriented middleware, such as Sun RPC, DCE, Java RMI, COM, and CORBA, has provided synchronous method invocation (SMI) models to applications. Although SMI works well for conventional client/server applications, it is not well-suited for highperformance or real-time applications due to its lack of scalability. To address this problem, the OMG has recently standardized an asynchronous method invocation (AMI) model for CORBA. AMI provides CORBA with many of the capabilities associated traditionally with messageoriented middleware, without incurring the key drawbacks of messageoriented middleware.

Managing crosscutting concerns during software evolution tasks: an inquisitive study

Code is modularized, for many reasons, including making it easier to understand, change, and verify. Aspect-oriented programming approaches extend the kind of code that can be modularized, enabling the modularization of crosscutting code. We conducted an inquisitive study to better understand the kinds of crosscutting code that software developers encounter and to better understand how the developers manage this code. We tracked eight participants: four from industry and four from academia. Each participant was currently evolving a non-trivial software system. We interviewed these participants three times about crosscutting concerns they had encountered and the strategies they used to deal with the concerns. We found that crosscutting concerns tended to emerge as obstacles that the developer had to consider to make the desired change. The strategy used by the developer to manage the concern depended on the form of the obstacle code. The results of this study provide empirical evidence to support the problems identified by the aspect-oriented programming community, and provide a basis on which to further assess aspect-oriented programming.

Applying reflective middleware techniques to optimize a QoS-enabled CORBA component model implementation

Although existing CORBA specifications, such as Real-time CORBA and CORBA Messaging, address many end-to-end quality of service (QoS) properties, they do not define strategies for configuring these properties into applications flexibly, transparently, and adaptively. Therefore, application developers must make these configuration decisions manually and explicitly which is tedious, error-prone, and often suboptimal. Although the recently adopted CORBA Component Model (CCM) does define a standard configuration framework for packaging and deploying software components, conventional CCM implementations focus on functionality rather than adaptive quality of service, which makes them unsuitable for next generation applications with demanding QoS requirements. The paper presents three contributions to the study of middleware for QoS-enabled component based applications. It outlines reflective middleware techniques designed to adaptively: (1) select optimal communication mechanisms; (2) manage QoS properties of CORBA components in their containers; and (3) (re)configure selected component executors dynamically. Based on our ongoing research on CORBA and the CCM, we believe the application of reflective techniques to component middleware will provide a dynamically adaptive and (re)configurable framework for COTS software that is well-suited for the QoS demands of next generation applications.

Adaptive and Reflective Middleware for QoS-Enabled CCM Applications

Existing middleware specifications, such as Real-Time CORBA and CORBA Messaging, address many quality-of-service (QoS) properties by defining policies that control connection multiplexing, request priority, queuing order, routing, and dependability. They do not, however, define strategies for configuring these QoS properties into applications flexibly, transparently, and adaptively. Application developers must therefore make these configuration decisions manually. This process is tedious and error-prone, and suboptimal for complex distributed realtime and embedded (DRE) systems. Although the recently adopted CORBA Component Model (CCM) defines a standard configuration framework for packaging and deployingsoftware components, conventional CCM implementations focus on functionality rather than adaptive QoS, which makes the CCM currently unsuitable for DRE applications withdemanding QoS requirements.

Design and Implementation of an Asynchronous Invocation Framework for Web Services

Asynchronous invocations are an important functionality in the context of distributed object frameworks, because in many situations clients should not block during remote invocations. There should be a loose coupling between clients and remote services. Popular web service frameworks, such as Apache Axis, offer only synchronous invocations (over HTTP). An alternative are messaging protocols but these implement a different communication paradigm. When client asynchrony is not supported, client developers have to build asynchronous invocations on top of the synchronous invocation facility. But this is tedious, error-prone, and might result in different remote invocation styles used within the same application. In this paper we build a framework using patterns for asynchronous invocation of web services. The framework design is based on the asynchrony patterns and other patterns from the same pattern language.

Pattern-Based Design of an Asynchronous Invocation Framework for Web Services

Asynchronous invocations are needed in the context of distributed object frameworks to prevent clients from blocking during remote invocations. Popular Web service frameworks offer only synchronous invocations (over HTTP). An alternative is messaging protocols but these implement a different communication paradigm. When client asynchrony is not supported, client developers have to build asynchronous invocations on top of the synchronous invocation facility. But this is tedious, error-prone, and might result in different remote invocation styles used within the same application. We present a number of patterns for asynchronous invocations and explain how these patterns can be used to build asynchronous invocation facilities for Web service frameworks. We exemplify this approach by explaining the design and implementation of an asynchronous invocation framework for Apache Axis.

Transitioning to a software product family approach - challenges and best practices

This paper explains the challenges we experienced when introducing a software product family approach in Siemens business groups. Our vision is a complete and easily accessible cookbook with advice on how to start such an approach. In a first attempt, we identified a collection of more or less successful best practices. On the suggestions and the open questions we are going to present in this paper, we search validation by practitioners in the field.

Model driven software development in the context of embedded component infrastructures

In this chapter we motivate the need for an infrastructure platform for embedded software, supporting the development of reusable systems. Our solution is based on a component infrastructure that is implemented using model-driven software development (MDSD) techniques. This approach allows us to achieve the goal of re-usability while still providing an efficient system, tailored for the specific embedded hardware and operating system. This chapter explains the principles of our approach and introduces model-driven software development. It illustrates the concepts by presenting an example of how to model and specify the embedded application (a simple weather station), and how to generate supporting component middleware infrastructure from these models.

Domain specific feature modeling for software product lines

This paper summarizes our experience with introducing feature modeling into a product line for imaging and therapy systems in the Siemens Healthcare Sector. Determining and negotiating the scope in a product line that spans several business units with their own economic goals is challenging. Feature modeling offers a good way to do variability/commonality analysis for complex product lines. A precondition for feature modeling is the identification of all features supporting the product line. To identify these features, we developed a method for systematically deriving a feature model top down based on domain know-how. We call this method domain specific feature modeling. As the primary artifact to describe the problem space, a domain specific feature model additionally improves the requirement understanding for all stakeholders by considerably improving the scoping, traceability, testing, efficiency and transparency of planning activities and making the development efforts easier to estimate. In this paper, we share our experience with domain specific feature modeling in a large platform project and describe the lessons learned. We describe our general approach that can also be used for other domains.