Secondary Content
Info Menu
Private Interrests
Networks
Dr. Thomas P. Ruhroth - Publications
- Robert Heinrich, Stefan Gärtner, Tom-Michael Hesse, Thomas Ruhroth, Ralf H. Reussner, Kurt Schneider, Barbara Paech, Jan Jürjens: The CoCoME Platform: A Research Note on Empirical Studies in Information System Evolution. In: International Journal of Software Engineering and Knowledge Engineering, vol. 25, no. 9-10, pp. 1715-1720, 2015.Methods for supporting evolution of software-intensive systems are a competitive edge in software engineering as software is often operated over decades. Empirical research is useful to validate the effectiveness of these methods. However, empirical studies on software evolution are rarely comprehensive and hardly replicable. Collaboration may prevent these shortcomings. We designed CoCoMEP — a platform for supporting collaboration in empirical research on software evolution by shared knowledge. We report lessons learned from the application of the platform in a large research programme.AbstractBibTeX DOI
@article{ijseke15, author = {Robert Heinrich and Stefan G{\"{a}}rtner and Tom{-}Michael Hesse and Thomas Ruhroth and Ralf H. Reussner and Kurt Schneider and Barbara Paech and Jan J{\"{u}}rjens}, title = {The CoCoME Platform: {A} Research Note on Empirical Studies in Information System Evolution}, journal = {International Journal of Software Engineering and Knowledge Engineering}, volume = {25}, number = {9-10}, pages = {1715--1720}, year = {2015}, url = {http://dx.doi.org/10.1142/S0218194015710059}, doi = {10.1142/S0218194015710059}, abstract = {Methods for supporting evolution of software-intensive systems are a competitive edge in software engineering as software is often operated over decades. Empirical research is useful to validate the effectiveness of these methods. However, empirical studies on software evolution are rarely comprehensive and hardly replicable. Collaboration may prevent these shortcomings. We designed CoCoMEP — a platform for supporting collaboration in empirical research on software evolution by shared knowledge. We report lessons learned from the application of the platform in a large research programme.} } - J. Bürger, S. Gärtner, T. Ruhroth, J. Zweihoff, J. Jürjens, K. Schneider: Restoring Security of Long-Living Systems by Co-Evolution. In: 39th Annual IEEE Computer Software and Applications Conference (COMPSAC 2015), pp. 153 - 158, IEEE, 2015. 6 pp.Security is an important quality aspect for modern information systems. Security properties may however be violated if the information system operates in an evolving environment. Environmental changes then trigger reactions which lead to co-evolution of the security design and the corresponding system model. However, updating the security design manually is time-consuming and error-prone. We present an approach to support semi-automatic system co-evolution which responds to environmental knowledge evolution, using the UML security extension UMLsec and graph transformation. The aim is to enable software engineers to react more reliably and effectively to environmental changes and to ensure lifelong compliance of information systems. To evaluate our approach, we conducted a case study on the open-source project iTrust.AbstractBibTeX
@InProceedings{compsac15B, author = {J.~B\"urger and S.~G\"artner and T.~Ruhroth and J.~Zweihoff and J.~{J}{\"u}{r}jens and K.~Schneider}, title = {Restoring Security of Long-Living Systems by Co-Evolution}, booktitle = {39th Annual IEEE Computer Software and Applications Conference (COMPSAC 2015)}, pages = {153 - 158 }, note = {6 pp.}, year = {2015}, OPTeditor = {}, volume={2}, OPTnumber = {}, organization = {IEEE}, keywords = {internationalConferences, softwareEvolution}, abstract = {Security is an important quality aspect for modern information systems. Security properties may however be violated if the information system operates in an evolving environment. Environmental changes then trigger reactions which lead to co-evolution of the security design and the corresponding system model. However, updating the security design manually is time-consuming and error-prone. We present an approach to support semi-automatic system co-evolution which responds to environmental knowledge evolution, using the UML security extension UMLsec and graph transformation. The aim is to enable software engineers to react more reliably and effectively to environmental changes and to ensure lifelong compliance of information systems. To evaluate our approach, we conducted a case study on the open-source project iTrust.} } - Robert Heinrich, Stefan Gärtner, Tom-Michael Hesse, Thomas Ruhroth, Ralf Reussner, Kurt Schneider, Barbara Paech, Jan Jürjens: A Platform for Empirical Research on Information System Evolution. In: The 27th International Conference on Software Engineering and Knowledge Engineering (SEKE 2015), pp. 415-420, KSI Research Inc., 2015. .Software-intensive systems are subject to continuous change due to modification of the systems themselves and their environment. Methods for supporting evolution are a competitive edge in software engineering as software is operated over decades. Empirical research is useful to validate the effectiveness of these methods. However, empirical studies on software evolution are rarely comprehensive and hardly replicable. Collaboration in empirical studies may prevent these shortcomings. We analyzed the sup- port for such collaboration and examined existing studies in a literature review. Based on our findings, we designed CoCoMEP– a platform for supporting collaboration in em- pirical research on software evolution by shared knowledge. We report lessons learned from the application of the platform in a large research programme.AbstractBibTeX
@InProceedings{seke15, author = {Robert Heinrich and Stefan Gärtner and Tom-Michael Hesse and Thomas Ruhroth and Ralf Reussner and Kurt Schneider and Barbara Paech and Jan Jürjens}, title = {A Platform for Empirical Research on Information System Evolution}, booktitle = {The 27th International Conference on Software Engineering and Knowledge Engineering (SEKE 2015)}, pages = {415--420}, note = {}, year = {2015}, OPTeditor = {}, OPTvolume = {}, OPTnumber = {}, organization = {KSI Research Inc.}, keywords = {internationalConferences, softwareEvolution}, abstract = {Software-intensive systems are subject to continuous change due to modification of the systems themselves and their environment. Methods for supporting evolution are a competitive edge in software engineering as software is operated over decades. Empirical research is useful to validate the effectiveness of these methods. However, empirical studies on software evolution are rarely comprehensive and hardly replicable. Collaboration in empirical studies may prevent these shortcomings. We analyzed the sup- port for such collaboration and examined existing studies in a literature review. Based on our findings, we designed CoCoMEP– a platform for supporting collaboration in em- pirical research on software evolution by shared knowledge. We report lessons learned from the application of the platform in a large research programme.} } - Stefan Gärtner, Thomas Ruhroth, Jens Bürger, Kurt Schneider, Jan Jürjens: Towards Maintaining Long-Living Information Systems by Incorporating Evolving Security Knowledge. In: Software Engineering (SE 2015), Lecture Notes in Informatics, GI, 2015.Modern information systems are increasingly complex and need to operate in evolving environments. As a consequence, systems must co-evolve to keep up-to-date with their environments. This is especially important for security properties, since changes and patches tend to compromise them. We propose a security assessment approach for natural language requirements for systematic co-evolution. Our evaluation and tool implementation show security benefits for maintaining long-living systems.AbstractBibTeX preprint
@InProceedings{se15GRBSJ, author = {Stefan G\"artner and Thomas Ruhroth and Jens B\"urger and Kurt Schneider and Jan J\"urjens}, title = {Towards Maintaining Long-Living Information Systems by Incorporating Evolving Security Knowledge}, booktitle = {Software Engineering (SE 2015)}, OPTpages = {}, year = {2015}, OPTeditor = {}, OPTvolume = {}, OPTnumber = {}, series = {Lecture Notes in Informatics}, organization = {GI}, File = {preprint:http\://rgse.uni-koblenz.de/secse/pages/people/juerjens/publications/papers/se15.pdf:URL}, keywords = {hotOffThePress,workshop, industrialConferences}, abstract = {Modern information systems are increasingly complex and need to operate in evolving environments. As a consequence, systems must co-evolve to keep up-to-date with their environments. This is especially important for security properties, since changes and patches tend to compromise them. We propose a security assessment approach for natural language requirements for systematic co-evolution. Our evaluation and tool implementation show security benefits for maintaining long-living systems.} } - Thomas Ruhroth, Stefan Gärtner, Jens Bürger, Jan Jürjens, Kurt Schneider: Towards Adaptation and Evolution of Domain-specific Knowledge for Maintaining Secure Systems. In: 15th International Conference of Product Focused Software Development and Process Improvement (Profes'14), Springer-Verlag, Lecture Notes in Computer Science, vol. 8892, pp. 239-253, 2014.Creating and maintaining secure software require a good understanding of the system and its environment. Knowledge management is therefore one of the key factors to maintain secure software successfully. However, acquiring and modeling knowledge is a labor-intensive and time-consuming task. Thus, knowledge ought to be shared among different projects and must be adapted to their specific needs. In this paper, we present an approach allowing the stepwise adaptation from domain- to project-specific knowledge based on OWL ontologies. For this purpose, we define a basic set of adaptation operators which allows effective and frugal changes. Moreover, we discuss how our approach can be integrated into common software process models in order to adapt knowledge required for maintenance. Since domain- and project-specific knowledge changes over time, we show how our approach copes with changes efficiently, so that the affected knowledge remains consistent. The shared use of knowledge significantly reduce the complexity and effort to model required knowledge in various projects. Our case study and tool implementation shows the benefits for maintaining secure systems.AbstractBibTeX DOI preprint dblp SpringerLink
@InProceedings{profes14, author = {Thomas Ruhroth and Stefan G\"artner and Jens B\"urger and Jan J\"urjens and Kurt Schneider}, title = {Towards Adaptation and Evolution of Domain-specific Knowledge for Maintaining Secure Systems}, booktitle = {15th International Conference of Product Focused Software Development and Process Improvement (Profes'14)}, pages = {239--253}, editors = {Andreas Jedlitschka and Pasi Kuvaja and Marco Kuhrmann and Tomi Mannist\"o and J\"urgen M\"unch}, year = {2014}, volume = {8892}, series = {Lecture Notes in Computer Science}, publisher = {Springer-Verlag}, doi = {10.1007/978-3-319-13835-0_17}, file = {preprint:http\://rgse.uni-koblenz.de/secse/pages/people/juerjens/publications/papers/profes14.pdf:URL;dblp:http://www.informatik.uni-trier.de/~ley/pers/hd/j/J=uuml=rjens:Jan.html#c113:URL;SpringerLink:http://link.springer.com/chapter/10.1007/978-3-319-13835-0_17:URL}, abstract = {Creating and maintaining secure software require a good understanding of the system and its environment. Knowledge management is therefore one of the key factors to maintain secure software successfully. However, acquiring and modeling knowledge is a labor-intensive and time-consuming task. Thus, knowledge ought to be shared among different projects and must be adapted to their specific needs. In this paper, we present an approach allowing the stepwise adaptation from domain- to project-specific knowledge based on OWL ontologies. For this purpose, we define a basic set of adaptation operators which allows effective and frugal changes. Moreover, we discuss how our approach can be integrated into common software process models in order to adapt knowledge required for maintenance. Since domain- and project-specific knowledge changes over time, we show how our approach copes with changes efficiently, so that the affected knowledge remains consistent. The shared use of knowledge significantly reduce the complexity and effort to model required knowledge in various projects. Our case study and tool implementation shows the benefits for maintaining secure systems. } } - Jens Bürger, Jan Jürjens, Thomas Ruhroth, Stefan Gärtner, Kurt Schneider: Model-based Security Engineering: Managed Co-Evolution of Security Knowledge and Software Models. In: Alessandro Aldini, Javier Lopez, Fabio Martinelli (editors): Foundations of Security Analysis and Desing VII: FOSAD 2012/2013 Tutorial Lectures, Lecture Notes in Computer Science, vol. 8604, pp. 34-53, 2014.We explain UMLsec and associated techniques to incorporate security aspects in model-based development. Additionally, we show how UMLsec can be used in the context of software evolution. More precisely, we present the SecVolution approach which supports monitoring changes in external security knowledge sources (such as compliance regulations or security databases) in order to react to security related modification and to support the associated co-evolution of the UMLsec models.AbstractBibTeX DOI SpringerLink
@INPROCEEDINGS{fosad14, author = {Jens B\"urger and Jan J{\"u}rjens and Thomas Ruhroth and Stefan G\"artner and Kurt Schneider }, title = {Model-based Security Engineering: Managed Co-Evolution of Security Knowledge and Software Models}, booktitle = {Foundations of Security Analysis and Desing VII: FOSAD 2012/2013 Tutorial Lectures}, year = {2014}, editor = {Aldini, Alessandro and Lopez, Javier and Martinelli, Fabio}, volume = {8604}, series = {Lecture Notes in Computer Science}, pages={34-53}, url={http://dx.doi.org/10.1007/978-3-319-10082-1_2}, doi={10.1007/978-3-319-10082-1_2}, file={SpringerLink:http://link.springer.com/chapter/10.1007/978-3-319-10082-1_2:URL}, abstract = {We explain UMLsec and associated techniques to incorporate security aspects in model-based development. Additionally, we show how UMLsec can be used in the context of software evolution. More precisely, we present the SecVolution approach which supports monitoring changes in external security knowledge sources (such as compliance regulations or security databases) in order to react to security related modification and to support the associated co-evolution of the UMLsec models.} } - Steffen Becker, Matthias Riebisch, Benjamin Klatt, Stefan Sauer, Thomas Ruhroth: Modellbasierte und Modellgetriebene Softwaremodernisierung. In: Softwaretechnik-Trends, vol. 34, no. 2, 2014.BibTeX URL
@article{vorBRKSR14, author = {Steffen Becker and Matthias Riebisch and Benjamin Klatt and Stefan Sauer and Thomas Ruhroth}, title = {Modellbasierte und Modellgetriebene Softwaremodernisierung}, journal = {Softwaretechnik-Trends}, volume = {34}, number = {2}, year = {2014}, url = {http://pi.informatik.uni-siegen.de/stt/34_2/01_Fachgruppenberichte/MMSM2014/MMSM2014_Intro.pdf}, timestamp = {Tue, 24 Feb 2015 17:16:40 +0100}, } - Robert Heinrich, Reiner Jung, Marco Konersmann, Thomas Ruhroth, Eric Schmieders: 1st Colloborative Workshop on Evolution and Maintenance of Long-Living-Systems (EMLS14). In: Wilhelm Hasselbring, Nils Christian Ehmke (editors): Software Engineering 2014, Fachtagung des GI-Fachbereichs Softwaretechnik, 25. Februar - 28. Februar 2014, Kiel, Deutschland, GI, LNI, vol. 227, pp. 203-204, 2014.BibTeX
@inproceedings{HeinrichJKRS14, author = {Robert Heinrich and Reiner Jung and Marco Konersmann and Thomas Ruhroth and Eric Schmieders}, editor = {Wilhelm Hasselbring and Nils Christian Ehmke}, title = {1st Colloborative Workshop on Evolution and Maintenance of Long-Living-Systems {(EMLS14)}}, booktitle = {Software Engineering 2014, Fachtagung des GI-Fachbereichs Softwaretechnik, 25. Februar - 28. Februar 2014, Kiel, Deutschland}, series = {{LNI}}, volume = {227}, pages = {203--204}, publisher = {{GI}}, year = {2014} } - Klaus Schmid, Wolfgang Böhm, Robert Heinrich, Andrea Herrmann, Anne Hoffmann, Dieter Landes, Marco Konersmann, Thomas Ruhroth, Oliver Sander, Volker Stolz, Baltasar Trancòn-y-Widemann, Rüdiger Weißbach (editors): Gemeinsamer Tagungsband der Workshops der Tagung Software Engineering 2014, 25.-26. Februar 2014 in Kiel, Deutschland, CEUR-WS.org, CEUR Workshop Proceedings, vol. 1129, 2014.BibTeX URL
@proceedings{DBLP:conf/se/2014w, editor = {Klaus Schmid and Wolfgang B{\"{o}}hm and Robert Heinrich and Andrea Herrmann and Anne Hoffmann and Dieter Landes and Marco Konersmann and Thomas Ruhroth and Oliver Sander and Volker Stolz and Baltasar Tranc{\'{o}}n{-}y{-}Widemann and R{\"{u}}diger Wei{\ss}bach}, title = {Gemeinsamer Tagungsband der Workshops der Tagung Software Engineering 2014, 25.-26. Februar 2014 in Kiel, Deutschland}, series = {{CEUR} Workshop Proceedings}, year = {2014}, volume = {1129}, publisher = {CEUR-WS.org}, url = {http://ceur-ws.org/Vol-1129} } - Stefan Gärtner, Thomas Ruhroth, Jens Bürger, Kurt Schneider, Jan Jürjens: Maintaining Requirements for Long-Living Software Systems by Incorporating Security Knowledge. In: 22nd IEEE International Requirements Engineering Conference, IEEE, 2014.ASecurity is an increasingly important quality facet in modern information systems and needs to be retained. Due to a constantly changing environment, long-living software systems “age” not by wearing out, but by failing to keep up-to- date with their environment. The problem is that requirements engineers usually do not have a complete overview of the security-related knowledge necessary to retain security of long-living software systems. This includes security standards, principles and guidelines as well as reported security incidents. In this paper, we focus on the identification of known vulnerabilities (and their variations) in natural-language requirements by leveraging security knowledge. For this purpose, we present an integrative security knowledge model and a heuristic method to detect vulnerabilities in requirements based on reported security incidents. To support knowledge evolution, we further propose a method based on natural language analysis to refine and to adapt security knowledge. Our evaluation indicates that the proposed assessment approach detects vulnerable requirements more reliable than other methods (Bayes, SVM, k-NN). Thus, requirements engineers can react faster and more effectively to a changing environment that has an impact on the desired security level of the information system.AbstractBibTeX DOI
@InProceedings{re14GRBSJ, author = {Stefan G\"artner and Thomas Ruhroth and Jens B\"urger and Kurt Schneider and Jan J\"urjens}, title = {Maintaining Requirements for Long-Living Software Systems by Incorporating Security Knowledge}, booktitle = {22nd IEEE International Requirements Engineering Conference}, year = {2014}, organization = {IEEE}, abstract = {ASecurity is an increasingly important quality facet in modern information systems and needs to be retained. Due to a constantly changing environment, long-living software systems “age” not by wearing out, but by failing to keep up-to- date with their environment. The problem is that requirements engineers usually do not have a complete overview of the security-related knowledge necessary to retain security of long-living software systems. This includes security standards, principles and guidelines as well as reported security incidents. In this paper, we focus on the identification of known vulnerabilities (and their variations) in natural-language requirements by leveraging security knowledge. For this purpose, we present an integrative security knowledge model and a heuristic method to detect vulnerabilities in requirements based on reported security incidents. To support knowledge evolution, we further propose a method based on natural language analysis to refine and to adapt security knowledge. Our evaluation indicates that the proposed assessment approach detects vulnerable requirements more reliable than other methods (Bayes, SVM, k-NN). Thus, requirements engineers can react faster and more effectively to a changing environment that has an impact on the desired security level of the information system.}, doi = {10.1109/RE.2014.6912252} } - Thorsten Humberg, Christian Wessel, Daniel Poggenpohl, Sven Wenzel, Thomas Ruhroth, Jan Jürjens: Using Ontologies to Analyze Compliance Requirements of Cloud-Based Processes. In: Cloud Computing and Services Science (Revised Selected Papers), Springer, LNCS, vol. 453, 2014.In recent years, the concept of cloud computing has seen a significant growth. The spectrum of available services covers most, if not all, aspects needed in existing business processes, allowing companies to outsource large parts of their IT infrastructure to cloud service providers. While this prospect might offer considerable economic advantages, it is hindered by concerns regarding information security as well as compliance issues. Relevant regulations are imposed by several sources, like legal regulations or standards for information security, amounting to an extend that makes it difficult to identify those aspects relevant for a given company. In order to support the identification of relevant regulations, we developed an approach to represent regulations in the form of ontologies, which can then be used to examine a given system for compliance requirements. Additional tool support is offered to check system models for certain properties that have been found relevant.AbstractBibTeX SpringerLink
@INPROCEEDINGS{closer13selected, author = {Thorsten Humberg and Christian Wessel and Daniel Poggenpohl and Sven Wenzel and Thomas Ruhroth and Jan J\"urjens}, title = {Using Ontologies to Analyze Compliance Requirements of Cloud-Based Processes}, booktitle = {Cloud Computing and Services Science (Revised Selected Papers)}, editors = {Markus Helfert and Frédéric Desprez and Donald Ferguson and Frank Leymann}, year = {2014}, volume = {453}, series = {LNCS}, publisher = {Springer}, TBDfile = {preprint:http\://rgse.uni-koblenz.de/secse/pages/people/juerjens/publications/papers/closer13selected.pdf:URL}, file = {SpringerLink:http://link.springer.com/chapter/10.1007/978-3-319-11561-0_3:URL}, TBDpages = {36-51}, abstract = { In recent years, the concept of cloud computing has seen a significant growth. The spectrum of available services covers most, if not all, aspects needed in existing business processes, allowing companies to outsource large parts of their IT infrastructure to cloud service providers. While this prospect might offer considerable economic advantages, it is hindered by concerns regarding information security as well as compliance issues. Relevant regulations are imposed by several sources, like legal regulations or standards for information security, amounting to an extend that makes it difficult to identify those aspects relevant for a given company. In order to support the identification of relevant regulations, we developed an approach to represent regulations in the form of ontologies, which can then be used to examine a given system for compliance requirements. Additional tool support is offered to check system models for certain properties that have been found relevant. } } - Thomas Ruhroth, Stefan Gärtner, Jens Bürger, Jan Jürjens, Kurt Schneider: Versioning and Evolution Requirements for Model-Based System Development. In: International Workshop on Comparison and Versioning of Software Models (CVSM 2014), Softwaretechnik-Trends, vol. 34/2, pp. 20-24, 2014.Long-living software systems “ages” not by wearing out, but by failing to keep up-to-date with its requirements. Moreover, security is an increasingly important quality facet in modern information systems and needs to be retained properly. In model-based system development, this leads to a continuously changing information system model accordingly. The problem is that software engineers cannot simply overview changes of the system model and their impact on the applied security model. To overcome this problem, a semantic representation of model changes is needed which is determined from fine-grained edit operations. Based on the semantic representation of system model changes, software engineers are supported to choose an evolution strategy of the associated security model. In this paper, we discuss challenges and problems that arise from the granularity of the change operations as well as the selection of different evolution strategies which can be performed interleaved.AbstractBibTeX preprint
@INPROCEEDINGS{cvsm14RGBJS, author = {Thomas Ruhroth and Stefan G\"artner and Jens B\"urger and Jan J{\"u}rjens and Kurt Schneider}, title = {Versioning and Evolution Requirements for Model-Based System Development}, booktitle = {International Workshop on Comparison and Versioning of Software Models (CVSM 2014)}, year = {2014}, keywords = {hotOffThePress, workshop}, file = {preprint:http\://rgse.uni-koblenz.de/secse/pages/people/juerjens/publications/papers/cvsm14.pdf:URL}, pages = {20--24}, volume = {34/2}, series = {Softwaretechnik-Trends}, abstract = {Long-living software systems “ages” not by wearing out, but by failing to keep up-to-date with its requirements. Moreover, security is an increasingly important quality facet in modern information systems and needs to be retained properly. In model-based system development, this leads to a continuously changing information system model accordingly. The problem is that software engineers cannot simply overview changes of the system model and their impact on the applied security model. To overcome this problem, a semantic representation of model changes is needed which is determined from fine-grained edit operations. Based on the semantic representation of system model changes, software engineers are supported to choose an evolution strategy of the associated security model. In this paper, we discuss challenges and problems that arise from the granularity of the change operations as well as the selection of different evolution strategies which can be performed interleaved. } } - Sven Wenzel, Thorsten Humberg, Christian Wessel, Daniel Poggenpohl, Thomas Ruhroth, Jan Jürjens: Ontology-Based Analysis of Compliance and Regulatory Requirements of Business Processes. In: Frédéric Desprez, Donald Ferguson, Ethan Hadar, Frank Leymann, Matthias Jarke, Markus Helfert (editors): CLOSER 2013 - Proceedings of the 3rd International Conference on Cloud Computing and Services Science, Aachen, Germany, 8-10 May, 2013, SciTePress, pp. 553-561, 2013.Despite its significant potential benefits, the concept of Cloud Computing is still regarded with skepticism in most companies. One of the main obstacle is posed by concerns about the systems’ security and compliance issues. Examining system and process models for compliance manually is time-consuming and error-prone, in particular due to the mere extent of potentially relevant sources of security and compliance concerns that have to be considered. This paper proposes techniques to ease these problems by providing support in identifying relevant aspects, as well as suggesting possible methods (from an existing pool of such) to actually check a given model. We developed a two-step approach: At first, we build an ontology to formalize rules from relevant standards, augmented with additional semantic information. This ontology is then utilized in the analysis of an actual model of a system or a business process in order to detect possible compliance obligations.AbstractBibTeX
@INPROCEEDINGS{closer13WHWPRJ, author = {Sven Wenzel and Thorsten Humberg and Christian Wessel and Daniel Poggenpohl and Thomas Ruhroth and Jan J\"urjens}, title = {Ontology-Based Analysis of Compliance and Regulatory Requirements of Business Processes}, booktitle = {{CLOSER} 2013 - Proceedings of the 3rd International Conference on Cloud Computing and Services Science, Aachen, Germany, 8-10 May, 2013}, editor = {Fr{\'{e}}d{\'{e}}ric Desprez and Donald Ferguson and Ethan Hadar and Frank Leymann and Matthias Jarke and Markus Helfert}, year = {2013}, pages = {553--561}, publisher = {SciTePress}, abstract = {Despite its significant potential benefits, the concept of Cloud Computing is still regarded with skepticism in most companies. One of the main obstacle is posed by concerns about the systems’ security and compliance issues. Examining system and process models for compliance manually is time-consuming and error-prone, in particular due to the mere extent of potentially relevant sources of security and compliance concerns that have to be considered. This paper proposes techniques to ease these problems by providing support in identifying relevant aspects, as well as suggesting possible methods (from an existing pool of such) to actually check a given model. We developed a two-step approach: At first, we build an ontology to formalize rules from relevant standards, augmented with additional semantic information. This ontology is then utilized in the analysis of an actual model of a system or a business process in order to detect possible compliance obligations. } } - Stefan Sauer, Benjamin Klatt, Thomas Ruhroth: 5. Workshop Design For Future - Langlebige Softwaresysteme. In: Stefan Kowalewski, Bernhard Rumpe (editors): Software Engineering 2013: Fachtagung des GI-Fachbereichs Softwaretechnik, 26. Februar - 2. März 2013 in Aachen, GI, LNI, vol. 213, pp. 379, 2013.BibTeX URL
@inproceedings{SauerKR13, author = {Stefan Sauer and Benjamin Klatt and Thomas Ruhroth}, title = {5. Workshop Design For Future - Langlebige Softwaresysteme}, booktitle = {Software Engineering 2013: Fachtagung des GI-Fachbereichs Softwaretechnik, 26. Februar - 2. M{\"{a}}rz 2013 in Aachen}, year = {2013}, pages = {379}, editor = {Stefan Kowalewski and Bernhard Rumpe}, publisher = {{GI}}, url = {http://subs.emis.de/LNI/Proceedings/Proceedings213/article30.html}, series = {{LNI}}, volume = {213}, } - Thomas Ruhroth, Jan Jürjens: Supporting Security Assurance in the Context of Evolution: Modular Modeling and Analysis with UMLsec. In: IEEE: 14th International Symposium on High-Assurance Systems Engineering (HASE 2012), IEEE CS, October 2012.Abstract—Developing security-critical software correctly and securely is difficult. To address this problem, there has been a significant amount of work over the last 10 years on providing model-based development approaches based on the Unified Modeling Language which aim to raise the trustworthiness of security-critical systems. However, the fact that software continues to evolve on an ongoing basis, even after the implementation has been shipped to the customer, increases the challenge since in principle, the software has to be reverified after each modification, requiring significant efforts. In particular, as part of the system evolution, the threat model can change against which the design has to be verified. This requires a modular approach to security assurance, since the threat model has to be substituted independently from the design model. In this paper, we present such an approach based on the extension mechanisms available for the Unified Modeling Language (UML), in particular using so-called profiles. This modular approach allows us to define analysis models which can be exchanged easily whenever the threat model changes due to system evolution. We demonstrate the approach in the face of a specific security requirement, namely secure information flow.AbstractBibTeX DOI
@INPROCEEDINGS{RuJu2012, author = {Thomas Ruhroth and Jan J{\"u}rjens}, title = {{Supporting Security Assurance in the Context of Evolution: Modular Modeling and Analysis with UMLsec}}, booktitle = {IEEE: 14th International Symposium on High-Assurance Systems Engineering (HASE 2012)}, year = {2012}, month = {October}, editors = {Victor Winter and Robin Gandhi and Abhishek Parakh}, publisher = {IEEE CS}, doi = {10.1109/HASE.2012.35}, abstract = {Abstract—Developing security-critical software correctly and securely is difficult. To address this problem, there has been a significant amount of work over the last 10 years on providing model-based development approaches based on the Unified Modeling Language which aim to raise the trustworthiness of security-critical systems. However, the fact that software continues to evolve on an ongoing basis, even after the implementation has been shipped to the customer, increases the challenge since in principle, the software has to be reverified after each modification, requiring significant efforts. In particular, as part of the system evolution, the threat model can change against which the design has to be verified. This requires a modular approach to security assurance, since the threat model has to be substituted independently from the design model. In this paper, we present such an approach based on the extension mechanisms available for the Unified Modeling Language (UML), in particular using so-called profiles. This modular approach allows us to define analysis models which can be exchanged easily whenever the threat model changes due to system evolution. We demonstrate the approach in the face of a specific security requirement, namely secure information flow. } } - Martin Ochoa, Sebastian Pape, Thomas Ruhroth, Barbara Sprick, Kurt Stenzel, Henning Sudbrock: Report on the RS3 Topic Workshop ``Security Properties in Software Engineering`` Universitätsbibliothek der Universität Augsburg2012 (Technical Report)BibTeX URL
@TECHREPORT{Ochoa12, author = {Martin Ochoa and Sebastian Pape and Thomas Ruhroth and Barbara Sprick and Kurt Stenzel and Henning Sudbrock}, title = {Report on the {RS3} Topic Workshop ``Security Properties in Software Engineering``}, institution = {Universit\"atsbibliothek der Universit\"at Augsburg}, year = {2012}, address = {Universit\"atsstr. 22, 86159 Augsburg}, language = {eng}, timestamp = {2012.02.09},
liothek.uni-augsburg.de/volltexte/2012/1865/} } - Thomas Ruhroth, Heike Wehrheim: Model evolution and refinement. In: Science of Computer Programming, vol. 77, no. 3, pp. 270 - 289, 2012.Despite the progress in automated planning and scheduling systems, these systems still need to be fed by careful problem description and they need to be fine tuned for particular domains or problems. Knowledge engineering for AI planning and scheduling deals with the acquisition, design, validation and maintenance of domain models, and the selection and optimization of appropriate machinery to work on them. These processes impact directly on the success of real planning and scheduling applications. The importance of knowledge engineering techniques is clearly demonstrated by a performance gap between domain-independent planners and planners exploiting domain dependent knowledge. The KEPS workshop attracts audience interested in bridging the above-described gap between real-life problems and planning and scheduling algorithms. Its topics include domain and problem formulations, languages, knowledge acquisition (e.g. control rules), visualization, validation and analysis of plans/domains, problem (re)formulation etc. The workshop will consist of presentations of technical papers that will be immediately commented by other researchers, it will include a demo session where existing systems will be presented, and it will be concluded by an open discussion on the next ICKEPS competition.AbstractBibTeX DOI
@ARTICLE{RW2012, author = {Thomas Ruhroth AND Heike Wehrheim}, title = {Model evolution and refinement}, journal = {Science of Computer Programming}, year = {2012}, volume = {77}, pages = {270 - 289}, number = {3}, doi = {10.1016/j.scico.2011.04.007}, abstract = {Despite the progress in automated planning and scheduling systems, these systems still need to be fed by careful problem description and they need to be fine tuned for particular domains or problems. Knowledge engineering for AI planning and scheduling deals with the acquisition, design, validation and maintenance of domain models, and the selection and optimization of appropriate machinery to work on them. These processes impact directly on the success of real planning and scheduling applications. The importance of knowledge engineering techniques is clearly demonstrated by a performance gap between domain-independent planners and planners exploiting domain dependent knowledge. The KEPS workshop attracts audience interested in bridging the above-described gap between real-life problems and planning and scheduling algorithms. Its topics include domain and problem formulations, languages, knowledge acquisition (e.g. control rules), visualization, validation and analysis of plans/domains, problem (re)formulation etc. The workshop will consist of presentations of technical papers that will be immediately commented by other researchers, it will include a demo session where existing systems will be presented, and it will be concluded by an open discussion on the next ICKEPS competition. }, publisher = {Science of Computer Programming} } - Thomas Ruhroth, Heike Wehrheim, Steffen Ziegert: ReL: A Generic Refactoring Language for Specification and Execution. In: 37th EUROMICRO Conference on Software Engineering and Advanced Application (SEAA 2011), IEEE Computer Society, 2011.Refactoring is a powerful technique for improving the structural quality of software models and programs. Besides informal, example-driven descriptions of refactorings, a number of languages for specifying refactorings have been developed. Such refactoring languages are either specific to particular programming languages or to particular application purposes. In this paper, we present the generic refactoring language ReL. ReL is a domain-specific language which can be instantiated for any target language with Backus-Naur-style grammar. Thus obtained ReL instances are equally well suited for specifying refactorings and executing them. A tool chain for ReL supports the automatic instantiation for target languages as well as the parsing and execution of refactoring descriptions.AbstractBibTeX DOI
@INPROCEEDINGS{RWZ2011, author = {Thomas Ruhroth AND Heike Wehrheim AND Steffen Ziegert}, title = {ReL: A Generic Refactoring Language for Specification and Execution}, booktitle = {37th EUROMICRO Conference on Software Engineering and Advanced Application (SEAA 2011)}, year = {2011}, publisher = {IEEE Computer Society}, abstract = {Refactoring is a powerful technique for improving the structural quality of software models and programs. Besides informal, example-driven descriptions of refactorings, a number of languages for specifying refactorings have been developed. Such refactoring languages are either specific to particular programming languages or to particular application purposes. In this paper, we present the generic refactoring language ReL. ReL is a domain-specific language which can be instantiated for any target language with Backus-Naur-style grammar. Thus obtained ReL instances are equally well suited for specifying refactorings and executing them. A tool chain for ReL supports the automatic instantiation for target languages as well as the parsing and execution of refactoring descriptions.}, doi = {http://dx.doi.org/10.1109/SEAA.2011.22} } - Thomas Ruhroth: Generische Refactoring-Spezifikation für Korrektheitsbeweise in mehrsichtigen Modellsprachen Universität Paderborn, 2011 (PhD-Thesis).In software development it is necessary that program code and models can be maintained. Refactoring is a best practice in code development which can be used to improve the internal quality of given code. Refactoring means modifying code without changing its behaviour. It is also desirable to improve the internal quality of formal models. Unlike programs most models are not executable. Thus, refactoring techniques need to be adapted. For example, a suitable definition of behaviour preservation is needed. A technique often used in the context of models is the usage of multiple views on one model, e.g. to specify several aspects using different diagrams. This also implies the need to adapt existing refactoring techniques. The aim of this work is to describe refactorings of formal models and to ensure the behaviour preservation of these refactorings. The language family ReL (Refactoring Language) is used to describe refactorings of simple imperative programs (FWHILE) and specifications given in an integrated formal method (CSP-OZ). In particular, the structure of ReL allows proving behaviour preservation without transferring the refactoring to a different representation. ReL uses templates to describe the state of the code before and after the refactoring. These templates are divided into subtemplates. These subtemplates can be used in different views and therefore provide the possibility to describe multi-view refactorings. Also the structure of ReL allows a refactoring to be applied to a model as well as the formal analysis. ReL is derived using techniques of \emph {Domain Specific Languages}. Thus, ReL depends on the syntax definition of the language to be refactored. This process allows ReL to derive a ReL-Instance for all languages that be described as Backus-Naur Form (BNF). The application is therefore not restricted to formal model languages, but can also be applied to programming languages. The preservation of the behaviour can be proved using these templates. Techniques are presented to simplify these proofs. Observation points will help to reduce the actual proof to a certain area in the semantics of the model. Also the techniques for multi view models will be derived out of observation point. Three different types of interactions are distinguishable. Refactorings affecting a single view, refactorings with condition to other views, and refactorings with effects on multiple views.AbstractBibTeX
@PHDTHESIS{Tr11, author = {Thomas Ruhroth}, title = {Generische Refactoring-Spezifikation f\"ur Korrektheitsbeweise in mehrsichtigen Modellsprachen}, school = {Universit\"at Paderborn}, year = {2011}, abstract = { In software development it is necessary that program code and models can be maintained. Refactoring is a best practice in code development which can be used to improve the internal quality of given code. Refactoring means modifying code without changing its behaviour. It is also desirable to improve the internal quality of formal models. Unlike programs most models are not executable. Thus, refactoring techniques need to be adapted. For example, a suitable definition of behaviour preservation is needed. A technique often used in the context of models is the usage of multiple views on one model, e.g. to specify several aspects using different diagrams. This also implies the need to adapt existing refactoring techniques. The aim of this work is to describe refactorings of formal models and to ensure the behaviour preservation of these refactorings. The language family ReL (Refactoring Language) is used to describe refactorings of simple imperative programs (FWHILE) and specifications given in an integrated formal method (CSP-OZ). In particular, the structure of ReL allows proving behaviour preservation without transferring the refactoring to a different representation. ReL uses templates to describe the state of the code before and after the refactoring. These templates are divided into subtemplates. These subtemplates can be used in different views and therefore provide the possibility to describe multi-view refactorings. Also the structure of ReL allows a refactoring to be applied to a model as well as the formal analysis. ReL is derived using techniques of \emph {Domain Specific Languages}. Thus, ReL depends on the syntax definition of the language to be refactored. This process allows ReL to derive a ReL-Instance for all languages that be described as Backus-Naur Form (BNF). The application is therefore not restricted to formal model languages, but can also be applied to programming languages. The preservation of the behaviour can be proved using these templates. Techniques are presented to simplify these proofs. Observation points will help to reduce the actual proof to a certain area in the semantics of the model. Also the techniques for multi view models will be derived out of observation point. Three different types of interactions are distinguishable. Refactorings affecting a single view, refactorings with condition to other views, and refactorings with effects on multiple views.} } - Thomas Ruhroth, Heike Wehrheim: Refinement-Preserving Co-evolution. In: Karin Breitman, Ana Cavalcanti (editors): Formal Methods and Software Engineering, 11th International Conference on Formal Engineering Methods, ICFEM 2009, Rio de Janeiro, Brazil, December 9-12, 2009., Springer, pp. 620-638, 2009.Software changes during its lifetime. Likewise, specifications change during their design time, e.g. by removing, adding or changing operations. In a refinement-based approach to software design, we moreover do not deal with a single but with a chain of specifications, related via refinement. Changes thus need to be consistently made to all specifications in the chain so as to keep the refinement structure. In this paper, we describe such co-evolutions of specifications in the context of the formal method Object-Z. More specifically, given a particular evolution of a specification we show how to construct a corresponding evolution for its refinements. We furthermore formally prove our co-evolutions to maintain refinement, thus giving rise to a notion of refinement-preserving co-evolution.AbstractBibTeX DOI SpringerLink
@INPROCEEDINGS{Ruhroth2009, author = {Thomas Ruhroth AND Heike Wehrheim}, title = {Refinement-Preserving Co-evolution}, booktitle = {Formal Methods and Software Engineering, 11th International Conference on Formal Engineering Methods, ICFEM 2009, Rio de Janeiro, Brazil, December 9-12, 2009.}, year = {2009}, editor = {Karin Breitman and Ana Cavalcanti}, volume = {5885}, pages = {620--638}, publisher = {Springer}, abstract = {Software changes during its lifetime. Likewise, specifications change during their design time, e.g. by removing, adding or changing operations. In a refinement-based approach to software design, we moreover do not deal with a single but with a chain of specifications, related via refinement. Changes thus need to be consistently made to all specifications in the chain so as to keep the refinement structure. In this paper, we describe such co-evolutions of specifications in the context of the formal method Object-Z. More specifically, given a particular evolution of a specification we show how to construct a corresponding evolution for its refinements. We furthermore formally prove our co-evolutions to maintain refinement, thus giving rise to a notion of refinement-preserving co-evolution. }, file = {SpringerLink:http://link.springer.com/chapter/10.1007/978-3-642-10373-5_32:URL}, doi = {http://dx.doi.org/10.1007/978-3-642-10373-5_32}, url={http://dx.doi.org/10.1007/978-3-642-10373-5_32} } - Thomas Ruhroth, Heike Wehrheim: Static Class Elements for Object-Z. In: Proceedings of the 14th BCS-FACS Refinement Workshop (REFINE 2009), Elsevier, pp. 193-205, Dezember 2009.Static variables and methods are part of almost every modern object-oriented programming language. Static elements are for instance indispensable for certain kinds of design patterns applied during programming. Object-oriented specification formalisms on the other hand lack such concepts. This can prevent writing formal specifications close to the actual implementation, and can thus hamper a refinement-based stepwise development. In this paper, we extend the state-based object-oriented specification language Object-Z with a concept for static class elements. We furthermore show how refinement can introduce static elements into a specification.AbstractBibTeX DOI
@INPROCEEDINGS{RW09, author = {Thomas Ruhroth AND Heike Wehrheim}, title = {Static Class Elements for {Object-Z}}, booktitle = {Proceedings of the 14th BCS-FACS Refinement Workshop (REFINE 2009)}, year = {2009}, volume = {259}, pages = {193--205}, month = {Dezember}, publisher = {Elsevier}, abstract = {Static variables and methods are part of almost every modern object-oriented programming language. Static elements are for instance indispensable for certain kinds of design patterns applied during programming. Object-oriented specification formalisms on the other hand lack such concepts. This can prevent writing formal specifications close to the actual implementation, and can thus hamper a refinement-based stepwise development. In this paper, we extend the state-based object-oriented specification language Object-Z with a concept for static class elements. We furthermore show how refinement can introduce static elements into a specification.}, doi = {http://dx.doi.org/10.1016/j.entcs.2009.12.025} } - Hendrik Voigt, Thomas Ruhroth, Heike Wehrheim: Measure, diagnose, refactor: A formal quality cycle for software Models. In: 35th EUROMICRO Conference on Software Engineering and Advanced Applications (SEAA), IEEE Computer Society, pp. 360-367, 2009.Software changes during its lifetime. Likewise, specifications change during their design time, e.g. by removing, adding or changing operations. In a refinement-based approach to software design, we moreover do not deal with a single but with a chain of specifications, related via refinement. Changes thus need to be consistently made to all specifications in the chain so as to keep the refinement structure. In this paper, we describe such co-evolutions of specifications in the context of the formal method Object-Z. More specifically, given a particular evolution of a specification we show how to construct a corresponding evolution for its refinements. We furthermore formally prove our co-evolutions to maintain refinement, thus giving rise to a notion of refinement-preserving co-evolution.AbstractBibTeX DOI
@INPROCEEDINGS{VRW09, author = {Hendrik Voigt AND Thomas Ruhroth AND Heike Wehrheim}, title = {Measure, diagnose, refactor: A formal quality cycle for software Models}, booktitle = {35th EUROMICRO Conference on Software Engineering and Advanced Applications (SEAA)}, year = {2009}, pages = {360--367}, publisher = {IEEE Computer Society}, doi = {http://dx.doi.org/10.1007/978-3-642-10373-5_32}, abstract = { Software changes during its lifetime. Likewise, specifications change during their design time, e.g. by removing, adding or changing operations. In a refinement-based approach to software design, we moreover do not deal with a single but with a chain of specifications, related via refinement. Changes thus need to be consistently made to all specifications in the chain so as to keep the refinement structure. In this paper, we describe such co-evolutions of specifications in the context of the formal method Object-Z. More specifically, given a particular evolution of a specification we show how to construct a corresponding evolution for its refinements. We furthermore formally prove our co-evolutions to maintain refinement, thus giving rise to a notion of refinement-preserving co-evolution. } } - Hendrik Voigt, Thomas Ruhroth: A Quality Circle Tool for Software Models. In: Qing Li, Stefano Spaccapietra, Eric Yu, Antoni Olivé (editors): Proceedings of the 27th International Conference on Conceptual Modeling (ER 2008), Barcelona, Spain, Springer, pp. 526-527, October 2008.The quality management of software models is an important issue. As a preparative task, the quality circle requires quality planning. After that a software model can repeat the sequence: quality measurement, quality analysis, and quality improvement. Until now, existing tools lack support for all these activities at once. Therefore, we developed and implemented concepts that provide the full quality circle for software models. The considered models are mainly represented in the syntax of UML class and statechart diagrams and their semantics are formally defined. The formal semantics of the considered software models allows us to improve them while preserving their external behavior.AbstractBibTeX DOI SpringerLink
@INPROCEEDINGS{VoigtR08, author = {Hendrik Voigt AND Thomas Ruhroth}, title = {A Quality Circle Tool for Software Models}, booktitle = {Proceedings of the 27th International Conference on Conceptual Modeling (ER 2008), Barcelona, Spain}, year = {2008}, editor={Li, Qing and Spaccapietra, Stefano and Yu, Eric and Olivé, Antoni}, volume = {5231}, pages = {526--527}, month = {October}, publisher = {Springer}, abstract = {The quality management of software models is an important issue. As a preparative task, the quality circle requires quality planning. After that a software model can repeat the sequence: quality measurement, quality analysis, and quality improvement. Until now, existing tools lack support for all these activities at once. Therefore, we developed and implemented concepts that provide the full quality circle for software models. The considered models are mainly represented in the syntax of UML class and statechart diagrams and their semantics are formally defined. The formal semantics of the considered software models allows us to improve them while preserving their external behavior.}, doi = {http://dx.doi.org/10.1007/978-3-540-87877-3_44}, url={http://dx.doi.org/10.1007/978-3-540-87877-3_44}, file={SpringerLink:http://link.springer.com/chapter/10.1007/978-3-540-87877-3_44:URL}, } - H. Estler, Thomas Ruhroth, Heike Wehrheim: Modelchecking Correctness of Refactorings - Some Experiments. In: B. Aichernig, E. Boiten, J. Derrick, L. Groves (editors): Proceedings REFINE 2006, Elsevier, pp. 3-17, 2007.Refactorings are changes made to programs, models or specifications with the intention of improving their structure and thus making them clearer, more readable and re-usable. Refactorings are required to be behaviour-preserving in that the external behaviour of the program/model/specification remains unchanged. In this paper we show how a simple type of refactorings on object-oriented specifications (written in Object-Z) can be formally shown to be behaviour-preserving using a modelchecker (SAL). The class of refactorings treated covers those operating on a single method only.AbstractBibTeX DOI
@INPROCEEDINGS{ERW07, author = {H. Estler AND Thomas Ruhroth AND Heike Wehrheim}, title = {Modelchecking Correctness of Refactorings - Some Experiments}, booktitle = {Proceedings REFINE 2006}, year = {2007}, editor = {B. Aichernig and E. Boiten and J. Derrick and L. Groves}, volume = {187}, pages = {3-17}, publisher = {Elsevier}, abstract = {Refactorings are changes made to programs, models or specifications with the intention of improving their structure and thus making them clearer, more readable and re-usable. Refactorings are required to be behaviour-preserving in that the external behaviour of the program/model/specification remains unchanged. In this paper we show how a simple type of refactorings on object-oriented specifications (written in Object-Z) can be formally shown to be behaviour-preserving using a modelchecker (SAL). The class of refactorings treated covers those operating on a single method only.}, doi = {http://dx.doi.org/10.1016/j.entcs.2006.08.041} } - Thomas Ruhroth, Heike Wehrheim: Refactoring Object-Oriented Specifications with Data and Processes. In: MarcelloM. Bonsangue, EinarBroch Johnsen (editors): Formal Methods for Open Object-Based Distributed Systems, 9th IFIP WG 6.1 International Conference, FMOODS 2007, Springer, Lecture Notes in Computer Science, vol. 4468, pp. 236-251, June 2007.Refactoring is a method for improving the structure of programs/specifications as to enhance readability, modularity and reusability. Refactorings are required to be behaviour-preserving in that – to an external observer – no difference between the program before and after refactoring is visible. In this paper, we develop refactorings for an object-oriented specification formalism combining a state-based language (Object-Z) with a process algebra (CSP). In contrast to OO-programming languages, refactorings moving methods or attributes up and down the class hierarchy, in addition, need to change CSP processes. We formally prove behaviour preservation with respect to the failures-divergences model of CSP.AbstractBibTeX DOI SpringerLink
@INPROCEEDINGS{RW07, author = {Thomas Ruhroth AND Heike Wehrheim}, title = {Refactoring Object-Oriented Specifications with Data and Processes}, booktitle = {Formal Methods for Open Object-Based Distributed Systems, 9th IFIP WG 6.1 International Conference, FMOODS 2007}, year = {2007}, editor={Bonsangue, MarcelloM. and Johnsen, EinarBroch}, volume = {4468}, pages = {236-251}, month = {June}, series = {Lecture Notes in Computer Science}, publisher = {Springer}, abstract = {Refactoring is a method for improving the structure of programs/specifications as to enhance readability, modularity and reusability. Refactorings are required to be behaviour-preserving in that – to an external observer – no difference between the program before and after refactoring is visible. In this paper, we develop refactorings for an object-oriented specification formalism combining a state-based language (Object-Z) with a process algebra (CSP). In contrast to OO-programming languages, refactorings moving methods or attributes up and down the class hierarchy, in addition, need to change CSP processes. We formally prove behaviour preservation with respect to the failures-divergences model of CSP. }, doi = {http://dx.doi.org/10.1007/978-3-540-72952-5_15}, url={http://dx.doi.org/10.1007/978-3-540-72952-5_15}, file = {SpringerLink:http://link.springer.com/chapter/10.1007/978-3-540-72952-5_15:URL}, } - Thomas Ruhroth: Refactoring Object-Z Specifications. In: 18th Nordic Workshop on Programming Theory, 2006.BibTeX
@INPROCEEDINGS{Ru06, author = {Thomas Ruhroth}, title = {Refactoring {Object-Z} Specifications}, booktitle = {18th Nordic Workshop on Programming Theory}, year = {2006} }