# This BibTeX File has been generated by # the Typo3 extension 'Sixpack-4-T3 by Sixten Boeck' # # URL: # Date: 06/26/2017 # Non-Standard BibTex fields are included. # state: 0 = published, 1 = accepted, 2 = submitted, 3 = to be published // if missing, published is assumed # extern,deleted,hidden: 0 = false, 1 = true // if missing, false is assumed # link format: Title Url // separated by a whitespace @book{ITS08, author = { Michael Perscheid and David Tibbe and Martin Beck and Stefan Berger and Peter Osburg and Jeff Eastman and Michael Haupt and Robert Hirschfeld }, title = { An Introduction to Seaside }, year = { 2008 }, pages = { 210 }, abstract = { Seaside is a Web development framework implemented in Smalltalk. It allows the easy creation of powerful Web applications using high level abstractions on the application components and on the underlying hypertext transfer protocol. In doing so, it builds upon the strengths of the Smalltalk object-oriented programming language and transcends many of the common practices needed in other, less dynamic languages. This book explains the major concepts of Seaside in a clear and intuitive style. A working example of a ToDo List application is developed to illustrate the framework's important concepts that build upon each other in an orderly progression. Besides the notions of users, tasks, components, forms and deployment, additional topics such as persistence, Ajax and Magritte are also discussed. }, url = { http://www.hpi.uni-potsdam.de/swa/seaside/tutorial }, publisher = { Software Architecture Group (Hasso-Plattner-Institut) }, isbn = { 978-3-00-023645-7 }, sorting = { 17920 } } @conference{Oleksandr2010a, author = { Oleksandr Panchenko,Alexander Koglin,Johannes Bohnet,Alexander Zeier }, title = { An XPath-based Query Language for Trace Analysis }, year = { 2010 }, booktitle = { 5th International Workshop on Program Comprehension through Dynamic Analysis (PCODA), co-located with WCRE, Boston, USA }, sorting = { 44288 } } @incollection{LSHD2017, author = { Limberger, Daniel and Scheibel, Willy and Hahn, Sebastian and D{\"o}llner, J{\"u}rgen }, title = { Reducing Visual Complexity in Software Maps using Importance-based Aggregation of Nodes }, year = { 2017 }, abstract = {

Depicting massive software system data using software maps can result in visual clutter and increased cognitive load. This paper introduces an adaptive level-of-detail (LoD) technique that uses scoring for interactive aggregation on a per-node basis. The scoring approximates importance by degree-of-interest measures as well as screen and user-interaction scores. The technique adheres to established aggregation guidelines and was evaluated by means of two user studies. The first user study investigates task completion time in visual search. The second evaluates the readability of the presented nesting level contouring for aggregates. With the adap- tive LoD technique software maps allow for multi-resolution depictions of software system information. It facilitates efficient identification of important nodes and allows for additional annotation.

© The Authors 2017. This is the authors' version of the work. It is posted here for your personal use. Not for redistribution. The definitive version will be published in Proceedings of the 8th International Conference on Information Visualization Theory and Applications (IVAPP 2017).
}, affiliation = { Hasso Plattner Institute, University of Potsdam }, series = { IVAPP 2017 }, booktitle = { Proceedings of the 8th International Conference on Information Visualization Theory and Applications }, project = { NFGII;HPI }, files = { fileadmin/user_upload/fachgebiete/doellner/publications/2017/LSHD2017/LSHD2017.pdf }, sorting = { 1 } } @incollection{SEfSAS2-ROADMAP, author = { Rogério de Lemos and Holger Giese and Hausi A. Müller and Mary Shaw and Jesper Andersson and Marin Litoiu and Bradley Schmerl and Gabriel Tamura and Norha M. Villegas and Thomas Vogel and Danny Weyns and Luciano Baresi and Basil Becker and Nelly Bencomo and Yuriy Brun and Bojan Cukic and Ron Desmarais and Schahram Dustdar and Gregor Engels and Kurt Geihs and Karl Goeschka and Alessandra Gorla and Vincenzo Grassi and Paola Inverardi and Gabor Karsai and Jeff Kramer and Antónia Lopes and Jeff Magee and Sam Malek and Serge Mankovskii and Raffaela Mirandola and John Mylopoulos and Oscar Nierstrasz and Mauro Pezzè and Christian Prehofer and Wilhelm Schäfer and Rick Schlichting and Dennis B. Smith and Joao P. Sousa and Ladan Tahvildari and Kenny Wong and Jochen Wuttke }, title = { Software Engineering for Self-Adaptive Systems: A second Research Roadmap }, year = { 2013 }, volume = { 7475 }, pages = { 1-32 }, month = { 1 }, abstract = { The goal of this roadmap paper is to summarize the state-of-the-art and identify research challenges when developing, deploying and managing self-adaptive software systems. Instead of dealing with a wide range of topics associated with the field, we focus on four essential topics of self-adaptation: design space for self-adaptive solutions, software engineering processes for self-adaptive systems, from centralized to decentralized control, and practical run-time verification & validation for self-adaptive systems. For each topic, we present an overview, suggest future directions, and focus on selected challenges. This paper complements and extends a previous roadmap on software engineering for self-adaptive systems published in 2009 covering a different set of topics, and reflecting in part on the previous paper. This roadmap is one of the many results of the Dagstuhl Seminar 10431 on Software Engineering for Self-Adaptive Systems, which took place in October 2010. }, editor = { Rogério de Lemos and Holger Giese and Hausi A. Müller and Mary Shaw }, publisher = { Springer-Verlag }, series = { Lecture Notes in Computer Science (LNCS) }, booktitle = { Software Engineering for Self-Adaptive Systems II }, project = { mrt }, doi = { 10.1007/978-3-642-35813-5_1 }, sorting = { 5376 } } @incollection{GL+12, author = { Holger Giese and Leen Lambers and Basil Becker and Stephan Hildebrandt and Stefan Neumann and Thomas Vogel and Sebastian Wätzoldt }, title = { Graph Transformations for MDE, Adaptation, and Models at Runtime }, year = { 2012 }, volume = { 7320 }, pages = { 137-191 }, month = { 6 }, abstract = { Software evolution and the resulting need to continuously adapt the software is one of the main challenges for software engineering. The model-driven development movement therefore aims at improving the longevity of software by keeping the development artifacts more consistent and better changeable by employing models and to a certain degree automated model operations. Another trend are systems that tackle the challenge at runtime by being able to adapt their structure and behavior to be more flexible and operate in more dynamic environments (e.g., context-aware software, autonomic computing, self-adaptive software). Finally, models at runtime, where the benefits of model-driven development are employed at runtime to support adaptation capabilities, today lead towards a unification of both ideas. In this paper, we present graph transformations and show that they can be employed to engineer solutions for all three outlined cases. Furthermore, we will even be able to demonstrate that graph transformation based technology has the potential to also unify all three cases in a single scenario where models at runtime and runtime adaptation is linked with classical MDE. Therefore, we at first provide an introduction in graph transformations, then present the related techniques of Story Pattern and Triple Graph Grammars, and demonstrate how with the help of both techniques model transformations, adaptation behavior and runtime model framework work. In addition, we show that due to the formal underpinning analysis becomes possible and report about a number of successful examples. }, editor = { Marco Bernardo and Vittorio Cortellessa and Alfonso Pierantonio }, publisher = { Springer-Verlag }, series = { Lecture Notes in Computer Science (LNCS) }, booktitle = { Formal Methods for Model-Driven Engineering }, project = { mrt }, doi = { 10.1007/978-3-642-30982-3_5 }, sorting = { 12032 } } @incollection{VogelNHGB10, author = { Thomas Vogel and Stefan Neumann and Stephan Hildebrandt and Holger Giese and Basil Becker }, title = { Incremental Model Synchronization for Efficient Run-Time Monitoring }, year = { 2010 }, volume = { 6002 }, pages = { 124-139 }, month = { 4 }, abstract = { The model-driven engineering community has developed expressive model transformation techniques based on metamodels, which ease the specification of translations between different model types. Thus, it is attractive to also apply these techniques for autonomic and self- adaptive systems at run-time to enable a comprehensive monitoring of their architectures while reducing development efforts. This requires special solutions for model transformation techniques as they are applied at run-time instead of their traditional usage at development time. In this paper we present an approach to ease the development of architectural monitoring based on incremental model synchronization with triple graph grammars. We show that the provided incremental synchronization between a running system and models for different self-management capabilities provides a significantly better compromise between performance and development costs than manually developed solutions. }, editor = { Sudipto Ghosh }, publisher = { Springer-Verlag }, series = { Lecture Notes in Computer Science (LNCS) }, booktitle = { Models in Software Engineering, Workshops and Symposia at MODELS 2009, Denver, CO, USA, October 4-9, 2009, Reports and Revised Selected Papers }, project = { mrt }, files = { EXT: pdf/VogelNHGB10_mrt09lncs.pdf }, isbn = { 978-3-642-12260-6 }, issn = { 0302-9743 (Print) 1611-3349 (Online) }, doi = { 10.1007/978-3-642-12261-3_13 }, link1 = { http://www.springerlink.com/content/1518022k168n5055/ }, sorting = { 39424 } } @incollection{BSHST10, author = { Basil Becker and Stefan Neumann and Martin Schenk and Arian Treffer and Holger Giese }, title = { Model-Based Extension of AUTOSAR for Architectural Online Reconfiguration }, year = { 2010 }, volume = { 6002 }, pages = { 83-97 }, editor = { Sudipto Ghosh }, publisher = { Springer-Verlag }, series = { Lecture Notes in Computer Science (LNCS) }, booktitle = { Models in Software Engineering, Workshops and Symposia at MODELS 2009, Denver, CO, USA, October 4-9, 2009, Reports and Revised Selected Papers }, isbn = { 978-3-642-12260-6 }, doi = { 10.1007/978-3-642-12261-3_9 }, sorting = { 40192 } } @inproceedings{LFHTD, author = { Limberger, Daniel and Fiedler, Carolin and Hahn, Sebastian and Trapp, Matthias and D{\"o}llner, J{\"u}rgen }, title = { Evaluation of Sketchiness as a Visual Variable for 2.5D Treemaps }, year = { 2016 }, month = { 5 }, abstract = {

Interactive 2.5D treemaps serve as an effective tool for the visualization of attributed hierarchies, enabling exploration of non-spatial, multi-variate, hierarchical data. In this paper the suitability of sketchiness as a visual variable, e.g., for uncertainty, is evaluated. Therefore, a design space for sketchy rendering in 2.5D and integration details for real-time applications are presented. The results of three user studies indicate, that sketchiness is a promising candidate for a visual variable that can be used independently and in addition to others, e.g., color and height.

© The Authors 2016. This is the authors' version of the work. It is posted here for your personal use. Not for redistribution. The definitive version will be published in Proceedings of the 20th International Conference on Information Visualization (IV'16).
}, affiliation = { Hasso-Plattner-Institut, University of Potsdam, Germany }, keywords = { Visual Analytics, 2.5D Treemaps, Sketchiness, Visual Variables, Uncertainty }, booktitle = { Proceedings of the 20th International Conference of Information Visualization (IV'16) }, project = { HPI;NFGII }, sorting = { 2048 } } @inproceedings{RheinlanderBKHSL14, author = { Astrid Rheinländer, Martin Beckmann, Anja Kunkel, Arvid Heise, Thomas Stoltmann, Ulf Leser }, title = { Versatile optimization of UDF-heavy data flows with SOFA (demo) }, year = { 2014 }, pages = { 685-688 }, booktitle = { Proceedings of the SIGMOD conference }, project = { stratosphere }, doi = { http://doi.acm.org/10.1145/2588555.2594517 }, sorting = { 11520 } } @inproceedings{KTD2013, author = { Benjamin Karran and Jonas Trümper and Jürgen Döllner }, title = { SyncTrace: Visual Thread-Interplay Analysis }, year = { 2013 }, pages = { 10 }, month = { 9 }, abstract = { In software comprehension, program traces are important to gain insight into certain aspects of concurrent runtime behavior, e.g., thread-interplay. Here, key tasks are finding usages of blocking operations, such as synchronization and I/O operations, assessing temporal order of such operations, and analyzing their effects. This is a hard task for large and complex program traces due to their size and number of threads involved. In this paper, we present SyncTrace, a new visualization technique based on (bended) activity diagrams and edge bundles that allows for parallel analysis of multiple threads and their inter-thread correspondences. We demonstrate how the technique, implemented as a tool, can be applied on real-world trace datasets to support understanding concurrent behavior. }, keywords = { trace analysis, software visualization, program comprehension, software maintenance, visualization }, publisher = { IEEE Computer Society }, booktitle = { Proceedings (electronic) of the 1st Working Conference on Software Visualization (VISSOFT) }, project = { NFGII }, files = { fileadmin/user_upload/fachgebiete/doellner/publications/2013/KTD2013/synctrace_preprint.pdf }, doi = { 10.1109/VISSOFT.2013.6650534 }, link1 = { Video (YouTube) http://youtu.be/rTQlyVMre_w }, sorting = { 1024 } } @inproceedings{TDT2013, author = { Jonas Trümper and Jürgen Döllner and Alexandru Telea }, title = { Multiscale Visual Comparison of Execution Traces }, year = { 2013 }, pages = { 53-62 }, month = { 5 }, abstract = { Understanding the execution of programs by means of program traces is a key strategy in software comprehension. An important task in this context is comparing two traces in order to find similarities and differences in terms of executed code, execution order, and execution duration. For large and complex program traces, this is a difficult task due to the cardinality of the trace data. In this paper, we propose a new visualization method based on icicle plots and edge bundles. We address visual scalability by several multiscale visualization metaphors, which help users navigating from the main differences between two traces to intermediate structural-difference levels, and, finally fine-grained function call levels. We show how our approach, implemented in a tool called TraceDiff, is applicable in several scenarios for trace difference comprehension on real-world trace datasets. }, keywords = { trace analysis, software visualization, program comprehension, software maintenance, visualization }, publisher = { IEEE Computer Society }, booktitle = { Proceedings of the International Conference on Program Comprehension }, project = { NFGII }, files = { fileadmin/user_upload/fachgebiete/doellner/publications/2013/TDT2013/truemper2013_tracediff_preprint.pdf }, link1 = { Video (YouTube) http://youtu.be/9x2mOsf_fjU }, sorting = { 2304 } } @inproceedings{LWTD2013, author = { Limberger, Daniel and Wasty, Benjamin and Jonas Trümper and Döllner, Jürgen }, title = { Interactive Software Maps for Web-Based Source Code Analysis }, year = { 2013 }, pages = { 8 }, month = { 5 }, abstract = { Software maps -- linking rectangular 3D-Treemaps, software system structure, and performance indicators -- are commonly used to support informed decision making in software-engineering processes. A key aspect for this decision making is that software maps provide the structural context required for correct interpretation of these performance indicators. In parallel, source code repositories and collaboration platforms are an integral part of today's software-engineering tool set, but cannot properly incorporate software maps since implementations are only available as stand-alone applications. Hence, software maps are 'disconnected' from the main body of this tool set, rendering their use and provisioning overly complicated, which is one of the main reasons against regular use. We thus present a web-based rendering system for software maps that achieves both fast client-side page load time and interactive frame rates even with large software maps. We significantly reduce page load time by efficiently encoding hierarchy and geometry data for the net transport. Apart from that, appropriate interaction, layouting, and labeling techniques as well as common image enhancements aid evaluation of project-related quality aspects. Metrics provisioning can further be implemented by predefined attribute mappings to simplify communication of project specific quality aspects. The system is integrated into dashboards to demonstrate how our web-based approach makes software maps more accessible to many different stakeholders in software-engineering projects. }, publisher = { ACM }, booktitle = { In Proceedings of the International Web3D Conference }, project = { NFGII }, files = { fileadmin/user_upload/fachgebiete/doellner/publications/2013/LWTD2013/web3d2013-treemaps-limberger.pdf }, link1 = { Video (Youtube) http://www.youtube.com/watch?v=AaHJRVQ3Z1E }, sorting = { 2048 } } @inproceedings{TSD2013, author = { Trapp, Matthias and Hahn, Sebastian and D{\"o}llner, J{\"u}rgen }, title = { Interactive Rendering of Complex 3D-Treemaps }, year = { 2013 }, pages = { 165-175 }, month = { 2 }, abstract = { 3D-Treemaps are an important visualization technique for hierarchical views. In contrast to 2D-Treemaps, height can be used to map one additional attribute of the data items. Using the Treemap technique in combination with large datasets (more than 500k) a fast rendering and interaction techniques that are beyond collapsing/uncollapsing nodes is still one of the main challenges. This paper presents a novel rendering technique that enables the image synthesis of geometrical complex 3D-Treemaps in real-time. The fully hardware accelerated approach is based on shape generation using geometry shaders. This approach offers increased rendering performance and low update latency compared to existing techniques and through it enables new real-time interaction techniques to large datasets. }, affiliation = { Hasso-Plattner-Institut, University of Potsdam, Germany }, keywords = { 3D-treemaps, real-time rendering, performance evaluation }, editor = { Sabine Coquillart, Carlos Andujar, Robert S. Laramee, Andreas Kerren and José Braz }, publisher = { SCITEPRESS – Science and Technology Publications }, booktitle = { Proceedings of the 8th International Conference on Computer Graphics Theory and Applications (GRAPP 2013) }, project = { NFGII;HPI }, files = { fileadmin/user_upload/fachgebiete/doellner/publications/2013/TSD2013/TreeMap.pdf }, isbn = { 978-989-8565-46-4 }, link1 = { Slides (AuthorStream) http://www.authorstream.com/Presentation/autopilot-1702377-rendering-complex-3d-tree-maps-grapp-2013/ }, sorting = { 2816 } } @inproceedings{TTD2012, author = { Jonas Trümper and Alexandru Telea and Jürgen Döllner }, title = { ViewFusion: Correlating Structure and Activity Views for Execution Traces }, year = { 2012 }, pages = { 45-52 }, month = { 9 }, abstract = { Visualization of data on structure and related temporal activity supports the analysis of correlations between the two types of data. This is typically done by linked views. This has shortcomings with respect to efficient space usage and makes mapping the effect of user input into one view into the other view difficult. We propose here a novel, space-efficient technique that `fuses' the two information spaces -- structure and activity -- in one view. We base our technique on the idea that user interaction should be simple, yet easy to understand and follow. We apply our technique, implemented in a prototype tool, for the understanding of software engineering datasets, namely static structure and execution traces of the Chromium web browser. }, keywords = { visualization, linking, correlation, software, execution traces, program comprehension, correlation, view, fusion, information space, best student application-paper }, publisher = { European Association for Computer Graphics }, address = { **Best Application-Paper** }, booktitle = { Proceedings of the 10th Theory and Practice of Computer Graphics Conference }, project = { NFGII }, files = { fileadmin/user_upload/fachgebiete/doellner/publications/2012/TTD2012/truemper_tpcg2012_preprint.pdf }, doi = { 10.2312/LocalChapterEvents/TPCG/TPCG12/045-052 }, link1 = { Definitive version http://diglib.eg.org/EG/DL/LocalChapterEvents/TPCG/TPCG12/045-052.pdf.abstract.pdf;internal&action=action.digitallibrary.ShowPaperAbstract }, link2 = { Video (Youtube) http://youtu.be/czhXPtt-Eoo }, link3 = { Project page at University of Groningen, NL http://www.cs.rug.nl/svcg/SoftVis/ViewFusion }, sorting = { 512 } } @inproceedings{TBD2012, author = { Jonas Trümper and Martin Beck and Jürgen Döllner }, title = { A Visual Analysis Approach to Support Perfective Software Maintenance }, year = { 2012 }, pages = { 308-315 }, month = { 7 }, abstract = { Ensuring code quality represents an essential task in «perfective software maintenance», which aims at keeping future maintenance costs low by facilitating adaptations of complex software systems. For this purpose, changes and related efforts have to be identified that imply high positive impact on future maintainability. In this paper, we propose a novel assessment method that applies visual analysis techniques to combine multiple indicators for low maintainability, including code complexity and entanglement with other parts of the system, and recent changes applied to the code. The approach generally helps to identify modules that impose a high risk by causing increased future maintenance efforts. Consequently, it allows for exploration, analysis, and planning of different preventive measures that, e.g., most likely will have a high return on investment. In our tool implementation, we use circular bundle views, extended by the third dimension in which indicators can be mapped to. We have evaluated our approach by conducting a case study based on our tool for a large-scale software system of an industry partner. }, publisher = { IEEE Computer Society }, booktitle = { Proceedings of the 16th International Conference on Information Visualisation }, project = { HPI }, files = { fileadmin/user_upload/fachgebiete/doellner/publications/2012/TBD2012/truemper_iv2012_preprint.pdf }, doi = { 10.1109/IV.2012.59 }, link1 = { Video (Youtube) http://youtu.be/XixapoI2JVI }, link2 = { Definitive version http://dx.doi.org/10.1109/IV.2012.59 }, sorting = { 1792 } } @inproceedings{HLBG12, author = { Stephan Hildebrandt and Leen Lambers and Basil Becker and Holger Giese }, title = { Integration of Triple Graph Grammars and Constraints }, year = { 2012 }, volume = { 52 }, pages = { 1-12 }, editor = { Christian Krause and Bernhard Westfechtel }, publisher = { EC-EASST }, booktitle = { Proceedings of the 7th International Workshp on Graph Based Tools }, project = { kormoran }, sorting = { 5888 } } @inproceedings{TVD2012, author = { Jonas Trümper and Stefan Voigt and Jürgen Döllner }, title = { Maintenance of Embedded Systems: Supporting Program Comprehension Using Dynamic Analysis }, year = { 2012 }, pages = { 58-64 }, abstract = { Maintenance of embedded software systems is faced with multiple challenges, including the exploration and analysis of the actual system's runtime behavior. As a fundamental technique, tracing can be used to capture data about runtime behavior as a whole, and represents one of the few methods to observe and record data about embedded systems within their production environments. In this paper we present a software-based, function-boundary tracing approach for embedded software systems. It uses static binary instrumentation, which implies only lightweight memory and performance overheads. To further reduce these overheads, instrumentation can be configured per trace, i.e., activated only for a specified group of functions without having to recompile the system. The technique can be characterized by its robust implementation and its versatile usage. It is complemented by a visualization framework that allows for analysis and exploration of a system's runtime behavior, e.g., to examine thread interaction. To show the technique's applicability, we conclude with a case study that has been applied to an industrial embedded software system. }, keywords = { Computerized instrumentation; Performance analysis; Software maintenance; Embedded software }, publisher = { IEEE Computer Society }, booktitle = { In Proceedings of the 2nd International ICSE Workshop on Software Engineering for Embedded Systems (SEES) }, files = { fileadmin/user_upload/fachgebiete/doellner/publications/2012/TVD2012/truemper_sees2012_preprint.pdf }, doi = { 10.1109/SEES.2012.6225492 }, link1 = { Definitive version http://dx.doi.org/10.1109/SEES.2012.6225492 }, sorting = { 3584 } } @inproceedings{TD2012, author = { Jonas Trümper and Jürgen Döllner }, title = { Extending Recommendation Systems with Software Maps }, year = { 2012 }, pages = { 92-96 }, abstract = { In practice, recommendation systems have evolved as helpful tools to facilitate and optimize software engineering processes. Serving both developers and managers, specific recommendation systems address their individual problems. Yet, in a number of cases complementing them with other techniques can enhance their use and extend their scope. In this paper, we first discuss different perspectives on software-engineering processes and examples of recommendation systems that support representatives of these perspectives. We then identify how select software-map techniques can extend recommendation systems to facilitate decision making by addressing the perspectives' information and communication needs. }, keywords = { Decision making, Context, Computer aided analysis, Visualization, Recommendation Systems }, publisher = { IEEE Computer Society }, booktitle = { Proceedings of the 3rd International ICSE Workshop on Recommendation Systems for Software Engineering (RSSE) }, files = { fileadmin/user_upload/fachgebiete/doellner/publications/2012/TD2012/truemper_rsse2012_preprint.pdf }, doi = { 10.1109/RSSE.2012.6233420 }, link1 = { Definitive version http://dx.doi.org/10.1109/RSSE.2012.6233420 }, sorting = { 3328 } } @inproceedings{delemos_et_al:DSP:2011:3156, author = { Rogério de Lemos and Holger Giese and Hausi A. Müller and Mary Shaw and Jesper Andersson and Luciano Baresi and Basil Becker and Nelly Bencomo and Yuriy Brun and Bojan Cukic and Ron Desmarais and Schahram Dustdar and Gregor Engels and Kurt Geihs and Karl M. Goeschka and Alessandra Gorla and Vincenzo Grassi and Poala Inverardi and Gabor Karsai and Jeff Kramer and Marin Litoiu and Antónia Lopes and Jeff Magee and Sam Malek and Serge Mankovskii and Raffaela Mirandola and John Mylopoulos and Oscar Nierstrasz and Mauro Pezzè and Christian Prehofer and Wilhelm Schäfer and Wilhelm Schlichting and Bradley Schmerl and Dennis B. Smith and Joao P. Sousa and Gabriel Tamura and Ladan Tahvildari and Norha M. Villegas and Thomas Vogel and Danny Weyns and Kenny Wong and Jochen Wuttke }, title = { Software Engineering for Self-Adaptive Systems: A second Research Roadmap }, year = { 2011 }, number = { 10431 }, month = { 6 }, note = { (Draft Version of May 20, 2011) }, editor = { Rogério de Lemos and Holger Giese and Hausi A. Müller and Mary Shaw }, publisher = { Schloss Dagstuhl - Leibniz-Zentrum fuer Informatik, Germany }, series = { Dagstuhl Seminar Proceedings }, address = { Dagstuhl, Germany }, booktitle = { Software Engineering for Self-Adaptive Systems }, project = { mrt }, link1 = { http://drops.dagstuhl.de/opus/volltexte/2011/3156 }, sorting = { 13056 } } @inproceedings{BD2011, author = { Johannes Bohnet and D{\"o}llner, J{\"u}rgen }, title = { Monitoring Code Quality and Development Activity by Software Maps }, year = { 2011 }, pages = { 9-16 }, month = { 5 }, abstract = { Software development projects are difficult to manage, in general, due to the friction between completing system features and, at the same time, obtaining a high degree of code quality to ensure maintainability of the system in the future. A major challenge of this optimization problem is that code quality is less visible to stakeholders in the development process, particularly, to the management. In this paper, we describe an approach for automated software analysis and monitoring of both quality-related code metrics and development activities by means of software maps. A software map represents an adaptive, hierarchical representation of software implementation artifacts such as source code files being organized in a modular hierarchy. The maps can express and combine information about software development, software quality, and system dynamics; they can systematically be specified, automatically generated, and organized by templates. The maps aim at supporting decision-making processes. For example, they facilitate to decide where in the code an increase of quality would be beneficial both for speeding up current development activities and for reducing risks of future maintenance problems. Due to their high degree of expressiveness and their instantaneous generation, the maps additionally serve as up-to-date information tools, bridging an essential information gap between management and development, improve awareness, and serve as early risk detection instrument. The software map concept and its tool implementation are evaluated by means of two case studies on large industrially developed software systems. }, booktitle = { Proceedings of the IEEE ACM ICSE Workshop on Managing Technical Debt }, sorting = { 1280 }, priority = { 1 } } @inproceedings{BeckerLDBG2011, author = { Basil Becker and Leen Lambers and Johannes Dyck and Stefanie Birth and Holger Giese }, title = { Iterative Development of Consistency-Preserving Rule-Based Refactorings }, year = { 2011 }, volume = { 6707 }, pages = { 123-137 }, editor = { Jordi Cabot and Eelco Visser }, publisher = { Springer / Heidelberg }, series = { Lecture Notes in Computer Science }, booktitle = { Theory and Practice of Model Transformations, Fourth International Conference, ICMT 2011, Zurich, Switzerland, June 27-28, 2011. Proceedings }, project = { kormoran }, sorting = { 22784 } } @inproceedings{LTD2011, author = { Christine Lehmann and Jonas Trümper and Jürgen Döllner }, title = { Interactive Areal Annotations for 3D Treemaps of Large-Scale Software Systems }, year = { 2011 }, abstract = { Exploration of large-scale software systems typically poses a challenge to human mind and perception. Among other approaches to this challenge, visualizing such tree-structured data using treemaps is a common solution. Especially three-dimensional treemaps enable intuitive exploration through a large-scale software system using the landscape metaphor for navigation. Annotations of treemap nodes contribute essential semantic information, e.g., class or method names. However, textual annotations in three-dimensional environments typically suffer from ambiguousness, illegibility and instability. In this paper, we propose an interactive labeling algorithm suitable for 3D areal annotation of large-scale software systems that are visualized using three-dimensional treemaps. We demonstrate how the algorithm generates an unambiguous and stable layout with respect to legibility using 3D treemaps of a software visualization tool that visualizes the hierarchical structure of a large software system, e.g., Google Chromium. }, keywords = { treemaps, labeling, software visualization }, booktitle = { Proceedings (CD-ROM) of the Workshop on Geovisualization }, files = { fileadmin/user_upload/fachgebiete/doellner/publications/2011/LTD2011/clehmann_geoviz2011.pdf }, sorting = { 6 }, priority = { 1 } } @inproceedings{BTD2011, author = { Martin Beck and Jonas Trümper and Jürgen Döllner }, title = { A Visual Analysis and Design Tool for Planning Software Reengineerings }, year = { 2011 }, pages = { 54-61 }, abstract = { Reengineering complex software systems represents a non-trivial process. As a fundamental technique in software engineering, reengineering includes (a) reverse engineering the as-is system design, (b) identifying a set of transformations to the design, and (c) applying these transformations. While methods a) and c) are widely supported by existing tools, identifying possible transformations to improve architectural quality is not well supported and, therefore, becomes increasingly complex in aged and large software systems. In this paper we present a novel visual analysis and design tool to support software architects during reengineering tasks in identifying a given software's design and in visually planning quality-improving changes to its design. The tool eases estimating effort and change impact of a planned reengineering. A prototype implementation shows the proposed technique's feasibility. Three case studies conducted on industrial software systems demonstrate usage and scalability of our approach. }, keywords = { software, visualization, reengineering, what-if analysis }, publisher = { IEEE Computer Society }, booktitle = { Proceedings of the 6th IEEE International Workshop on Visualizing Software for Understanding and Analysis }, project = { HPI }, files = { fileadmin/user_upload/fachgebiete/doellner/publications/2011/BTD2011/beck_vissoft2011_preprint.pdf }, link1 = { Video (Youtube) http://www.youtube.com/watch?v=4rkgfRaCS20&context=C36131dcADOEgsToPDskISqJ8lSK3-CBkmMZEdHKPa }, link2 = { Definitive version http://dx.doi.org/10.1109/VISSOF.2011.6069458 }, sorting = { 1 }, priority = { 1 } } @inproceedings{TBD10, author = { Jonas Trümper and Johannes Bohnet and Jürgen Döllner }, title = { Understanding Complex Multithreaded Software Systems by Using Trace Visualization }, year = { 2010 }, pages = { 133-142 }, month = { 10 }, abstract = { Understanding multithreaded software systems is typically a tedious task: Due to parallel execution and interactions between multiple threads, such a system's runtime behavior is often much more complex than the behavior of a single-threaded system. For many maintenance activities, system understanding is a prerequisite. Hence, tasks such as bug fixing or performance optimization are highly demanding in the case of multithreaded systems. Unfortunately, state-of-the-art tools for system understanding and debuggers provide only limited support for these systems. We present a dynamic analysis and visualization technique that helps developers in understanding multithreaded software systems in general and in identifying performance bottlenecks in particular. The technique first performs method boundary tracing. Second, developers perform a post-mortem analysis of a system's behavior using visualization optimized for trace data of multithreaded software systems. The technique enables developers to understand how multiple threads collaborate at runtime. The technique is integrated into a professional and scalable tool for visualizing the behavior of complex software systems. In case studies, we have tested the technique with industrially developed, multithreaded software systems to understand system behavior and to identify multithreading-related performance bottlenecks. }, keywords = { multithreaded, software, visualization, comprehension, trace compaction }, publisher = { ACM }, booktitle = { Proceedings of the 5th International Symposium on Software Visualization }, files = { fileadmin/user_upload/fachgebiete/doellner/publications/2010/TBD10/jtruemper_softvis2010_preprint.pdf }, link1 = { Definitive version http://dx.doi.org/10.1145/1879211.1879232 }, sorting = { 256 }, priority = { 2 } } @inproceedings{TBVD10, author = { Jonas Trümper and Johannes Bohnet and Stefan Voigt and Jürgen Döllner }, title = { Visualization of Multithreaded Behavior to Facilitate Maintenance of Complex Software Systems }, year = { 2010 }, pages = { 325-330 }, month = { 9 }, abstract = { Maintenance accounts for the major part of a software system's total costs. Therein, program comprehension is an important, but complex activity: Typically, up-to-date documentation is not available, so the main reliable source of information on the implementation represent the artifacts of the system's implementation. Understanding software systems is difficult, in particular, if multithreading concepts are involved because state-of-the art development tools provide only limited support for maintenance activities. In addition, concurrency is often not directly reflected by the source code, i.e., there is only a non-obvious correlation between control structures in the source code and a system's runtime behavior. We present a program comprehension technique that helps to analyze and understand runtime behavior of multithreaded software systems and, thereby, facilitates software maintenance tasks. Our approach contains the following concepts: First, light-weight dynamic analysis records executed method calls at runtime. Second, visualization of multithreading trace data allows developers to explore the system behavior post-mortem. The technique forms part of a scalable tool suite for understanding the behavior of complex software systems. We also show how to apply the technique on industrial software systems to solve common maintenance problems. }, keywords = { multithreaded, software, visualization, comprehension, maintenance }, publisher = { IEEE Computer Society }, booktitle = { Proceedings of the 7th International Conference on the Quality of Information and Communications Technology }, files = { fileadmin/user_upload/fachgebiete/doellner/publications/2010/TBVD10/jtruemper_quatic2010_preprint.pdf }, link1 = { Definitive version http://dx.doi.org/10.1109/QUATIC.2010.59 }, sorting = { 512 }, priority = { 1 } } @inproceedings{HGB2010, author = { Regina Hebig and Holger Giese and Basil Becker }, title = { Making Control Loops Explicit When Architecting Self-Adaptive Systems }, year = { 2010 }, pages = { 21--28 }, month = { 6 }, abstract = { Many self-adaptive systems include control loops between the core system and specific control elements which realize the self-adaptation capabilities. This is also true albeit at a higher level of abstraction for decentralized architectures. However, the available techniques to describe the software architecture of such systems do not support to make the control loops explicit. Therefore, architecting self-adaptive systems and their self-adaptation logic is today not well supported. In this paper, we present a UML profile for control loops that extends UML modeling concepts such that control loops become first class elements of the architecture. This enables that the architecture reflects control loops as crucial elements of the software architecture of these systems. Furthermore, it supports to design control loops as well as the interplay of multiple control loops at the architectural level. In addition, warning signals and related analysis activities are presented that can be used to analyze whether a given architectural UML model using the profile includes potentially problematic occurrences of control loops. }, publisher = { ACM }, address = { Washington, DC, USA }, booktitle = { SOAR '10: Proceedings of the second international workshop on Self-Organizing Architectures }, files = { EXT: pdf/Hebig_et_al:2010.pdf }, isbn = { 978-1-4503-0087-2 }, doi = { 10.1145/1809036.1809042 }, sorting = { 35584 } } @inproceedings{2010_Linckels_GML2, author = { Serge Linckels, Claude Weber, Simone Beck, Christoph Meinel }, title = { Informations- und Kommunikationstechnologien im Unterricht – Vorläufige Ergebnisse einer umfassenden Umfrage }, year = { 2010 }, pages = { 100-111 }, month = { 3 }, address = { Berlin, Germany }, booktitle = { Proceedings of Conference on Grundfragen Multimedialen Lehrens und Lernens (GML2 2010) }, isbn = { 978-3-8309-2326-8 }, sorting = { 120576 } } @inproceedings{VogelMRT09, author = { Thomas Vogel and Stefan Neumann and Stephan Hildebrandt and Holger Giese and Basil Becker }, title = { Incremental Model Synchronization for Efficient Run-time Monitoring }, year = { 2009 }, volume = { 509 }, pages = { 1-10 }, month = { 10 }, abstract = { The model-driven engineering community has developed expressive model transformation techniques based on meta models, which ease the specification of translations between different model types. Thus, it is attractive to also apply these techniques for autonomic and self-adaptive systems at run-time to enable a comprehensive monitoring of their architectures while reducing development efforts. This requires special solutions for model transformation techniques as they are applied at run-time instead of their traditional usage at development time. In this paper we present an approach to ease the development of architectural monitoring based on the incremental model synchronization with triple graph grammars. We show that the provided incremental synchronization between a running system and models for different self-management capabilities provides a significantly better compromise between performance and development costs than manually developed solutions. }, note = { (best paper) }, keywords = { Incremental model synchronization, Models at runtime }, editor = { Nelly Bencomo and Gordon Blair and Robert France and Cedric Jeanneret and Freddy Munoz }, publisher = { CEUR-WS.org }, series = { CEUR Workshop Proceedings }, booktitle = { Proceedings of the 4th International Workshop on Models@run.time at the 12th IEEE/ACM International Conference on Model Driven Engineering Languages and Systems (MoDELS 2009), Denver, Colorado, USA }, project = { mrt }, files = { EXT: pdf/VogelMRT09_paper_8.pdf }, issn = { 1613-0073 }, link1 = { http://ceur-ws.org/Vol-509/paper_8.pdf }, sorting = { 50176 } } @inproceedings{BGNST09, author = { Basil Becker and Holger Giese and Stefan Neumann and Martin Schenck and Arian Treffer }, title = { Model-Based Extension of AUTOSAR for Architectural Online Reconfiguration }, year = { 2009 }, volume = { 507 }, pages = { 123-137 }, month = { 10 }, abstract = { In the last years innovations in the automotive domain have more and more been realized by software leading to a dramatically increased complexity of such systems. Additionally automotive systems have to be flexible and robust, e.g., to be able to deal with failures of sensors, actuators or other constituents of an automotive system. One possibility to achieve robustness and flexibility in automotive systems is the usage of reconfiguration capabilities. However, adding such capabilities introduces even higher degree of complexity. To avoid this drawback we propose to integrate reconfiguration capabilities into AUTOSAR, an existing framework supporting the management of such complex system at the architectural level. Elaborated and expensive tools and toolchains assist during the development of automotive systems. Hence we present how our reconfiguration solution has been seamlessly integrated into such a toolchain. }, editor = { Stefan Van Baelen and Thomas Weigert and Ileana Ober and Huascar Espinoza }, publisher = { CEUR-WS.org }, series = { CEUR Workshop Proceedings }, booktitle = { Proceedings of the 2nd International Workshop on Model Based Architecting and Construction of Embedded Systems (ACES-MB 2009) }, files = { EXT: pdf/BGNST09.pdf }, sorting = { 49920 }, priority = { 2 } } @inproceedings{Vogel-ICAC09, author = { Thomas Vogel and Stefan Neumann and Stephan Hildebrandt and Holger Giese and Basil Becker }, title = { Model-Driven Architectural Monitoring and Adaptation for Autonomic Systems }, year = { 2009 }, pages = { 67-68 }, month = { 6 }, abstract = { Architectural monitoring and adaptation allows self-management capabilities of autonomic systems to realize more powerful adaptation steps, which observe and adjust not only parameters but also the software architecture. However, monitoring as well as adaptation of the architecture of a running system in addition to the parameters are considerably more complex and only rather limited and costly solutions are available today. In this paper we propose a model-driven approach to ease the development of architectural monitoring and adaptation for autonomic systems. Using meta models and model transformation techniques, we were able to realize an incremental synchronization between the run-time system and models for di fferent self-management activities. The synchronization might be triggered when needed and therefore the activities can operate concurrently. }, keywords = { autonomic computing, Incremental model synchronization, Model transformation, Models at runtime, runtime software architecture }, publisher = { ACM }, booktitle = { Proceedings of the 6th IEEE/ACM International Conference on Autonomic Computing and Communications (ICAC 2009), Barcelona, Spain }, project = { mrt }, files = { EXT: pdf/Vogel-ICAC09_p67.pdf }, isbn = { 978-1-60558-564-2 }, doi = { 10.1145/1555228.1555249 }, link1 = { http://portal.acm.org/citation.cfm?doid=1555228.1555249 }, sorting = { 52736 }, priority = { 10 } } @inproceedings{Becker09, author = { Basil Becker }, title = { Towards Safety Guarantees for Service-Oriented Systems }, year = { 2009 }, pages = { 347 -- 350 }, publisher = { IEEE Computer Society }, booktitle = { ICSE Companion 2009, Companion of the 31th International Conference on Software Engineering }, files = { EXT: pdf/Becker09.pdf }, sorting = { 51456 } } @inproceedings{VBD09, author = { Voigt, Stefan and Bohnet, Johannes and D{\"o}llner, J{\"u}rgen }, title = { Enhancing Structural Views of Software Systems by Dynamic Information }, year = { 2009 }, pages = { 47 - 50 }, abstract = { Understanding software systems comprises the analysis of different aspects of the respective systems, such as dynamic and static analysis with all their facets. Consequently, developers study different kinds of information and create different mental models. We introduce a visualization technique that facilitates cross referencing mental models, in particular models that describe the structure and models describing the behavior of software systems. To achieve this goal, we enhance structural views by runtime information depending on the current focus of a sequential view. Animation enables developers to explore how the system’s state changes over time, by this, supporting developers in understanding program behavior. }, keywords = { Dynamic Analysis, Animation, Program Comprehension }, publisher = { IEEE Computer Society Press }, booktitle = { 5th IEEE International Workshop on Visualizing Software for Understanding and Analysis }, sorting = { 2304 }, state = { 1 }, priority = { 1 } } @inproceedings{BKD09, author = { Bohnet, Johannes and Koeleman, Martin and D{\"o}llner, J{\"u}rgen }, title = { Visualizing Massively Pruned Execution Traces to Facilitate Trace Exploration }, year = { 2009 }, pages = { 57-64 }, abstract = { Execution traces provide precise pictures of the inner workings of software systems. They therefore support programmers in performing various maintenance tasks. However, exploring traces is difficult due to their size. They typically consist of thousands of participating functions and millions of control flow events. When exploring traces, it is particularly time-consuming to identify those time ranges within the trace that are relevant for the current maintenance task. In this paper, we propose a technique that supports programmers in exploring traces in that it first prunes less relevant calls from the trace and then provides condensed and repetition-aware visualizations that facilitate fast and accurate navigation even within very large traces. Repetitions in the trace are detected by a novel metrics to measure similarity between function calls in a fuzzy and adjustable way. The metrics helps to identify outlier calls in repetitive call sequences and guides programmers on control paths being likely relevant for their comprehension task. The technique is implemented within a prototypical analysis tool that copes with large C/C++ software systems. We demonstrate the concepts by means of a case study with our industrial partner. }, keywords = { software visualization, trace visualization, reverse engineering, dynamic analysis }, publisher = { IEEE Computer Society Press }, booktitle = { 5th IEEE International Workshop on Visualizing Software for Understanding and Analysis }, sorting = { 2560 }, priority = { 1 } } @inproceedings{VBD09a, author = { Voigt, Stefan and Bohnet, Johannes and D{\"o}llner, J{\"u}rgen }, title = { Object Aware Execution Trace Exploration }, year = { 2009 }, pages = { 201 - 210 }, abstract = { To understand software systems it is common practice to explore runtime information such as method calls. System behavior analysis can further be facilitated by additionally taking runtime data dependencies into account. In object oriented systems, a typical data dependency is the information about which objects are accessed by the traced method calls. To support software engineers in handling the massive amount of information that execution traces typically consist of, highly scalable visualizations are needed. In this paper, we propose a trace-visualization technique that (a) explicitly visualizes both, method calls and object accesses, and (b) provides high scalability to handle large execution traces. With regard to the visualization technique proposed, we give a systematic overview of visual patterns that are to be expected and of their meanings with respect to system behavior. Additionally, we present the results of three case-studies to show how our approach facilitates developers in comprehending the behavior of complex C++ software systems. }, keywords = { Reverse Engineering; Dynamic Analysis; Execution Trace Exploration; Object Orientation; Software Visualization }, publisher = { IEEE Computer Society Press }, booktitle = { 25th IEEE International Conference on Software Maintenance }, sorting = { 3072 }, state = { 1 }, priority = { 1 } } @inproceedings{BVD09, author = { Bohnet, Johannes and Voigt, Stefan and D{\"o}llner, J{\"u}rgen }, title = { Projecting Code Changes onto Execution Traces to Support Localization of Recently Introduced Bugs }, year = { 2009 }, pages = { 438--442 }, abstract = { Working collaboratively on complex software systems often leads to situations where a developer enhances or extends system functionality, thereby however, introducing bugs. At best the unintentional changes are caught immediately by regression tests. Often however, the bugs are detected days or weeks later by other developers noticing strange system behavior while working on different parts of the system. Then it is a highly time-consuming task to trace back this behavior change to code changes in the past. In this paper we propose a technique for identifying the recently introduced change that is responsible for the unexpected behavior. The key idea is to combine dynamic, static, and code change information on the system to reduce the possibly great amount of code modifications to those that may affect the system while running its faulty behavior. After having applied this massive automated filtering step, developers receive support in semi-automatically identifying the root cause change by means of a trace exploration frontend. Within multiple synchronized views, developers explore when, how and why modified code locations are executed. The technique is implemented within a prototypical analysis tool that copes with large (> MLOC) C/C++ software systems. We demonstrate the approach by means of industrial case studies. }, keywords = { software visualization, fault localization, reverse engineering }, publisher = { ACM }, booktitle = { 24th ACM Symposium on Applied Computing }, sorting = { 4864 }, priority = { 1 } } @inproceedings{BGHS08, author = { Basil Becker and Holger Giese and Stephan Hildebrandt and Andreas Seibel }, title = { Fujaba's Future in the MDA Jungle - Fully Integrating Fujaba and the Eclipse Modeling Framework? }, year = { 2008 }, month = { 9 }, booktitle = { Proceedings of the 6th International Fujaba Days }, project = { fujaba }, sorting = { 54528 }, priority = { 5 } } @inproceedings{GieseBecker08, author = { Basil Becker and Holger Giese }, title = { On Safe Service-Oriented Real-Time Coordination for Autonomous Vehicles }, year = { 2008 }, pages = { 203--210 }, month = { 5 }, publisher = { IEEE Computer Society Press }, booktitle = { In Proc. of 11th International Symposium on Object/component/service-oriented Real-time distributed Computing (ISORC) }, project = { SFB614, Masterarbeit-InvCheck-Heuristic }, language = { english }, files = { EXT: pdf/GieseBecker08_beckergiese-SafeServiceOrientedRealTimeCoordination.pdf }, isbn = { 978-0-7695-3132-8 }, sorting = { 58880 }, priority = { 3 } } @inproceedings{BeckerGiese08b, author = { Basil Becker and Holger Giese }, title = { Incremental Verification of Inductive Invariants for the Run-Time Evolution of Self-Adaptive Software-Intensive Systems }, year = { 2008 }, annotation = { to appear }, publisher = { IEEE Computer Society Press }, booktitle = { Proc. 1st Intl. Workshop on Automatic Engineering of Autonomous and Run-Time Evolving Systems }, project = { HPI }, sorting = { 19200 } } @inproceedings{BGHS08, author = { Basil Becker and Holger Giese and Stephan Hildebrandt and Andreas Seibel }, title = { Fujaba's Future in the MDA Jungle - Fully Integrating Fujaba and the Eclipse Modeling Framework? }, year = { 2008 }, booktitle = { Proceedings of the 6th International Fujaba Days }, project = { HPI }, sorting = { 18944 }, priority = { 1 } } @inproceedings{BeckerGiese08c, author = { Basil Becker and Holger Giese }, title = { Modeling of Correct Self-Adaptive Systems: A Graph Transformation System Based Approach }, year = { 2008 }, abstract = { Software is always embedded in a social and technical context which change over time and therefore also the software has to be adjusted over time to preserve its value. Self-adaptive systems provide a vision how the systems can become capable of doing a large fraction of the required adaptations autonomously. In this paper we first discuss what is required to model correct self-adaptive systems. We then present the formal model of graph transformation systems which serves most of the identified needs. Based on this findings we outline how UML class and object diagrams as well as extensions for the modeling of behavior based upon graph transformation systems can be employed to model correct self-adaptive system. An application example is used to present how the approach can be employed to model self-adaptive systems at a high level of abstraction and means to ensure its correctness are discussed. }, note = { to appear }, publisher = { IEEE Computer Society Press }, booktitle = { Proceedings 1st IEEE Intl. Workshop on Autonomous and Autonomic Software-Based Systems }, project = { HPI }, sorting = { 18688 }, priority = { 3 } } @inproceedings{BeckerGiese08b, author = { Basil Becker and Holger Giese }, title = { Incremental Verification of Inductive Invariants for the Run-Time Evolution of Self-Adaptive Software-Intensive Systems }, year = { 2008 }, pages = { 33-40 }, abstract = { The safe run-time evolution of complex software-intensive systems requires that the impact of changes can be predicted at run-time. In this paper we consider the specific case of self-adaptive software-intensive systems using an example for the coordination of autonomous vehicles. We show how incremental run-time checks can verify that changes in the rule set which governs the distributed rule-based self-adaptive behavior provides the required safety properties. We demonstrate how an existing verification technique for invariant checking is turned into an incremental one. We discuss the theoretical complexity of the incremental verification checks and also present some first evaluation results. }, publisher = { IEEE Computer Society Press }, booktitle = { Proc. 23rd IEEE/ACM International Conference on Automated Software Engineering - Workshops }, files = { EXT: pdf/BeckerGiese08b_aramis08.pdf }, isbn = { 978-1-4244-2776-5 }, doi = { 10.1109/ASEW.2008.4686291 }, sorting = { 55040 } } @inproceedings{BeckerGiese08c, author = { Basil Becker and Holger Giese }, title = { Modeling of Correct Self-Adaptive Systems: A Graph Transformation System Based Approach }, year = { 2008 }, pages = { 508 - 516 }, abstract = { Software is always embedded in a social and technical context which change over time and therefore also the software has to be adjusted over time to preserve its value. Self-adaptive systems provide a vision how the systems can become capable of doing a large fraction of the required adaptations autonomously. In this paper we first discuss what is required to model correct self-adaptive systems. We then present the formal model of graph transformation systems which serves most of the identified needs. Based on this findings we outline how UML class and object diagrams as well as extensions for the modeling of behavior based upon graph transformation systems can be employed to model correct self-adaptive system. An application example is used to present how the approach can be employed to model self-adaptive systems at a high level of abstraction and means to ensure its correctness are discussed. }, publisher = { ACM Press }, booktitle = { CSTST '08: Proc. 5th Intl. Conference on Soft Computing as Transdisciplinary Science and Technology }, files = { EXT: pdf/BeckerGiese08c_asbs2008.pdf }, isbn = { 978-1-60558-046-3 }, doi = { 10.1145/1456223.1456326 }, sorting = { 54016 }, priority = { 3 } } @inproceedings{cheng_et_al:DSP:2008:1500, author = { Betty H.C. Cheng and Holger Giese and Paola Inverardi and Jeff Magee and Rogerio de Lemos and Jesper Andersson and Basil Becker and Nelly Bencomo and Yuriy Brun and Bojan Cukic and Giovanna Di Marzo Serugendo and Schahram Dustdar and Anthony Finkelstein and Cristina Gacek and Kurt Geihs and Vincenzo Grassi and Gabor Karsai and Holger Kienle and Jeff Kramer and Marin Litoiu and Sam Malek and Raffaela Mirandola and Hausi Muller and Sooyong Park and Mary Shaw and Matthias Tichy and Massimo Tivoli and Danny Weyns and Jon Whittle }, title = { 08031 -- Software Engineering for Self-Adaptive Systems: A Research Road Map }, year = { 2008 }, number = { 08031 }, annotation = { Keywords: Software engineering, requirements engineering, modelling, evolution, assurances, self-adaptability, self-organization, self-management }, editor = { Betty H.C. Cheng and Rogerio de Lemos and Holger Giese and Paola Inverardi and Jeff Magee }, publisher = { Schloss Dagstuhl - Leibniz-Zentrum fuer Informatik, Germany }, series = { Dagstuhl Seminar Proceedings }, address = { Dagstuhl, Germany }, booktitle = { Software Engineering for Self-Adaptive Systems }, link1 = { http://drops.dagstuhl.de/opus/volltexte/2008/1500 }, sorting = { 48128 } } @inproceedings{BVD08, author = { Bohnet, Johannes and Voigt, Stefan and D{\"o}llner, J{\"u}rgen }, title = { Locating and Understanding Features of Complex Software Systems by Synchronizing Time-, Collaboration- and Code-focused Views on Execution Traces }, year = { 2008 }, pages = { 268--271 }, keywords = { software visualization, program comprehension, reverse engineering, feature location }, publisher = { IEEE Computer Society Press }, booktitle = { 16th IEEE International Conference on Program Comprehension }, organization = { IEEE }, sorting = { 3584 }, priority = { 1 } } @inproceedings{BD08, author = { Bohnet, Johannes and D{\"o}llner, J{\"u}rgen }, title = { Analyzing Dynamic Call Graphs Enhanced with Program State Information for Feature Location and Understanding }, year = { 2008 }, pages = { 915--916 }, keywords = { software visualization, feature location, reverse engineering, maintenance }, publisher = { IEEE Computer Society Press }, booktitle = { 30th IEEE International Conference on Software Engineering }, organization = { IEEE }, sorting = { 4864 }, priority = { 1 } } @inproceedings{BD07, author = { Bohnet, Johannes and D{\"o}llner, J{\"u}rgen }, title = { Facilitating Exploration of Unfamiliar Source Code by Providing 2-1/2-D Visualizations of Dynamic Call Graphs }, year = { 2007 }, pages = { 63--66 }, keywords = { software visualization, program understanding }, publisher = { IEEE Computer Society Press }, booktitle = { 4th IEEE International Workshop on Visualizing Software for Understanding and Analysis }, organization = { IEEE }, sorting = { 1536 }, priority = { 1 } } @inproceedings{BD07a, author = { Bohnet, Johannes and D{\"o}llner, J{\"u}rgen }, title = { CGA Call Graph Analyzer - Locating and Understanding Functionality within the Gnu Compiler Collection's Million Lines of Code }, year = { 2007 }, pages = { 161--162 }, keywords = { software visualization, program understanding }, publisher = { IEEE Computer Society Press }, booktitle = { 4th IEEE International Workshop on Visualizing Software for Understanding and Analysis }, organization = { IEEE }, sorting = { 1792 }, priority = { 1 } } @inproceedings{BD07b, author = { Bohnet, Johannes and D{\"o}llner, J{\"u}rgen }, title = { Visually Exploring Control Flow Graphs to Support Legacy Software Migration }, year = { 2007 }, pages = { 245--246 }, keywords = { software visualization, program understanding }, publisher = { Springer }, series = { GI-Edition Lecture Notes in Informatics }, booktitle = { Conference on Software Engineering (SE) }, organization = { GI }, sorting = { 2560 }, priority = { 1 } } @inproceedings{BD07c, author = { Bohnet, Johannes and D{\"o}llner, J{\"u}rgen }, title = { Planning an Experiment on User Performance for Exploration of Diagrams Displayed in 2 1/2 Dimensions }, year = { 2007 }, pages = { 223--230 }, keywords = { software visualization, program understanding }, publisher = { Springer }, series = { GI-Edition Lecture Notes in Informatics }, booktitle = { Workshop on SE07 - Empirische Untersuchungen von Visualisierungswerkzeugen zur Software-Analyse }, organization = { GI }, sorting = { 3072 }, priority = { 1 } } @inproceedings{BD06, author = { Bohnet, Johannes and D{\"o}llner, J{\"u}rgen }, title = { Visual Exploration of Function Call Graphs for Feature Location in Complex Software Systems }, year = { 2006 }, pages = { 95--104 }, keywords = { software visualization, program understanding }, publisher = { ACM Press }, booktitle = { ACM Symposium on Software Visualization }, organization = { ACM }, sorting = { 256 }, priority = { 1 } } @inproceedings{BD06a, author = { Bohnet, Johannes and D{\"o}llner, J{\"u}rgen }, title = { Analyzing Feature Implementation by Visual Exploration of Architecturally-Embedded Call-Graphs }, year = { 2006 }, pages = { 41--48 }, keywords = { software visualization, program understanding }, publisher = { ACM Press }, booktitle = { 4th International Workshop on Dynamic Analysis }, organization = { ACM }, sorting = { 768 }, priority = { 1 } } @inproceedings{GSKBB06, author = { Basil Becker and Dirk Beyer and Holger Giese and Florian Klein and Daniela Schilling }, title = { Symbolic Invariant Verification for Systems with Dynamic Structural Adaptation }, year = { 2006 }, publisher = { ACM Press }, booktitle = { Proc. of the $28^th$ International Conference on Software Engineering (ICSE), Shanghai, China }, files = { EXT: pdf/GSKBB06_Symbolic Invariant Verification for Systems with Dynamic Structural Adaption - Becker,Beyer,Giese,Klein,Schilling.pdf }, sorting = { 157184 } } @inproceedings{BGS05a_ag, author = { Basil Becker and Holger Giese and Daniela Schilling }, title = { A Plugin for Checking Inductive Invariants when Modeling with Class Diagrams and Story Patterns }, year = { 2005 }, pages = { 1-4 }, month = { 9 }, annotation = { LANGUAGE : english }, booktitle = { Proc. of the 3rd International Fujaba Days 2005, Paderborn, Germany }, project = { SFB614-B1, FUJABA }, language = { english }, sorting = { 165632 }, priority = { 10 } } @inproceedings{BBD05a, author = { Buchholz, Henrik and Bohnet, Johannes and D{\"o}llner, J{\"u}rgen }, title = { Smart Navigation Strategies for Virtual Landscapes }, year = { 2005 }, pages = { 124--131 }, abstract = { Navigation is a key factor for user acceptance of virtual 3D landscapes. Existing geovirtual environments (GeoVEs) frequently suffer from the lack of a proper handling and prevention of confusing or disorientating situations. As FUHRMANN & MACEACHREN (2001) point out, “core problems for users of these desktop GeoVEs are to navigate through, and remain oriented in, the display space and to relate that display space to the geographic space it depicts.” This paper proposes smart navigation strategies, which overcome these problems and give additional features to landscape designers for user guidance: 1) Smart navigation strategies interpret user interaction regarding the current view specification, i.e., the parameters of the virtual camera, and determine if the user is about to get into confusing or disorienting situations in an anticipatory way. 2) They guide the user away from situations where usual navigation behavior tends to fail. 3) They always indicate to the user when the guidance mechanism is operating, so that the user understands the behavior of the smart navigation strategy. 4) They allow for constraining the camera according to data quality and the emphasis given to certain parts of the virtual landscape. With smart navigation strategies we aim to achieve a higher user acceptance for virtual landscape applications. Particularly, smart navigation strategies facilitate the use of visualization applications for inexperienced users without the need for a specific training. }, editor = { Buhmann, E. and Paar, P. and Bishop, I.D. and Lange, E. }, publisher = { Wichmann }, booktitle = { Trends in Real-time Visualization and Participation. Proceedings at Anhalt University of Applied Sciences }, files = { user_upload/fachgebiete/doellner/publications/2005/BBD05a/SmartNavForVirtualLandscapes.pdf }, sorting = { 512 } } @inproceedings{BBD05, author = { Buchholz, Henrik and Bohnet, Johannes and D{\"o}llner, J{\"u}rgen }, title = { Smart and Physically-Based Navigation in 3D Geovirtual Environments }, year = { 2005 }, pages = { 629--635 }, abstract = { This paper describes an approach for smart and physically-based navigation, which aims at supporting effective and intuitive user interactions with 3D geovirtual environments (GeoVEs). The approach is based on two aligned concepts: 1) All navigation techniques are controlled by constraints that ensure user orientation and avoid “getting lost” situations. 2) All navigation techniques are handled in a time-coherent way achieving steady, continuous user movements using a physically-based motion model. Based on these concepts, we demonstrate several ways to improve commonly used navigation techniques for geovirtual environments. }, publisher = { IEEE Computer Society Press }, booktitle = { 9th International Conference on Information Visualization }, files = { user_upload/fachgebiete/doellner/publications/2005/BBD05/SmartNavigation_Buchholz_draft.pdf }, sorting = { 768 } } @inproceedings{TBG04_ag, author = { Matthias Tichy and Basil Becker and Holger Giese }, title = { Component Templates for Dependable Real-Time Systems }, year = { 2004 }, volume = { tr-ri-04-253 }, pages = { 27-30 }, month = { 9 }, abstract = { A general trend towards more complex technical systems can be observed which results in an increasing demand for methods and tools to develop dependable, high quality software for embedded systems. The UML in principle provides the essential concepts which are required to model such complex, safety-critical software systems. In this paper, we describe a component template plugin for the Fujaba Real-Time Tool Suite which has been especially tailored to support faulttolerance templates such as triple modular redundancy. We report about the underlying concepts and the application of the plugin by means of an example. }, editor = { Andy Schürr and Albert Zündorf }, publisher = { University of Paderborn }, series = { Technical Report }, booktitle = { Proceedings of the 2nd International Fujaba Days 2004, Darmstadt, Germany }, project = { FUJABA, SFB614-B1 }, files = { EXT: fdays2004-tbg.pdf }, link1 = { http://www.upb.de/cs/ag-schaefer/Veroeffentlichungen/Quellen/Papers/2004/fdays2004-tbg.pdf }, sorting = { 141312 }, priority = { 50 } } @inproceedings{2004_Becker_CATAI, author = { T. Becker, Christoph Meinel }, title = { Security in Telemedicine - Certificates and Digital Identity Cards }, year = { 2004 }, pages = { 44-47 }, address = { La Laguna, Teneriffa }, project = { eHealth; tele-Medicine }, language = { English }, files = { fileadmin/user_upload/fachgebiete/meinel/papers/Telemedicine/2004_Becker_CATAI.pdf }, sorting = { 84224 } } @inproceedings{2003_Becker_ONLINE, author = { Torsten Becker, Christoph Meinel }, title = { Sicherheit: Der entscheidende Erfolgsfaktor für E-Commerce und M-Commerce }, year = { 2003 }, pages = { C421.03-C421.08 }, month = { 9 }, address = { Düsseldorf, Germany }, project = { Security and Trust }, language = { German }, files = { fileadmin/user_upload/fachgebiete/meinel/papers/Trust_and_Security_Engineering/2003_Becker_ONLINE.pdf }, sorting = { 81408 } } @masterthesis{Becker07, author = { Basil Becker }, title = { Verifikation induktiver Invarianten in hybriden Graphtransformationssystemen }, year = { 2007 }, school = { University of Paderborn }, files = { becker07_fg_Diplomarbeit-final.pdf }, sorting = { 256 } } @masterthesis{becker07_fg, author = { Basil Becker }, title = { Verifikation induktiver Invarianten in hybriden Graphtransformationssystemen }, year = { 2007 }, school = { University of Paderborn }, files = { EXT: pdf/becker07_fg_Diplomarbeit-final.pdf,slides/becker07_fg_Vortrag.pdf }, sorting = { 40960 }, priority = { 1 } } @phdthesis{BOH11, author = { Johannes Bohnet }, title = { Visualization of Execution Traces and its Application to Software Maintenance }, year = { 2011 }, abstract = { Maintaining complex software systems tends to be costly because developers spend a significant part of their time with trying to understand the system’s structure and behavior. Among many reasons, program understanding is time consuming because the system’s structure and its internal behavior are not intuitively realizable and can only be partially inspected. The visualization of execution traces represents an approach to help developers to understand complex systems. Practically, execution trace visualization captures the sequence of function calls over time during system execution, analyzes and abstracts that data, and derives visual representations that permit developers to analyze the system’s structure and behavior. The goal of this thesis is to develop a trace visualization concept and tool that can handle the computational and cognitive scalability issues that trace visualization encounters due to the large amount of data that is typically produced when logging runtime processes. The thesis’ concept includes the following building blocks: (1) A concept for generating traces of C/C++ software systems in a scalable way; (2) a concept for trace reduction that automatically identifies recursive boundaries within the trace and, by this, supports developers in exploring a trace using a top-down approach; (3) a framework for trace visualization techniques that provides solutions to the question as to how core techniques for viewing trace data can be implemented such that developers are supported in performing top-down and bottom-up comprehension strategies; and (4) a concept for combining trace visualization with 3rd party tools and systems for reverse engineering. As a further contribution, this thesis validates the proposed concept by means of an implementation, performance measurements, and case studies. The implementation of the concept is provided as a framework for creating trace visualization tools. To ensure scalability of the concept, performance measurements were taken while applying the tool to large C/C++ software systems. Furthermore, the concept and tool has been experimentally applied to industrially developed software systems to solve particular maintenance problems in real-world scenarios. }, affiliation = { University of Potsdam }, school = { Hasso-Plattner-Institut, University of Potsdam }, files = { fileadmin/user_upload/fachgebiete/doellner/publications/2011/BOH11/2011-phd-dissertation-bohnet.pdf }, sorting = { 4 }, priority = { 1 } } @techreport{BeckerG12, author = { Basil Becker and Holger Giese }, title = { Cyber-Physical Systems with Dynamic Structure: Towards Modeling and Verification of Inductive Invariants }, year = { 2012 }, number = { 62 }, abstract = { Cyber-physical systems achieve sophisticated system behavior exploring the tight interconnection of physical coupling present in classical engineering systems and information technology based coupling. A particular challenging case are systems where these cyber-physical systems are formed ad hoc according to the specific local topology, the available networking capabilities, and the goals and constraints of the subsystems captured by the information processing part. In this paper we present a formalism that permits to model the sketched class of cyber-physical systems. The ad hoc formation of tightly coupled subsystems of arbitrary size are specified using a UML-based graph transformation system approach. Differential equations are employed to define the resulting tightly coupled behavior. Together, both form hybrid graph transformation systems where the graph transformation rules define the discrete steps where the topology or modes may change, while the differential equations capture the continuous behavior in between such discrete changes. In addition, we demonstrate that automated analysis techniques known for timed graph transformation systems for inductive invariants can be extended to also cover the hybrid case for an expressive case of hybrid models where the formed tightly coupled subsystems are restricted to smaller local networks. }, note = { to appear }, institution = { Hasso-Plattner-Institute at the University of Potsdam }, files = { fileadmin/user_upload/fachgebiete/giese/pdf/BeckerG12_iccps2011.pdf }, sorting = { 8704 } } @techreport{BGN09-TR, author = { Basil Becker and Holger Giese and Stefan Neumann }, title = { Correct Dynamic Service-Oriented Architectures: Modeling and Compositional Verification with Dynamic Collaborations }, year = { 2009 }, number = { 29 }, abstract = { Service-oriented modeling employs collaborations to capture the coordination of multiple roles in form of service contracts. In case of dynamic collaborations the roles may join and leave the collaboration at runtime and therefore complex structural dynamics can result, which makes it very hard to ensure their correct and safe operation. We present in this paper our approach for modeling and verifying such dynamic collaborations. Modeling is supported using a well-defined subset of UML class diagrams, behavioral rules for the structural dynamics, and UML state machines for the role behavior. To be also able to verify the resulting service-oriented systems, we extended our former results for the automated verification of systems with structural dynamics and developed a compositional reasoning scheme, which enables the reuse of verification results. We outline our approach using the example of autonomous vehicles that use such dynamic collaborations via ad-hoc networking to coordinate and optimize their joint behavior. }, institution = { Hasso Plattner Institute at the University of Potsdam }, files = { EXT: pdf/BGN09-TR_techreport.pdf }, isbn = { 978-3-940793-91-1 }, issn = { 1613-5652 }, sorting = { 52480 } } @misc{TnTDemo2007, author = { Robert Hirschfeld and Michael Haupt and Peter Osburg and Michael Perscheid and Martin Beck and Stefan Berger and Gregor Gabrysiak and Thomas Kowark and Dominic Letz and David Tibbe and Matthias Wagner }, title = { {Tours and Traps---Complex Software, with Simple Tools, in Time} }, year = { 2007 }, abstract = { Context-aware applications extend the reach of mobile users. The availability of current traffic information helps to avoid harmful to life-threatening situations. Convenient support for planning and enjoying sightseeing tours makes sharing impressions easy and fun. Eight undergraduate students of the Hasso-Plattner-Institut Potsdam collaborated during their bachelor project with DoCoMo Euro-Labs, the European research facility of NTT DoCoMo Japan, in the design and implementation of infrastructure components to mediate between the ContextWatcher application and network-side services. Within less than six months they have implemented and deployed two complex end-user scenarios: the planning of sightseeing tours and the reporting of traffic hazards. Equipped with a mobile phone and a GPS receiver, customers are provided with context-specific information when needed: They are alerted about family members or friends nearby, directed to points of interest, or warned about danger zones. At the end of a trip, memorable events and associated media are collected and shared with others. A simple yet comfortable Web interface helps in both preparing and recollecting trips like that. The demonstration will emphasize how all this was possible with a small team of undergrads. It will show how consequently following the principles of agile development (extreme programming), working with a highly dynamic language (Squeak Smalltalk), and taking advantage of a powerful Web application framework (Seaside) facilitated the completion of the project in time. }, note = { Demonstration at ECOOP 2007, Berlin }, sorting = { 18176 } }