author = {Pulverm{\"u}ller, Elke and Speck, Andreas 
                  and Feja, Sven and Witt, S{\"o}ren},
  title = {{Component Composition Validation.}},
  booktitle = {Proceedings of the 10th International Conference on 
                  Software Methodologies, Tools and Techniques (SoMeT\_2011)},
  publisher = {IOS Press},
  volume = {231},
  month = {September},
  year = {2011},
  pages = {5 -- 19},
  location = {St. Petersburg, Russia},
  mytype = {CONFERENCE},
  abstract = {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.},
  language = {English}
  author = {Iyenghar, Padma and Pulverm{\"u}ller, Elke and Westerkamp, Clemens},
  title = {{Towards Model-Based Test Automation for Embedded Systems using UML and UTP.}},
  booktitle = {Proceedings of the 16th IEEE International Conference on 
               Emerging Technologies Factory Automation (ETFA)},
  publisher = {IEEE Computer Society},
  month = {September},
  year = {2011},
  pages = {1 -- 9},
  location = {Toulouse, France},
  mytype = {CONFERENCE},
  abstract = {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.},
  language = {English},
  url_home = {http://dx.doi.org/10.1109/ETFA.2011.6058982}
  author = {Iyenghar, Padma and Pulverm{\"u}ller, Elke 
                  and Westerkamp, Clemens and W{\"u}bbelmann, J{\"u}rgen},
  title = {{Integrated Model-based Approach and Test Framework for 
                   Embedded Systems.}},
  booktitle = {Proceedings of the IEEE International Forum on 
                  Specification \& Design Languages. Forum for Design Languages (FDL)},
  publisher = {IEEE Press},
  month = {September},
  year = {2011},
  pages = {1 -- 8},
  location = {Oldenburg, Germany},
  mytype = {CONFERENCE},
  abstract = {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.},
  language = {English},
  url_home = {http://ieeexplore.ieee.org/stamp/stamp.jsp?tp=&arnumber=6069477&isnumber=6069466}
  author = {El~Kharbili, Marwane and Ma, Qin and Kelsen, Pierre 
                and Pulverm{\"u}ller, Elke},
  title = {{Enterprise Regulatory Compliance Modeling using CoReL: 
                 An illustrative Example.}},
  booktitle = {Proceedings of the 13th IEEE Conference on Commerce and 
                Enterprise Computing (CEC)},
  editor = {},
  series = {},
  pages = {185 -- 190},
  month = {September},
  year = {2011},
  publisher = {IEEE Computer Society Press},
  location = {Luxembourg, Luxembourg},
  mytype = {CONFERENCE},
  abstract = {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.},
  language = {English},
  url_home = {http://dx.doi.org/10.1109/CEC.2011.39}
  author = {El~Kharbili, Marwane and Ma, Qin and Kelsen, Pierre 
                and Pulverm{\"u}ller, Elke},
  title = {{CoReL: Policy-Based and Model-Driven Regulatory Compliance Management.}},
  booktitle = {Proceedings of the 15th IEEE International 
                Enterprise Distributed Object Computing Conference (EDOC)},
  editor = {},
  series = {},
  pages = {247 -- 256},
  month = {September},
  year = {2011},
  publisher = {IEEE Computer Society Press},
  location = {Helsinki, Finland },
  mytype = {CONFERENCE},
  abstract = {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.},
  language = {English},
  url_home = {http://dx.doi.org/10.1109/EDOC.2011.23}
  author = {Iyenghar, Padma and Westerkamp, Clemens 
                  and W{\"u}bbelmann, J{\"u}rgen and Pulverm{\"u}ller, Elke},
  title = {{Design Level Debugging of Timing Behavior in Embedded Systems: 
                   Using a Model-based Approach.}},
  booktitle = {Proceedings of the 9th IEEE International Conference on 
                  Industrial Informatics (INDIN)},
  publisher = {IEEE Press},
  month = {July},
  year = {2011},
  pages = {889 -- 894},
  location = {Lisbon, Portugal},
  mytype = {CONFERENCE},
  abstract = {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 
  language = {English},
  url_home = {http://dx.doi.org/10.1109/INDIN.2011.6035011}
  author = {Speck, Andreas and Witt, S{\"o}ren and Feja, Sven 
                  and Lotyzc, Aneta and Pulverm{\"u}ller, Elke},
  title = {{Framework for Business Process Verification.}},
  booktitle = {Proceedings of the 14th International Conference on 
                  Business Information Systems (BIS 2011)},
  publisher = {Springer LNBIP},
  volume = {87, Part 2},
  month = {June},
  year = {2011},
  pages = {50 -- 61},
  location = {Poznan, Poland},
  mytype = {CONFERENCE},
  abstract = {There are numerous concepts and tools for modeling 
business processes and several academic approaches to verify business 
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.},
  language = {English},
  url_home = {http://dx.doi.org/10.1007/978-3-642-21863-7_5}
  author = {Iyenghar, Padma and Westerkamp, Clemens and 
            W{\"u}bbelmann, J{\"u}rgen and Pulverm{\"u}ller, Elke},
  title = {{A Model Based Approach for Debugging Embedded Systems in Real-Time.}},
  booktitle = {Proceedings of the 10th International ACM Conference 
                  on Embedded Software (EMSOFT)},
  publisher = {ACM},
  address = {New York, NY, USA},
  volume = {},
  month = {October},
  year = {2010},
  pages = {69 -- 78},
  location = {Scottsdale, Arizona, USA},
  mytype = {CONFERENCE},
  abstract = {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.},
  language = {English},
  url_home = {http://dx.doi.org/10.1145/1879021.1879031}
  author = {Iyenghar, Padma and Westerkamp, Clemens and 
            W{\"u}bbelmann, J{\"u}rgen and Pulverm{\"u}ller, Elke},
  title = {{An Architecture for Deploying Model Based Testing in Embedded Systems.}},
  booktitle = {Proceedings of the IEEE International Forum on
                  Specification \& Design Languages. Forum for Design Languages (FDL)},
  publisher = {IEEE Press},
  month = {September},
  year = {2010},
  pages = {1 -- 6},
  location = {Southampton, United Kingdom},
  mytype = {CONFERENCE},
  abstract = {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.},
  language = {English},
  url_home = {http://ieeexplore.ieee.org/stamp/stamp.jsp?tp=&arnumber=5775133&isnumber=5774244}
  author = {Pulverm{\"u}ller, Elke and Speck, Andreas and Feja, Sven and Witt, S{\"o}ren},
  title = {{Process Model Validation - Transforming Process Models to Extended Checking Models.}},
  booktitle = {Proceedings of the 5th International Conference on Evaluation
        of Novel Approaches to Software Engineering (ENASE)},
  publisher = {INSTICC and Springer Communications in Computer and Information Science (CCIS)},
  volume = {},
  month = {July},
  year = {2010},
  pages = {214 -- 220},
  location = {Athens, Greece},
  mytype = {CONFERENCE},
  abstract = {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.},
  note = {},
  language = {English}
  author = {Speck, Andreas and Pulverm{\"u}ller, Elke},
  title = {{Verification Support for Generative System Development.}},
  booktitle = {Proceedings of the 8th International Conference on 
               New Trends in Software Methodologies, Tools and Techniques (SoMeT\_09)},
  publisher = {IOS Press},
  volume = {199},
  month = {September},
  year = {2009},
  pages = {131 -- 147},
  location = {Prague, Czech Republic},
  mytype = {CONFERENCE},
  abstract = {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.},
  language = {English},
  url_home = {http://dl.acm.org/citation.cfm?id=1659320}
  author = {Pulverm{\"u}ller, Elke},
  title = {{Reducing the Gap between Verification Models and Software Development Models}.},
  booktitle = {Proceedings of the 8th International Conference on 
               New Trends in Software Methodologies, Tools and Techniques (SoMeT\_09)},
  publisher = {IOS Press},
  volume = {199},
  month = {September},
  year = {2009},
  pages = {297 -- 313},
  location = {Prague, Czech Republic},
  mytype = {CONFERENCE},
  abstract = {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.},
  language = {English},
  url_home = {http://dx.doi.org/10.3233/978-1-60750-049-0-297}
  author = {{El~Kharbili}, Marwane and Pulverm{\"u}ller, Elke},
  title = {{A Semantic Framework for Compliance Management in Business Process Management.}},
  booktitle = {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)},
  location = {Leipzig, Germany},
  month = {March},
  year = {2009},
  pages = {60 -- 80},
  mytype = {CONFERENCE},
  abstract = {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.},
  language = {English}
  author = {F\"{o}tsch, Daniel and Pulverm{\"u}ller, Elke},
  title = {{Constructing higher-level Transformation Languages based on XML}.},
  booktitle = {Proceedings of the 6th International Conference on 
               New Trends in Software Methodologies, Tools and Techniques (SoMeT 07)},
  publisher = {IOS Press},
  volume = {161},
  month = {November},
  year = {2007},
  pages = {269 -- 284},
  location = {Rome, Italy},
  mytype = {CONFERENCE},
  abstract = {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.},
  language = {English}
  author = {Pulverm{\"u}ller, Elke and Ludwig, Andr{\'e} and Belter, Roman and 
            Zyskowski, Dominik and Heindl, Ulrich and Nguyen, Xuan~Thang},
  title = {{A Capability Oriented Management Approach for Business Integration.}},
  booktitle = {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)},
  series = {},
  location = {Leipzig, Germany},
  month = {September},
  year = {2007},
  pages = {},
  publisher = {},
  mytype = {CONFERENCE},
  abstract = {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 
  language = {English}
  author = {F\"{o}tsch, Daniel and Pulverm{\"u}ller, Elke},
  title = {{Applying the Operator Hierarchy Concept to XSLT}.},
  booktitle = {Proceedings XML-Tage in Berlin 2007 (XMLT 07)},
  publisher = {XML-clearinghouse},
  month = {September},
  year = {2007},
  pages = {51 -- 62},
  location = {Berlin, Germany},
  mytype = {CONFERENCE},
  abstract = {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.},
  language = {English}
  author = {Pulverm{\"u}ller, Elke and  Speck, Andreas},
  title = {{XOpT} - {XML}-{B}ased {C}omposition {C}oncept.},
  booktitle = {Proceedings of the 3rd International Conference on 
               New Software Methodologies, Tools, and Techniques 
               (SoMeT 04), Volume 111},
  publisher = {IOS Press},
  month = {September},
  year = {2004},
  pages = {249 -- 262},
  location = {Leipzig, Germany},
  mytype = {CONFERENCE},
  abstract = {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.},
  language = {English}
  author = {Speck, Andreas and Pulverm{\"u}ller, Elke and Clau{\ss}, Matthias},
  title = {{V}ersioning in {S}oftware {M}odeling.},
  booktitle = {Proceedings of the 6th International Conference on
               Integrated Design and Process Technology (IDPT 2002)},
  series = {},
  location = {Pasadena, California, USA},
  month = {June},
  year = {2002},
  pages = {},
  publisher = {Society for Design and Process Science (SDPS)},
  mytype = {CONFERENCE},
  abstract = {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.},
  language = {English}
  author = {Speck, Andreas and Pulverm\"uller, Elke},
  title = {{Versioning in Software Engineering.}},
  editor = {},
  booktitle = {Proceedings of the 27th Annual Conference of the IEEE Industrial
               Electronics Society IES (IECON'01)},
  series = {},
  month = {},
  year = {2001},
  publisher = {IEEE Computer Society Press},
  pages = {1856 -- 1861},
  location = {Denver, CO},
  language = {English},
  mytype = {CONFERENCE},
  abstract = {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).}
  author = {Pulverm{\"u}ller, Elke and Speck, Andreas and Coplien, James O.},
  title = {{A} {V}ersion {M}odel for {A}spect {D}ependency {M}anagement.},
  booktitle = {Proceedings of the 3rd International Symposium on 
               Generative and Component-Based Software Engineering (GCSE) 2001},
  month = {September},
  publisher = {Springer},
  series = {Lecture Notes in Computer Science (LNCS)},
  volume = {2186},
  pages = {70 --79},
  location = {Erfurt, Germany},
  year = {2001},
  mytype = {CONFERENCE},
  abstract = {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.},
  language = {English}
  author = {Rashid, Awais and Chitchyan, Ruzanna and Speck, Andreas 
            and Pulverm{\"u}ller, Elke},
  title = {{EProMS}: {A}n {E}-{C}ommerce based {P}rocess {M}odel 
           for {C}ooperative {S}oftware {D}evelopment in {S}mall {O}rganisations.},
  booktitle = {Proceedings of the 2nd International Conference on 
               ElectronicCommerce and Web Technologies (EC-WEB 2001)},
  month = {September},
  publisher = {Springer},
  series = {Lecture Notes in Computer Science (LNCS)},
  volume = {2115},
  pages = {39 -- 48},
  year = {2001},
  mytype = {CONFERENCE},
  abstract = {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' 
  language = {English}
  author = {Pulverm\"uller, Elke and Speck, Andreas and Rashid, Awais},
  title = {{I}mplementing collaboration-based {D}esigns using 
           {A}spect-{O}riented {P}rogramming.},
  booktitle = {Proceedings of TOOLS-USA 2000,
               Technology of Object-Oriented Languages and Systems,
               34th Int'l Conference and Exhibition},
  pages = {95 -- 104},
  month = {July/August},
  year = {2000},
  publisher = {IEEE Computer Society Press},
  location = {Santa  Barbara, CA, USA},
  mytype = {CONFERENCE},
  abstract = {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.},
  language = {English}
  author = {Rashid, Awais and Sawyer, Pete and Pulverm\"uller, Elke},
  title = {{A} {F}lexible {A}pproach for {I}nstance {A}daptation 
           during {C}lass {V}ersioning.},
  booktitle = {Proceedings of  OODB: Symposium on Objects and Databases
               (co-hosted with ECOOP 2000)},
  series = {Lecture Notes in Computer Science (LNCS)},
  volume = {1944},
  pages = {101 -- 113},
  month = {June},
  year = {2000},
  publisher = {Springer},
  location = {Sophia Antipolis, France},
  mytype = {CONFERENCE},
  abstract = {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.},
  language = {English}
  author = {Rashid, Awais and  Pulverm\"uller, Elke},
  title = {{F}rom {O}bject-{O}riented to {A}spect-{O}riented 
  booktitle = {Proceedings of DEXA: 11th International Conference on Database and 
               Expert Systems Applications},
  series = {Lecture Notes in Computer Science (LNCS)},
  volume = {1873},
  year = {2000},
  month = {September},
  publisher = {Springer},
  pages = {125 -- 134},
  location = {London, Greenwich, UK},
  mytype = {CONFERENCE},
  abstract = {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.},
  language = {English}
  author = {Klaeren, Herbert and Pulverm\"uller, Elke and Rashid, Awais
            and Speck, Andreas},
  title = {{A}spect {C}omposition applying the {D}esign by 
           {C}ontract {P}rinciple.},
  booktitle = {Proceedings of the Second International Symposium on
               Generative and Component-Based Software Engineering (GCSE) /
               Proceedings of the NetObjectDays 2000},
  pages = {453 -- 463},
  series = {Lecture Notes in Computer Science (LNCS)},
  volume = {2177},
  month = {October},
  year = {2000},
  location = {Erfurt, Germany},
  mytype = {CONFERENCE},
  pdf = {./publications/KlaerenPulvermuellerRashidSpeckGCSE2000.pdf},
  abstract = {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.},
  language = {English}
  author = {Pulverm\"uller, Elke and Klaeren, Herbert and Speck, Andreas},
  title = {{A}spects in {D}istributed {E}nvironments.},
  booktitle = {Proceedings of the First International Symposium on
               Generative and Component-Based Software Engineering (GCSE)},
  editor = {Czarnecki, K. and Eisenecker, U. W.},
  series = {Lecture Notes in Computer Science (LNCS)},
  volume = {1799},
  pages = {37 -- 48},
  month = {September},
  year = {1999},
  publisher = {Springer},
  location = {Erfurt, Germany},
  mytype = {CONFERENCE},
  abstract = {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.},
  language = {English}