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},
      url = {https://link.springer.com/}
    }
    
    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},
      url = {https://link.springer.com/}
    }
    
    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},
      url = {https://link.springer.com/}
    }
    
    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},
      url = {https://link.springer.com/chapter/10.1007%2F978-3-642-23798-0_2},
      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
    procedure, including re-engineering tasks for adjusting a given software architecture to
    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},
      url = {https://link.springer.com/}
    }
    
    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},
      url = {https://link.springer.com/}
    }
    
    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},
      url = {https://link.springer.com/}
    }
    
    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},
      url = {https://link.springer.com/}
    }
    
    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},
      url = {https://link.springer.com/}
    }
    

    Created by JabRef on 13/03/2018.

  • Software Quality [Veröffentlichungen]
  • Test [Veröffentlichungen]