# Maritta Heisel

Prof. Dr. Maritta Heisel
Raum BB 919
Tel. : +49 203 379 3465
Fax : +49 379 4490
E-Mail : maritta.heisel[at]uni-duisburg-essen.de

Research
• Compliance [VerÃ¶ffentlichungen]
• Formal Methods [VerÃ¶ffentlichungen]
• Methodology [VerÃ¶ffentlichungen]
• Patterns [VerÃ¶ffentlichungen]
• Privacy [VerÃ¶ffentlichungen]
• Requirements Engineering [VerÃ¶ffentlichungen]
• Safety [VerÃ¶ffentlichungen]
• Security [VerÃ¶ffentlichungen]
• Software Architecture
VerÃ¶ffentlichungen:

QuickSearch:   Number of matching entries: 0.

YearTitleAuthorJournal/ProceedingsPublisher
2016 Variability for Qualities in Software Architecture Alebrahim, A., Faßbender, S., Filipczyk, M., Goedicke, M., Heisel, M. & Zdun, U. SIGSOFT Softw. Eng. Notes   ACM
BibTeX:
@article{Alebrahim:2016:VQS:2853073.2853095,
year = {2016},
title = {Variability for Qualities in Software Architecture},
author = {Alebrahim, Azadeh and Fa{\ss}bender, Stephan and Filipczyk, Martin and Goedicke, Michael and Heisel, Maritta and Zdun, U.},
journal = {SIGSOFT Softw. Eng. Notes},
publisher = {ACM},
volume = {41},
number = {1},
pages = {32--35},
url = {https://dl.acm.org/citation.cfm?doid=2853073.2853095},
doi = {10.1145/2853073.2853095}
}

2015 Relating Performance and Security Tactics to Architectural Patterns Alebrahim, A., Faßbender, S., Filipczyk, M., Goedicke, M. & Heisel, M. Proceedings of the 20th European Conference on Pattern Languages of Program   ACM
BibTeX:
@inproceedings{AlebrahimFassbenderFGH2015ACM-europlopb,
year = {2015},
title = {Relating Performance and Security Tactics to Architectural Patterns},
booktitle = {Proceedings of the 20th European Conference on Pattern Languages of Program},
author = {Alebrahim, Azadeh and Fa{\ss}bender, Stephan and Filipczyk, Martin and Goedicke, Michael and Heisel, Maritta},
publisher = {ACM},
series = {EuroPLoP '15},
note = {To be Published},
url = {https://dl.acm.org/}
}

2015 Towards Systematic Selection of Architectural Patterns with Respect to Quality Requirements Alebrahim, A., Faßbender, S., Filipczyk, M., Goedicke, M. & Heisel, M. Proceedings of the 20th European Conference on Pattern Languages of Programs (EuroPLoP)   ACM
BibTeX:
@inproceedings{Europlop2015-2,
year = {2015},
title = {Towards Systematic Selection of Architectural Patterns with Respect to Quality Requirements},
booktitle = {Proceedings of the 20th European Conference on Pattern Languages of Programs (EuroPLoP)},
author = {Alebrahim, Azadeh and Fa{\ss}bender, Stephan and Filipczyk, Martin and Goedicke, Michael and Heisel, Maritta},
publisher = {ACM},
url = {https://dl.acm.org/citation.cfm?id=2855362}
}

2015 Towards a Reliable Mapping between Performance and Security Tactics, and Architectural Patterns Alebrahim, A., Faßbender, S., Filipczyk, M., Goedicke, M. & Heisel, M. Proceedings of the 20th European Conference on Pattern Languages of Programs (EuroPLoP)   ACM
BibTeX:
@inproceedings{,
year = {2015},
title = {Towards a Reliable Mapping between Performance and Security Tactics, and Architectural Patterns},
booktitle = {Proceedings of the 20th European Conference on Pattern Languages of Programs (EuroPLoP)},
author = {Alebrahim, Azadeh and Fa{\ss}bender, Stephan and Filipczyk, Martin and Goedicke, Michael and Heisel, Maritta},
publisher = {ACM},
url = {https://dl.acm.org/citation.cfm?id=2855361}
}

2014 Intertwining Relationship between Requirements, Architecture, and Domain Knowledge Alebrahim, A. & Heisel, M. Proceedings of the 9th International Conference on Software Engineering Advances (ICSEA)
Abstract: In requirements engineering, properties of the environment
and assumptions about it, called domain knowledge, need to
be captured in addition to exploring the requirements. Despite the
recognition of the significance of capturing the required domain
knowledge, domain knowledge might be missing, left implicit,
or be captured inadequately during the software development
process, causing incorrect specifications and software failure.
Domain knowledge affects the elicitation and evolution of requirements,
the evolution of software architectures, and related design
decisions. Conversely, requirements and design decisions affect
the elicitation and modification of domain knowledge. In this
paper, we propose the iterative capturing and co-developing of
domain knowledge with requirements and software architectures.
We explicitly discuss the effects of requirements and design
decisions on domain knowledge and illustrate this relationship
with examples drawn from our research, where we had to go
back and forth between requirements, domain knowledge, and
design decisions.
BibTeX:
@inproceedings{ICSEA2014,
year = {2014},
title = {Intertwining Relationship between Requirements, Architecture, and Domain Knowledge},
booktitle = {Proceedings of the 9th International Conference on Software Engineering Advances (ICSEA)},
author = {Alebrahim, Azadeh and Heisel, Maritta},
volume = {421},
series = {IFIP Advances in Information and Communication Technology},
pages = {150--162}
}

2012 Enterprise Applications: From Requirements to Design Choppy, C., Reggio, G., Hatebur, D. & Heisel, M. Aligning Enterprise, System, and Software Architectures   IGI Global
BibTeX:
@incollection{CRHH2012,
year = {2012},
title = {Enterprise Applications: From Requirements to Design},
booktitle = {Aligning Enterprise, System, and Software Architectures},
author = {Choppy, Christine and Reggio, G. and Hatebur, Denis and Heisel, Maritta},
publisher = {IGI Global},
pages = {96--117},
url = {www.igi-global.com}
}

2012 Designing Architectures from Problem Descriptions by Interactive Model Transformation Alebrahim, A., Côté, I., Heisel, M., Choppy, C. & Hatebur, D. Proceedings 27th Symposium on Applied Computing   ACM
Abstract: We present a structured approach to systematically derive a software
architecture from a given problem description based on problem
frames and a description of the environment. Our aim is to
re-use the elements of the problem descriptions in creating the architecture.
The derivation is performed by transforming the problem
description into an initial architecture, where each subproblem
corresponds to a component. The transformation is supported by
model transformation rules, formally specified as operations with
pre- and postconditions. This specification serves as a blueprint for
a tool supporting the architectural design. We illustrate our method
by the example of a patient care system.
BibTeX:
@inproceedings{SAC2012,
year = {2012},
title = {Designing Architectures from Problem Descriptions by Interactive Model Transformation},
booktitle = {Proceedings 27th Symposium on Applied Computing},
author = {Alebrahim, Azadeh and C{\^{o}}t{\'{e}}, Isabelle and Heisel, Maritta and Choppy, Christine and Hatebur, Denis},
publisher = {ACM},
pages = {1256--1258},
url = {http://dl.acm.org/}
}

2012 Deriving Quality-based Architecture Alternatives with Patterns Konersmann, M., Alebrahim, A., Heisel, M., Goedicke, M. & Kersten, B. Software Engineering   GI
Abstract: We propose in this paper an iterative method composed of three steps to
derive architecture alternatives from quality requirements using a catalogue of patterns
and styles. The solution candidates are chosen by answering a set of questions which
reflects the requirements. We instantiate then the solution candidates using a UMLbased
enhancement of the problem frame approach. To ensure that the instantiated
architectures fulfill the quality requirements, we evaluate them in the next step. A
desired refinement of the software architectures is then achieved by iterating over the
described steps.
BibTeX:
@inproceedings{SE2012,
year = {2012},
title = {Deriving Quality-based Architecture Alternatives with Patterns},
booktitle = {Software Engineering},
author = {Konersmann, Marco and Alebrahim, Azadeh and Heisel, Maritta and Goedicke, Michael and Kersten, Benjamin},
publisher = {GI},
series = {LNI 198},
pages = {71--82},
url = {www.gi.de}
}

2011 Towards Systematic Integration of Quality Requirements into Software Architecture Alebrahim, A., Hatebur, D. & Heisel, M. Proceedings of the 5th European Conference on Software Architecture (ECSA 2011)   Springer
Abstract: We present a model- and pattern-based approach that allows
software engineers to take quality requirements into account right from
the beginning of the software development process. The approach comprises
requirements analysis as well as the software architecture design,
in which quality requirements are re
ected explicitly.
BibTeX:
@inproceedings{AHH2011a,
year = {2011},
title = {Towards Systematic Integration of Quality Requirements into Software Architecture},
booktitle = {Proceedings of the 5th European Conference on Software Architecture (ECSA 2011)},
author = {Alebrahim, Azadeh and Hatebur, Denis and Heisel, Maritta},
publisher = {Springer},
series = {LNCS 6903},
pages = {17--25},
}

2011 A Method to Derive Software Architectures from Quality Requirements Alebrahim, A., Hatebur, D. & Heisel, M. Proceedings of the 18th Asia-Pacific Software Engineering Conference (APSEC)   IEEE Computer Society
Abstract: We present a model- and pattern-based method that allows software engineers to take quality requirements into account right from the beginning of the software development process. The method comprises requirements analysis as well as the derivation of a software architecture from requirements documents, in which quality requirements are reflected explicitly. For requirements analysis, we use an enhancement of the problem frame approach, where software development problems are represented by problem diagrams. The derivation of a software architecture starts from a set of problem diagrams, annotated with functional as well as quality requirements. First, we set up an initial software architecture, taking into account the decomposition of the overall software development problem into subproblems. Then, we incorporate quality requirements into that architecture by using security or performance patterns or mechanisms. The method is toolsupported, which allows developers to check semantic integrity conditions in the different models
BibTeX:
@inproceedings{AHH2011b,
year = {2011},
title = {A Method to Derive Software Architectures from Quality Requirements},
booktitle = {Proceedings of the 18th Asia-Pacific Software Engineering Conference ({APSEC})},
author = {Alebrahim, Azadeh and Hatebur, Denis and Heisel, Maritta},
publisher = {IEEE Computer Society},
pages = {322--330},
url = {https://www.ieee.org/}
}

2011 On the Evolution of Component-based Software Côté, I., Heisel, M. & Souquières, J. Proceedings 4th IFIP TC2 Central and East European Conference on Software Engineering Techniques (CEE-SET)   Springer
BibTeX:
@inproceedings{ceeset2009,
year = {2011},
title = {On the Evolution of Component-based Software},
booktitle = {Proceedings 4th IFIP TC2 Central and East European Conference on Software Engineering Techniques (CEE-SET)},
author = {C{\^{o}}t{\'{e}}, Isabelle and Heisel, Maritta and Souqui{\{e}}res, Jeanine},
publisher = {Springer},
series = {LNCS 7054},
pages = {54-69},
}

2011 Systematic Architectural Design based on Problem Patterns Choppy, C., Hatebur, D. & Heisel, M. Relating Software Requirements and Architectures   Springer
Abstract: We present a method to derive systematically software architectures
from problem descriptions. The problem descriptions are based on the artifacts
that are set up when following Jackson's problem frame approach. They include a
context diagram describing the overall problem situation and a set of problem
diagrams that describe subproblems of the overall software development problem.
The different subproblems should be instances of problem frames, which are
patterns for simple software development problems.
Starting from these pattern-based problem descriptions, we derive a software
architecture in three steps. An initial architecture contains one component for each
subproblem. In the second step, we apply different architectural and design
patterns and introduce coordinator and facade components. In the final step, the
components of the intermediate architecture are re-arranged to form a layered
architecture, and interface and driver components are added.
All artefacts are expressed as UML diagrams, using specific UML profiles. The
method is tool-supported. Our tool supports developers in setting up the diagrams,
and it checks different validation conditions concerning the semantic integrity and
the coherence of the different diagrams.
We illustrate the method by deriving an architecture for an automated teller
machine.
BibTeX:
@incollection{CHH2011a,
year = {2011},
title = {Systematic Architectural Design based on Problem Patterns},
booktitle = {Relating Software Requirements and Architectures},
author = {Choppy, Christine and Hatebur, Denis and Heisel, Maritta},
publisher = {Springer},
pages = {133--159},
}

2011 A Pattern- and Component-Based Method to Develop Secure Software Schmidt, H., Hatebur, D. & Heisel, M. Software Engineering for Secure Systems: Academic and Industrial Perspectives   IGI Global
Abstract: We present a security engineering process based on security problem frames and concretized
security problem frames. Both kinds of frames constitute patterns for analyzing security problems
and associated solution approaches. They are arranged in a pattern system that makes
dependencies between them explicit. We describe step-by-step how the pattern system can be
used to analyze a given security problem and how solution approaches can be found.
Afterwards, the security problems and the solution approaches are formally modeled in detail.
The formal models serve to prove that the solution approaches are correct solutions to the security
problems. Furthermore, the formal models of the solution approaches constitute a formal
specification of the software to be developed.
Then, the specification is implemented by generic security components and generic security
architectures, which constitute architectural patterns. Finally, the generic security components
and the generic security architecture that composes them are refined and the result is a secure
software product built from existing and/or tailor-made security components.
KEYWORDS
security
BibTeX:
@incollection{SHH2011,
year = {2011},
title = {A Pattern- and Component-Based Method to Develop Secure Software},
booktitle = {Software Engineering for Secure Systems: Academic and Industrial Perspectives},
author = {Schmidt, Holger and Hatebur, Denis and Heisel, Maritta},
publisher = {IGI Global},
pages = {32--74},
url = {http://www.igi-global.com/}
}

2011 Towards Systematic Integration of Performance and Security Requirements into Software Architecture Alebrahim, A., Hatebur, D. & Heisel, M. Software Architecture   Springer Berlin Heidelberg
Abstract: We present a model- and pattern-based method that allows
software engineers to take quality requirements into account
right from the beginning of the software development process.
The method comprises requirements analysis as well as
the derivation of a software architecture from requirements
documents. In that architecture, quality requirements are
reflected explicitly.
For requirements analysis, we use an enhancement of the
problem frame approach [14], where software development
problems are represented by problem diagrams. In our enhanced
version of the problem frame approach, we use UML
notation, and we have added the possibility to complement
functional requirements with quality requirements, such as
security or performance requirements.
The derivation of a software architecture starts from a
set of problem diagrams, annotated with functional as well
as quality requirements. First, we set up an initial software
architecture, taking into account the decomposition of
the overall software development problem into subproblems.
Next, we incorporate quality requirements into that architecture
by using security or performance patterns or mechanisms.
To obtain the final architecture, (functional) design
patterns are applied. The method is tool-supported, which
allows developers to check semantic integrity conditions in
the different models.
BibTeX:
@proceedings{,
year = {2011},
title = {Towards Systematic Integration of Performance and Security Requirements into Software Architecture},
booktitle = {Software Architecture},
author = {Alebrahim, Azadeh and Hatebur, Denis and Heisel, Maritta},
publisher = {Springer Berlin Heidelberg},
doi = {10.1007/978-3-642-23798-0_2}
}

2009 Deriving Software Architectures from Problem Descriptions Hatebur, D. & Heisel, M. Software Engineering 2009 - Workshopband   GI
Abstract: We show how software architectures (including interface descriptions) can
be derived from artifacts set up in the analysis phase of the software lifecycle. The
analysis phase consists of six steps, where various models are constructed. Especially,
the software development problem is decomposed into simple subproblems. The models
set up in the analysis phase form the basis for (i) defining software architectures
related to single subproblems, (ii) merging the subproblem architectures to obtain the
overall software architecture, and (iii) to define the interfaces between the components
of the overall architecture. The approach is based on problem patterns (problem
frames) and the architectural style of layered software architectures.
BibTeX:
@inproceedings{HH09a,
year = {2009},
title = {Deriving Software Architectures from Problem Descriptions},
booktitle = {Software Engineering 2009 - Workshopband},
author = {Hatebur, Denis and Heisel, Maritta},
publisher = {GI},
pages = {383--302},
url = {https://gi.de/}
}

2008 Analysis and Component-based Realization of Security Requirements Hatebur, D., Heisel, M. & Schmidt, H. Proceedings of the International Conference on Availability, Reliability and Security (AReS)   IEEE Computer Society
Abstract: We present a process to develop secure software with an
extensive pattern-based security requirements engineering
phase. It supports identifying and analyzing conflicts between
different security requirements. In the design phase,
we proceed by selecting security software components that
achieve security requirements. The process enables software
developers to systematically identify, analyze, and finally
realize security requirements using security software
components. We illustrate our approach by a lawyer agency
software example.
BibTeX:
@inproceedings{HHS2008b,
year = {2008},
title = {Analysis and Component-based Realization of Security Requirements},
booktitle = {Proceedings of the International Conference on Availability, Reliability and Security (AReS)},
author = {Hatebur, Denis and Heisel, Maritta and Schmidt, Holger},
publisher = {IEEE Computer Society},
series = {IEEE Transactions},
pages = {195--203},
url = {https://www.ieee.org}
}

2007 Pattern-based Exploration of Design Alternatives for the Evolution of Software Architectures Côté, I., Heisel, M. & Wentzlaff, I. International Journal of Cooperative Information Systems (IJCIS)   World Scientific
Abstract: We propose a pattern-based software development method comprising analysis (using
problem frames) and design (using architectural and design patterns), from which especially
evolving systems benefit. Evolution operators guide a pattern-based transformation
meet new system demands. Through application of these operators, relations between
analysis and design documents are explored systematically for accomplishing desired software
modifications. This allows for reusing development documents to a large extent,
even when the application environment and the requirements change.
BibTeX:
@article{CHW2007,
year = {2007},
title = {{Pattern-based Exploration of Design Alternatives for the Evolution of Software Architectures}},
author = {C{\^{o}}t{\'{e}}, Isabelle and Heisel, Maritta and Wentzlaff, Ina},
journal = {International Journal of Cooperative Information Systems (IJCIS)},
publisher = {World Scientific},
volume = {Volume: 16},
number = {Issue: 3/4},
pages = {341 -- 365},
url = {http://www.worldscinet.com/ijcis/ijcis.shtml}
}

2007 Enhancing Dependability of Component-Based Systems Lanoix, A., Hatebur, D., Heisel, M. & Souquières, J. Reliable Software Technologies -- Ada Europe 2007   Springer
Abstract: We present an approach for enhancing dependability of component-
based software. Functionality related to security, safety and reliability
is encapsulated in specific components, allowing the method to
be applied to off-the-shelf components. Any set of components can be
extended with dependability features by wrapping them with special
components, which monitor and filter input and outputs. This approach
is supported by a rigorous development methodology based on UML and
the B method and is introduced on the level of software architecture.
BibTeX:
@inproceedings{LHH+2007,
year = {2007},
title = {Enhancing Dependability of Component-Based Systems},
booktitle = {Reliable Software Technologies -- Ada Europe 2007},
author = {Lanoix, Arnaud and Hatebur, Denis and Heisel, Maritta and Souqui{\{e}}res, Jeanine},
publisher = {Springer},
series = {LNCS 4498},
pages = {41--54},
}

2006 Component composition through architectural patterns for problem frames Choppy, C., Hatebur, D. & Heisel, M. Proc. XIII Asia Pacific Software Engineering Conference   IEEE Computer Society
Abstract: In this paper, we present a pattern-based software development
process using problem frames and corresponding
architectural patterns. In decomposing a complex problem
into simple subproblems, the relationships between the subproblems
are recorded explicitly. Based on this information,
we give guidelines on how to derive the software architecture
for the overall problem from the software architectures
of the simple subproblems.
BibTeX:
@inproceedings{CHH2006,
year = {2006},
title = {Component composition through architectural patterns for problem frames},
booktitle = {Proc. XIII Asia Pacific Software Engineering Conference},
author = {Choppy, Christine and Hatebur, Denis and Heisel, Maritta},
publisher = {IEEE Computer Society},
pages = {27--34},
url = {https://www.ieee.org}
}

2006 Proving Component Interoperability with B Refinement Chouali, S., Heisel, M. & Souquières, J. Electronic Notes in Theoretical Computer Science
BibTeX:
@article{CHS2006,
year = {2006},
title = {Proving Component Interoperability with B Refinement},
author = {Chouali, Samir and Heisel, Maritta and Souqui{\{e}}res, Jeanine},
journal = {Electronic Notes in Theoretical Computer Science},
volume = {160},
pages = {157--172}
}

2006 A Method for Component-Based Software and System Development Hatebur, D., Heisel, M. & Souquières, J. Proc. 32nd Euromicro Conference on Software Engineering and Advanced Applications (SEAA)   IEEE Computer Society
Abstract: In this paper, we present a pattern-based software development
process using problem frames and corresponding
architectural patterns. In decomposing a complex problem
into simple subproblems, the relationships between the subproblems
are recorded explicitly. Based on this information,
we give guidelines on how to derive the software architecture
for the overall problem from the software architectures
of the simple subproblems.
BibTeX:
@inproceedings{HHS2006b,
year = {2006},
title = {A Method for Component-Based Software and System Development},
booktitle = {Proc. 32nd Euromicro Conference on Software Engineering and Advanced Applications (SEAA)},
author = {Hatebur, Denis and Heisel, Maritta and Souqui{\{e}}res, Jeanine},
publisher = {IEEE Computer Society},
pages = {72--80},
url = {https://www.ieee.org}
}

2005 Composing architectures based on architectural patterns for problem frames Choppy, C., Hatebur, D. & Heisel, M.
Abstract: to be inserted
BibTeX:
@techreport{ChoppyHateburHeisel05,
year = {2005},
title = {Composing architectures based on architectural patterns for problem frames},
author = {Choppy, Christine and Hatebur, Denis and Heisel, Maritta},
note = {\tt http://swe.uni-duisburg-essen.de/intern/comparch05.pdf}
}

2005 Proving Component Interoperability with B Refinement Chouali, S., Heisel, M. & Souquières, J. International Workshop on Formal Aspects on Component Software
Abstract: We use the formal method B for specifying interfaces of software components. Each component interface is equipped with a suitable data model defining all types occurring in the signature of interface operations. Moreover, pre- and postconditions have to be given for all interface operations. The interoperability between two components is proved by using a refinement relation between an adaption of the interface specifications.
BibTeX:
@inproceedings{ChoualiHeiselSouquieres05,
year = {2005},
title = {Proving Component Interoperability with {B} Refinement},
booktitle = {{International Workshop on Formal Aspects on Component Software}},
author = {Chouali, Samir and Heisel, Maritta and Souqui{\{e}}res, Jeanine},
publisher = {CSREA Press},
pages = {915-920}
}

2005 Problem Frames and Architectures for Security Problems Hatebur, D. & Heisel, M. Proceedings of the 24th International Conference on Computer Safety, Reliability and Security (SAFECOMP)   Springer
Abstract: Abstract: We present two (?) problem frames that serve to structure, characterize and analyze software
development problems in the area of software and system security. These problem frames constitute
patterns for representing security problems, variants of which occur frequently in practice. Solving such
problems starts with the development of an appropriate software architecture. To support that process,
we furthermore present architectural patterns associated with the problem frames.
BibTeX:
@inproceedings{HH2005,
year = {2005},
title = {Problem Frames and Architectures for Security Problems},
booktitle = {Proceedings of the 24th International Conference on Computer Safety, Reliability and Security (SAFECOMP)},
author = {Hatebur, Denis and Heisel, Maritta},
publisher = {Springer},
series = {LNCS 3688},
pages = {390--404},
}

2004 A Description Structure for Simulation Model Components Heisel, M., Lüthi, J., Uhrmacher, A. & Valentin, E. Proceedings Summer Computer Simulation Conference 04
BibTeX:
@inproceedings{HLU+2004,
year = {2004},
title = {A Description Structure for Simulation Model Components},
booktitle = {Proceedings Summer Computer Simulation Conference 04},
author = {Heisel, Maritta and L{\"{u}}thi, Johannes and Uhrmacher, Adelinde and Valentin, Edwin}
}

2004 Adding Features to Component-Based Systems Heisel, M. & Souquières, J. Objects, Agents and Features   Springer
Abstract: Features and components are two different structuring mechanisms
for software systems. Both are very useful, but lead to different structures for
the same system. Usually, features are spread over more than one component. In
this paper, we aim at reconciling the two structuring mechanisms. We show how
component orientation can support adding new features to a base system. We
present a method for adding features in a systematic way to component-based
systems that have been specified according to the method proposed by Cheesman
and Daniels
BibTeX:
@incollection{HS2004a,
year = {2004},
title = {Adding Features to Component-Based Systems},
booktitle = {Objects, Agents and Features},
author = {Heisel, Maritta and Souqui{\{e}}res, Jeanine},
publisher = {Springer},
series = {LNCS 2975},
pages = {137--153},
}

2003 Use of Patterns in Formal Development: Systematic Transition From Problems to Architectural Designs Choppy, C. & Heisel, M. Recent Trends in Algebraic Development Techniques, 16th WADT, Selected Papers   Springer
Abstract: We present a pattern-based software lifecycle and a method that supports the systematic execution of that lifecycle. First, problem frames are used to develop a formal specification of the problem to be solved. In a second phase, architectural styles are used to construct an architectural specification of the software system to be developed. That specification forms the basis for fine-grained design and implementation.
BibTeX:
@inproceedings{CH2003,
year = {2003},
title = {Use of Patterns in Formal Development: Systematic Transition From Problems to Architectural Designs},
booktitle = {Recent Trends in Algebraic Development Techniques, 16th WADT, Selected Papers},
author = {Choppy, Christine and Heisel, Maritta},
publisher = {Springer},
series = {LNCS 2755},
pages = {205--220},
}

2002 Toward a formal model of software components Heisel, M., Santen, T. & Souquières, J. Proc. 4th International Conference on Formal Engineering Methods   Springer
Abstract: We are interested in specifying component models in a way that allows
us to analyze the interplay of components in general, and to concisely specify
individual components. As a starting point for coming up with a technique of
specifying component models, we consider JavaBeans. We capture the JavaBean
component model using UML class diagrams, Object-Z, and life sequence charts.
BibTeX:
@inproceedings{HSS2002,
year = {2002},
title = {Toward a formal model of software components},
booktitle = {Proc.\ 4th International Conference on Formal Engineering Methods},
author = {Heisel, Maritta and Santen, Thomas and Souqui{\{e}}res, Jeanine},
publisher = {Springer},
series = {LNCS 2495},
pages = {57--68},
`