[1] Elke Pulvermüller, Andreas Speck, Sven Feja, and Sören Witt. Component Composition Validation. In Proceedings of the 10th International Conference on Software Methodologies, Tools and Techniques (SoMeT_2011), volume 231, pages 5 - 19. IOS Press, September 2011.
bib ]
Components have been introduced in order to support software reuse. Components are reusable building blocks for larger systems consisting of units (code pieces) and their construction plan. Technologies like COM+, .Net, CORBA JavaBeans and EJBs (or web services which may be considered as web-based components) have been developed to support the component concept. However, components still have the problem of both unavailable and unreliable documentation of their properties. Moreover, a lack of validation support concerning the components' or composed systems' behavior may be observed. In other words, there is a lot of knowledge about how to combine components technically but less experience to validate the interactions between the components. In this paper we introduce an approach to model components and their compositions as a base for automatic validation techniques to check the components composition and their interactions. The validation aims at deriving the component models from the implementation which allows comparing the specifications with the real components code.

[2] Padma Iyenghar, Elke Pulvermüller, and Clemens Westerkamp. Towards Model-Based Test Automation for Embedded Systems using UML and UTP. In Proceedings of the 16th IEEE International Conference on Emerging Technologies Factory Automation (ETFA), pages 1 - 9. IEEE Computer Society, September 2011.
bib | www ]
Model-based methodologies such as the Model-Driven Development (MDD) and Model-Based Testing (MBT) are being explored, in the recent decade, for automation in embedded software engineering projects. In this context, the target of this paper is to demonstrate the adoption and applicability of the Unified Modeling Language (UML) and the UML Testing Profile (UTP) for deploying MBT in Resource-Constrained (RC)-Real-Time Embedded Systems (RTES). Though the UTP standard has been introduced several years ago, concrete approaches or tool support for generating the test artifacts based on the UTP is currently unavailable. This paper aims to close this gap and discusses a concise set of UTP artifacts in the context of MBT for RC-RTES. A detailed discussion on the test artifacts generation algorithm demonstrating the applicability of our approach in a real-life RC-RTES example is presented.

[3] Padma Iyenghar, Elke Pulvermüller, Clemens Westerkamp, and Jürgen Wübbelmann. Integrated Model-based Approach and Test Framework for Embedded Systems. In Proceedings of the IEEE International Forum on Specification & Design Languages. Forum for Design Languages (FDL), pages 1 - 8. IEEE Press, September 2011.
bib | www ]
In the recent decade, new automated methodologies such as the Model Driven Development (MDD) and Model-Based Testing (MBT) are under evaluation for embedded systems development and testing. However, most of the currently existing MBT approaches are neither integrated with the software development process nor transferred to real-life embedded software engineering projects. There is also a lack of usage of corresponding modeling languages for the MDD and MBT phases. In this context, this paper discusses the applicability of an integrated model-based approach and test framework which addresses the aforementioned gaps. The approach is evaluated in a spark extinguishing embedded system example based on a real-life embedded software engineering project. A test framework generation algorithm which generates the necessary artifacts for deploying MBT in resource-constrained embedded systems is discussed. A prototype implementation of the proposed approach and illustrative examples are presented.

[4] Marwane El Kharbili, Qin Ma, Pierre Kelsen, and Elke Pulvermüller. Enterprise Regulatory Compliance Modeling using CoReL: An illustrative Example. In Proceedings of the 13th IEEE Conference on Commerce and Enterprise Computing (CEC), pages 185 - 190. IEEE Computer Society Press, September 2011.
bib | www ]
Regulatory compliance management is a critical and challenging task, especially in the context of Business Process Management. It requires a comprehensive framework for dealing with compliance requirements: elicitation, modeling, static and dynamic checking and reporting. We previously defined CoReL, a domain specific language for the domain of compliance decision-making. This paper shows how CoReL can be used to model compliance requirements using an illustrative example. In particular, we show how CoReL's agnosticism of logical formalisms and coverage of enterprise business aspects leverages the task of compliance modeling to the business user level.

[5] Marwane El Kharbili, Qin Ma, Pierre Kelsen, and Elke Pulvermüller. CoReL: Policy-Based and Model-Driven Regulatory Compliance Management. In Proceedings of the 15th IEEE International Enterprise Distributed Object Computing Conference (EDOC), pages 247 - 256. IEEE Computer Society Press, September 2011.
bib | www ]
Regulatory compliance management is now widely recognized as one of the main challenges still to be efficiently dealt with in information systems. In the discipline of business process management in particular, compliance is considered as an important driver of the efficiency, reliability and market value of companies. It consists of ensuring that enterprise systems behave according to some guidance provided in the form of regulations. This paper gives a definition of the research problem of regulatory compliance. We show why we expect a formal policy-based and model-driven approach to provide significant advantages in allowing enterprises to flexibly manage decision-making related to regulatory compliance. For this purpose, we contribute CoReL, a domain-specific modeling language for representing compliance requirements that has a graphical concrete syntax. Informal semantics of CoReL are introduced and its use is illustrated on an example. CoReL allows to leverage business process compliance modeling and checking, enhancing it with regard to, among other dimensions, user-friendliness, genericity, and traceability.

[6] Padma Iyenghar, Clemens Westerkamp, Jürgen Wübbelmann, and Elke Pulvermüller. Design Level Debugging of Timing Behavior in Embedded Systems: Using a Model-based Approach. In Proceedings of the 9th IEEE International Conference on Industrial Informatics (INDIN), pages 889 - 894. IEEE Press, July 2011.
bib | www ]
A robust model-based debugging and testing technique integrated with the Model Driven Development (MDD) approach for memory size constrained, real-time critical embedded target systems is still in its nascent stages. This is especially true for the industry standard MDD-based tools. In addition, a model-based debugging technique or tool chain based on the newly introduced timing diagrams in UML 2.x is not yet available. In this paper, we discuss a model-based, design-level debugging approach with which the timing behavior of embedded targets is visualized with the aid of UML timing diagrams on the host side, in real-time. The proposed approach is suitable for memory size constrained, real-time embedded target systems as the overhead introduced is negligible, constant and known beforehand. Hence, the end-user has the option to include the overhead in the system design phase, thereby making use of a model-based debug solution and at the same time adhering to temporal constraints. A prototype implementation of the proposed approach is discussed and an illustrative example is presented.

[7] Andreas Speck, Sören Witt, Sven Feja, Aneta Lotyzc, and Elke Pulvermüller. Framework for Business Process Verification. In Proceedings of the 14th International Conference on Business Information Systems (BIS 2011), volume 87, Part 2, pages 50 - 61. Springer LNBIP, June 2011.
bib | www ]
There are numerous concepts and tools for modeling business processes and several academic approaches to verify business processes. However, most modeling tools don’t integrate the checking of the processes. The three-tier architecture of the Business Application Modeler (BAM) provides the graphical representation of business models and rules (presentation layer) as well as integrates a verification mechanism layer with an intermediate transformation layer. The hierarchical architecture allows to extend the checking system with additional features supporting the use of the verifier in an industrial environment of commercial information system development. Examples for such add-ons are the improved graphical rule notation and an enhanced functionality of the verification system supporting the expressiveness in the business modeling domain.

[8] Padma Iyenghar, Clemens Westerkamp, Jürgen Wübbelmann, and Elke Pulvermüller. A Model Based Approach for Debugging Embedded Systems in Real-Time. In Proceedings of the 10th International ACM Conference on Embedded Software (EMSOFT), pages 69 - 78, New York, NY, USA, October 2010. ACM.
bib | www ]
Model driven design and development of real-time embedded systems has been gaining a lot of attention in the recent past. It is imperative for a hard real-time embedded system to execute and respond to sequenced exchanges of messages under critical temporal constraints. The UML provides artifacts such as communication diagrams, sequence diagrams and timing diagrams to aid software engineers to model and precisely document such a schedule of interactions or state changes at the design level. While modeling at the design level is interesting on one hand, it is also significant to understand the run time behavior of the embedded software. A step forward in this direction is to provide a real-time representation of the target system behavior on the host side. We propose an approach to realize a target debugger on the host side with a monitor solution in the target side. With the back annotated information from the target, a visual representation of the system behavior in real-time is now available at the design level. This way, a debugging solution in real-time is provided, thus taking a step forward towards understanding the behavior of the embedded software at hand. We illustrate our proposed approach with a prototype and examples.

[9] Padma Iyenghar, Clemens Westerkamp, Jürgen Wübbelmann, and Elke Pulvermüller. An Architecture for Deploying Model Based Testing in Embedded Systems. In Proceedings of the IEEE International Forum on Specification & Design Languages. Forum for Design Languages (FDL), pages 1 - 6. IEEE Press, September 2010.
bib | www ]
There have been several model based approaches used in the recent past for alleviating complexity in design, development and test case generation for real-time embedded software systems. However, deploying/executing these test cases in the embedded target without affecting the real-time behavior of the system still remains a challenging and unanswered question. To address this, we propose a novel architecture to perform an integrated model based testing for embedded systems. We introduce a holistic model based design, development and testing approach with the aid of a monitor and target debugger solution for real-time embedded systems. Our proposed approach eliminates the need for dynamic source code instrumentation inserted into the target to execute the software test routines. This will result in preserving the real-time behavior which is a boon especially for real-time critical and code size constrained embedded systems. We illustrate our proposed approach with a prototype and an example.

[10] Elke Pulvermüller, Andreas Speck, Sven Feja, and Sören Witt. Process Model Validation - Transforming Process Models to Extended Checking Models. In Proceedings of the 5th International Conference on Evaluation of Novel Approaches to Software Engineering (ENASE), pages 214 - 220. INSTICC and Springer Communications in Computer and Information Science (CCIS), July 2010.
bib ]
Process and workflow models are typical means to describe the dynamic activities of a system. Therefore, it is of high interest to validate these models. Many kinds of (business) rules, best practices, patterns, legal regulations may serve as specifications which the models have to fulfill. An already established technique to validate models of dynamic activities is model checking. In model checking the requirements are expressed by temporal logic. Temporal logic allows describing temporal dependencies. The models to be verified by model checkers are automata. In this context the question is how to transform process or workflow models into automata and how to specify the temporal logic in the way that the semantic of the process models is considered sufficiently. In our paper we present three approaches to transform process models to checkable automata. We use the example of ARIS Event-driven Process Chains. In particular, the third approach introduces specializers enabling semantic-rich requirement specifications. This reduces the gap between process models (consisting of different model element types) and verification models.

[11] Andreas Speck and Elke Pulvermüller. Verification Support for Generative System Development. In Proceedings of the 8th International Conference on New Trends in Software Methodologies, Tools and Techniques (SoMeT_09), volume 199, pages 131 - 147. IOS Press, September 2009.
bib | www ]
The automated generation of systems (e.g. within model-driven development) is a considerable improvement of the software development. However, besides the automated generation the verification of these generated systems needs to be supported, too. By applying generators it is not necessarily guaranteed that the generation outcome is correct. Typical problems may be, firstly, the use of a wrong operator resulting in an erroneous generation (static aspects of the generation). Secondly, the interactions between the different generated system assets (snippets) of the generated outcome might be incorrect, since the snippets might be connected in a wrong sequence (dynamic aspect of the generation). Therefore, the hierarchical dependencies of the snippets which are the input of the generator as well as the dynamic behavior resulting from the generation have to be checked. We describe the hierarchy in a version model based on Boolean logic. The temporal behavior may be checked by model checkers. For the generation we apply our XOpT concept which provides domain-specific transformation operators on the XML representation. Besides the principles of the static and dynamic elements of our checking approach the paper presents the way to map program assets to the version model and to finite state automata which are the prerequisite for the checking. Though the proposed checking is presented at the code level the approach may be applied to different kinds of assets, e.g. also on the model level.

[12] Elke Pulvermüller. Reducing the Gap between Verification Models and Software Development Models. In Proceedings of the 8th International Conference on New Trends in Software Methodologies, Tools and Techniques (SoMeT_09), volume 199, pages 297 - 313. IOS Press, September 2009.
bib | www ]
A variety of models and notations are available to support the software developers. Such models help to gather requirements and to build a system implementing these requirements. However, it is often neglected to verify that the requirements are actually fulfilled in the design and implementation. The increasing demand for compliancy to requirements (e.g. due to laws) together with the increasing system complexity re-attracts notice to automatic verification technologies for that purpose. The low user-friendliness and, thus, the low applicability of the verification technologies often prevents their employment. In this paper we aim at closing the gap between software development models with their rich notation and semantics (e.g. Event Process Chains, EPCs) on the one hand and verification-oriented models (typically just simple structures like finite state automata) on the other hand. This is approached by extending the verification model in a controlled manner towards more semantics resulting in our extended Kripke structure. To profit from such a semantic extension we, in addition, extend the temporal logic language CTL. Our new temporal logic language allows to express the expected requirements more precisely.

[13] Marwane El Kharbili and Elke Pulvermüller. A Semantic Framework for Compliance Management in Business Process Management. In Proceedings of the 2nd International Conference on Business Process and Service Computing (BPSC'09) as Part of Software, Agents and Services for Business, Research, and E-Sciences (SABRE), pages 60 - 80, March 2009.
bib ]
In process-centric enterprises, business processes (BPs) are at the center of value-creating activities. Governing enterprise BPs requires the ability to control and guide BP behavior. Ensuring compliance of processes to legal regulations and strategy directives becomes a critical requirement. Implementing business process compliance makes means for modeling and enforcing compliance measures necessary. In this work, we motivate the need for automation and semantic consistency in compliance management and defend the use of policies for this purpose. We then propose a policy-based framework for business process compliance management and further detail its architecture as part of the SUPER research project on semantic business process management (SBPM). Finally, we introduce the ontology stack we propose for compliance modeling and conclude by an investigation of the main challenges ahead in order to provide an implementation of the proposed framework. This work seeks to lay down the fundaments of a comprehensive architecture for semantic compliance modeling and enforcement in the context of BPM.

[14] Daniel Fötsch and Elke Pulvermüller. Constructing higher-level Transformation Languages based on XML. In Proceedings of the 6th International Conference on New Trends in Software Methodologies, Tools and Techniques (SoMeT 07), volume 161, pages 269 - 284. IOS Press, November 2007.
bib ]
Based on the experience in the e-commerce domain, we propose a concept for the development of higher-level transformation languages. Transformation is a key factor in this domain as the market requires a fast reaction to frequent changes in the interfaces and exchange data. Moreover, a typical e-commerce system is divided into different services which are offered and hosted by different vendors which results in a complex integration problem. Our proposed solution is based on the operator hierarchy concept which allows to define transformation operator hierarchies containing different levels of transformation operators. The concrete realization of such a higher-level transformation language construction is demonstrated by an application of the XML operator hierarchy concept to the transformation language XSLT. XSLT serves as an example which is employed to provide the elementary transformation operators. On top of these elementary operators the layered concept allows the definition of new higher-level operators, e. g. domain-independent and domain-specific ones. The construction of the higher-level language XML2DSV is presented, for instance. This is a stand-alone domain-specific transformation language, which creates delimeter-separated values (DSV) files from XML documents, on the base of XSLT.

[15] Elke Pulvermüller, André Ludwig, Roman Belter, Dominik Zyskowski, Ulrich Heindl, and Xuan Thang Nguyen. A Capability Oriented Management Approach for Business Integration. In Proceedings of the 1st International Conference on Business Process and Service Computing (BPSC'07) as Part of Software, Agents and Services for Business, Research, and E-Sciences (SABRE), September 2007.
bib ]
Service oriented architecture (SOA) has emerged as a popular software paradigm for integrating distributed applications. Services are generally regarded as interoperable building blocks for constructing, integrating, and merging applications. However, existing SOA based solutions often focus on solving technical integration problems while neglecting business-level capabilities which are most important for organizations. In this paper, we introduce the notion of capabilities as an important concept for business management. We identify major shortcomings of the existing service based solutions and outline a novel approach for capability oriented configuration and management that can react to the dynamically changing nature of business integration environments.

[16] Daniel Fötsch and Elke Pulvermüller. Applying the Operator Hierarchy Concept to XSLT. In Proceedings XML-Tage in Berlin 2007 (XMLT 07), pages 51 - 62. XML-clearinghouse, September 2007.
bib ]
XML has a broad acceptance as a standardized flexible text format for storing and exchanging of a wide variety of data. As a result, transformations between XML documents become more and more important. A scalable transformation approach requires the possibility to express transformation definitions in terms of domain-specific constructs. Only in this case, the domain knowledge is explicitly available and not hidden into, e. g., Java or XSLT code. Consequently, domain experts can easier understand, validate, and modify the transformation themselves. This paper presents a generic composition concept that relies on transformation itself. It allows the definition of transformation operator hierarchies containing different levels of transformation operators, e. g. domain-independent and domain-specific ones. We apply the proposed operator hierarchy concept to XSLT, and build new complex operators on top of existing ones which are specifically suited to develop transformations in a certain application area.

[17] Elke Pulvermüller and Andreas Speck. XOpT - XML-Based Composition Concept. In Proceedings of the 3rd International Conference on New Software Methodologies, Tools, and Techniques (SoMeT 04), Volume 111, pages 249 - 262. IOS Press, September 2004.
bib ]
System development is usually processed by applying different models both on the same and different levels of abstraction. This supports the stepwise refinement, the dealing with the inherent complexity and allows the tailored documentation and specification of the different aspects of the system. This paper presents the XOpT approach to support the composition and adaptation step. It provides a framework based on XML, DOM and XPath technology with an hierarchy of transformation operators. These are either generic or specifically suited for (and thus also restricted to) a certain domain. New operators may be added on top of existing ones on demand. XOpT is a unification of composition and weaving techniques as it operates on the standardized XML data format. Furthermore, this language independence allows the manipulations on different abstraction levels in parallel preserving model consistency. The concepts have been applied to an e-commerce system based on ARIS which also serves as example in this paper.

[18] Andreas Speck, Elke Pulvermüller, and Matthias Clauß. Versioning in Software Modeling. In Proceedings of the 6th International Conference on Integrated Design and Process Technology (IDPT 2002). Society for Design and Process Science (SDPS), June 2002.
bib ]
Since the first discussion about the software crisis in 1968 many concepts in order to improve the software development and reuse have been introduced. Some of them like frameworks or components aim on the reuse of code others capture experiences with system architecture, design or coding recommendations. This paper focuses on a way to express the reuse of pieces of software and design reasoning. We apply versions in order to describe sets of features we want to have in a system. Conditions are used to formulate these requirements. Then these conditions are integrated into UML models using the existing mechanisms for extensions. This enables a tight integration of versions and modeling constructs and enhances integrity of models. The use of version is demonstrated by an example from the eCommerce domain. This paper also discusses the effects of the integration of version into UML models.

[19] Elke Pulvermüller, Andreas Speck, and James O. Coplien. A Version Model for Aspect Dependency Management. In Proceedings of the 3rd International Symposium on Generative and Component-Based Software Engineering (GCSE) 2001, volume 2186 of Lecture Notes in Computer Science (LNCS), pages 70 -79. Springer, September 2001.
bib ]
With Aspect-Oriented Programming (AOP) a new type of system units is introduced (aspects). One observed characteristic of AOP is that it results in a large number of additional (coarse-grained to fine-grained) system units (aspects) ready to be composed to the final application. With this growing number of system units the dependencies between them become vast and tangling. This results in the necessity of an improved management of the dependencies between these system units. Our paper investigates this problem, proposes a more general model (version model) to capture different facettes of AOP as well as a partial solution towards unit consistency based on versions.

[20] Awais Rashid, Ruzanna Chitchyan, Andreas Speck, and Elke Pulvermüller. EProMS: An E-Commerce based Process Model for Cooperative Software Development in Small Organisations. In Proceedings of the 2nd International Conference on ElectronicCommerce and Web Technologies (EC-WEB 2001), volume 2115 of Lecture Notes in Computer Science (LNCS), pages 39 - 48. Springer, September 2001.
bib ]
Existing process models for software development are too resource intensive for small organisations. This paper proposes EProMS, an e-commerce based process model which takes into account the limited resources of these organisations. It distributes the software development process over several small organisations. These organisations, then, co-operate through an e-commerce layer to produce market-driven software. On competitive markets the distribution allows organisations in the co-operation to specialise in specific aspects of software development. This helps them to reduce costs and time to market and achieve a high degree of users' satisfaction.

[21] Andreas Speck and Elke Pulvermüller. Versioning in Software Engineering. In Proceedings of the 27th Annual Conference of the IEEE Industrial Electronics Society IES (IECON'01), pages 1856 - 1861. IEEE Computer Society Press, 2001.
bib ]
Software reuse usually has the drawback that the documentation of the software units is rather incomplete and inaccurate. It is hard to verify that such a component offers both the required and promised features / behavior. In this paper we present an approach to describe the components' features and dynamic behavior as finite state machines which may automatically be verified by model checkers. The model of the component is derived from the code providing consistency between documentation and implementation. The models of several components may be combined to larger systems (according to the composition of the real code components). To deal with the state explosion problem, our approach allows to "abstract" of the complete component's behavior as needed (compression and inflation). In the beginning of a reuse-based system development the requirements are modeled similarly as the reusable code assets. Model checking can be employed to determine the consistency between these requirement models and the models of the complete systems, subsystems or components. The tool support eases incremental system development and rapid prototyping / checking. The impact of a composed component (the component's model respectively) may be instantly examined (against the modeled requirements).

[22] Herbert Klaeren, Elke Pulvermüller, Awais Rashid, and Andreas Speck. Aspect Composition applying the Design by Contract Principle. In Proceedings of the Second International Symposium on Generative and Component-Based Software Engineering (GCSE) / Proceedings of the NetObjectDays 2000, volume 2177 of Lecture Notes in Computer Science (LNCS), pages 453 - 463, October 2000.
bib | .pdf ]
The composition of software units has been one of the main research topics in computer science. This paper addresses the composition validation problem evolving in this context. It focuses on the composition for a certain kind of units called aspects. Aspects are a new concept which is introduced by aspect-oriented programming aiming at a better separation of concerns. Cross-cutting code is captured and localised in these aspects. Some of the cross-cutting features which are expressed in aspects cannot be woven with other features into the same application since two features could be mutually exclusive. With a growing number of aspects, manual control of these dependencies becomes error-prone or even impossible. We show how assertions can be useful in this respect to support the software developer.

[23] Awais Rashid and Elke Pulvermüller. From Object-Oriented to Aspect-Oriented Databases. In Proceedings of DEXA: 11th International Conference on Database and Expert Systems Applications, volume 1873 of Lecture Notes in Computer Science (LNCS), pages 125 - 134. Springer, September 2000.
bib ]
Over the recent years aspect-oriented programming (AOP) has found increasing interest among researchers in software engineering. Aspects are abstractions which capture and localise cross-cutting concerns. Although persistence has been considered as an aspect of a system aspects in the persistence domain in general and in databases in particular have been largely ignored. This paper brings the notion of aspects to object-oriented databases. Some cross-cutting concerns are identified and addressed using aspects. An aspect-oriented extension of an OODB is discussed and various open issues pointed out.

[24] Elke Pulvermüller, Andreas Speck, and Awais Rashid. Implementing collaboration-based Designs using Aspect-Oriented Programming. In Proceedings of TOOLS-USA 2000, Technology of Object-Oriented Languages and Systems, 34th Int'l Conference and Exhibition, pages 95 - 104. IEEE Computer Society Press, July/August 2000.
bib ]
The collaboration-based approach is a powerful means to develop modularised systems by stepwise refinement. In this paper we introduce a new approach to realise a collaboration-based design. Our approach is based on the well-known observation that the knowledge about inter-object collaborations cannot be localised within objects but cross-cuts many objects. Such cross-cutting concerns are effectively addressed by applying the separation of concerns principle. We have, therefore, employed Aspect-Oriented Programming (AOP) to build collaboration-based designs. In the paper we illustrate and discuss our aspect-oriented approach both for the horizontal (i.e. the collaborations) and vertical (i.e. the refinements) dimensions. Although the example implementations are based on AspectJ0.4beta7 from Xerox PARC, the approach is generic enough to be implemented using other AOP techniques.

[25] Awais Rashid, Pete Sawyer, and Elke Pulvermüller. A Flexible Approach for Instance Adaptation during Class Versioning. In Proceedings of OODB: Symposium on Objects and Databases (co-hosted with ECOOP 2000), volume 1944 of Lecture Notes in Computer Science (LNCS), pages 101 - 113. Springer, June 2000.
bib ]
One of the consequences of evolution can be the inability to access objects created using the older schema definition under the new definition and vice versa. Instance adaptation is the conversion of objects to a compatible definition or making objects exhibit a compatible interface. Existing evolution approaches are committed to a particular instance adaptation strategy. This is because changes to the instance adaptation strategy or an attempt to adopt an entirely different strategy would be very costly. This paper proposes a flexible instance adaptation approach for systems employing class versioning to manage evolution. Flexibility is achieved by encapsulating the instance adaptation code in aspects - abstractions introduced by aspect-oriented programming to localise cross-cutting concerns. This makes it possible to make cost-effective changes to the instance adaptation strategy. The flexibility of the approach is demonstrated by using two instance adaptation strategies: error handlers and update/backdate methods.

[26] Elke Pulvermüller, Herbert Klaeren, and Andreas Speck. Aspects in Distributed Environments. In K. Czarnecki and U. W. Eisenecker, editors, Proceedings of the First International Symposium on Generative and Component-Based Software Engineering (GCSE), volume 1799 of Lecture Notes in Computer Science (LNCS), pages 37 - 48. Springer, September 1999.
bib ]
We illustrate how to combine CORBA as a distributed system with aspect-oriented programming (AOP) and the resulting positive impacts. In particular, we focus on the question how AOP can be applied to a CORBA application aiming at a better separation of concerns. The paper shows with implementation examples a practical way to package the distribution issues of a CORBA application into separated aspects (with AspectJ). This supports the distributed application design and leads to increased flexiblity.