pulvermueller_conferences.bib
@inproceedings{PuSpFeWiSOMET11,
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}
}
@inproceedings{IyPuWeETFA2011,
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}
}
@inproceedings{IyPuWeWuFDL2011,
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}
}
@inproceedings{EKMaKePuCEC11,
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}
}
@inproceedings{EKMaKePuEDOC11,
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}
}
@inproceedings{IyWeWuPuINDIN2011,
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
presented.},
language = {English},
url_home = {http://dx.doi.org/10.1109/INDIN.2011.6035011}
}
@inproceedings{SpWiFeLoPuBIS11,
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
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.},
language = {English},
url_home = {http://dx.doi.org/10.1007/978-3-642-21863-7_5}
}
@inproceedings{IyWeWuPuEMSOFT10,
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}
}
@inproceedings{IyWeWuPuFDL10,
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}
}
@inproceedings{PuSpFeWiCCIS10,
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}
}
@inproceedings{SpPuSOMET09,
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}
}
@inproceedings{PuSOMET09,
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}
}
@inproceedings{ElPuBPSC09,
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}
}
@inproceedings{FoPu07,
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}
}
@inproceedings{PuLuBeZy07,
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
environments.},
language = {English}
}
@inproceedings{FoPuXMLT07,
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}
}
@inproceedings{PuSp04,
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}
}
@inproceedings{SpPuCl02,
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}
}
@inproceedings{SpPuIECON01,
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).}
}
@inproceedings{PuSpCo01,
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}
}
@inproceedings{RaChSpPu01,
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'
satisfaction.},
language = {English}
}
@inproceedings{PuSpRa00,
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}
}
@inproceedings{RaSaPu00,
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}
}
@inproceedings{RaPu00,
author = {Rashid, Awais and Pulverm\"uller, Elke},
title = {{F}rom {O}bject-{O}riented to {A}spect-{O}riented
{D}atabases.},
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}
}
@inproceedings{KlPuRaSp00,
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}
}
@inproceedings{PuKlSp99,
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}
}