article_krogmann.bib

@article{krogmann2014a,
  abstract = {Mit der zunehmenden Verbreitung agiler Softwareentwicklung steigt auch die Zahl problematischer Projekte. Ziele wie eine schnelle Reaktionsf\"{a}higkeit auf \"{A}nderungsw\"{u}nsche werden nicht erreicht, obwohl (vordergr\"{u}ndig) nach agilen Grunds\"{a}tzen vorgegangen wird. Im Artikel fassen wir wiederkehrende Praxiserlebnisse in Form von Anti-Patterns zusammen und schildern, wie agile Entwicklung wiederholt zu dogmatisch gelebt oder als Ausrede f\"{u}r schlechte Projektorganisation missbraucht wurde. Diese Anti-Patterns erm\"{o}glichen dem Leser eigene Projekte auf \"{a}hnliche Missst\"{a}nde zu pr\"{u}fen und gegebenenfalls dagegen anzugehen.},
  author = {Klaus Krogmann and Matthias Naab and Oliver Hummel},
  journal = {{JAXenter Business Technology}},
  month = {June},
  pages = {29--34},
  title = {{Agile Anti-Patterns -- Warum viele Organisationen weniger agil sind, als sie denken}},
  url = {http://jaxenter.de/Business-Technology/Business-Technology-214-173734},
  volume = {2.14},
  year = {2014}
}
@article{krogmann2015a,
  author = {Klaus Krogmann and Matthias Naab and Oliver Hummel},
  journal = {{Entwickler Magazin Spezial: Agilit{\"a}t}},
  month = {March},
  note = {re-published article},
  title = {{Agile Anti-Patterns -- Warum viele Organisationen weniger agil sind, als sie denken}},
  url = {https://entwickler.de/special-issue/entwickler-magazin-spezial-vol-3-agilitaet-127662.html},
  volume = {3},
  year = {2015}
}
@article{kuester2014a,
  abstract = {For the evolution of software, understanding of the context, i.e. history and rationale of the existing artifacts, is crucial to avoid ignorant surgery", i.e. modifications to the software without understanding its design intent. Existing works on recording architecture decisions have mostly focused on architectural models. We extend this to code models, and introduce a catalog of code decisions that can be found in object-oriented systems. With the presented approach, we make it possible to record design decisions that are concerned with the decomposition of the system into interfaces, classes, and references between them, or how exceptions are handled. Furthermore, we indicate how decisions on the usage of Java frameworks (e.g. for dependency injection) can be recorded. All decision types presented are supplied with OCL-constraints to check the validity of the decision based on the linked code model.},
  author = {Martin K{\"u}ster and Klaus Krogmann},
  journal = {Softwaretechnik-Trends},
  month = {May},
  number = {2},
  pages = {58---59},
  title = {{Checkable Code Decisions to Support Software Evolution}},
  url = {http://pi.informatik.uni-siegen.de/stt/34_2/01_Fachgruppenberichte/WSRDFF/wsre_dff_2014-05_submission_d3.pdf},
  volume = {34},
  year = {2014}
}
@article{klatt2013d-STT,
  abstract = {Change impact analysis aims to provide insights about efforts and effects of a change to be expected, and to prevent missed adaptations. However, the benefit of applying an analysis in a given scenario is not clear. Only a few studies about change impact analysis ap- proaches compare the actual effort spent implement- ing the change with the prediction of the analysis. To gain more insight about change impact analysis benefits, we have performed a case study on chang- ing a software's input data model. We have applied two analyses, using the Java compiler and a depen- dency graph based approach, before implementing the actual change. In this paper, we present the re- sults, showing that i) syntactically required changes have been predicted adequately, iii) changes required for semantical correctness required the major effort but were not predicted at all, and iii) tool support for change impact analysis still needs to be improved.},
  author = {Benjamin Klatt and Martin K\"uster and Klaus Krogmann and Oliver Burkhardt},
  journal = {{Softwaretechnik-Trends}},
  month = {May},
  number = {2},
  pages = {53--54},
  pdf = {http://pi.informatik.uni-siegen.de/stt/33_2/01_Fachgruppenberichte/wsr/17_klatt.pdf},
  publisher = {K{\"o}llen Druck & Verlag GmbH},
  title = {{A Change Impact Analysis Case Study: Replacing the Input Data Model of SoMoX}},
  volume = {33},
  year = {2013}
}
@article{klatt2014e,
  abstract = {When implementing a software, developers express conceptual knowledge (e.g. about a specific feature) not only in program language syntax and semantics but also in linguistic information stored in identifiers (e.g. method or class names). Based on this habit, Natural Language Program Analysis (NLPA) is used to improve many different areas in software engineering such as code recommendations or program analysis. Simplified, NLPA algorithms collect identifier names and apply term processing such as camel case splitting (i.e. "MyIdentifier" to "My" and "Identifier") or stemming (i.e. "records" to "record") to subsequently perform further analyzes. In our research context, we search for code locations sharing similar terms to link them with each other. In such types of analysis, filtering stop words is essential to reduce the number of useless links.},
  author = {Benjamin Klatt and Klaus Krogmann and Volker Kuttruff},
  journal = {Softwaretechnik-Trends},
  month = {May},
  number = {2},
  pages = {85--86},
  title = {{Developing Stop Word Lists for Natural Language Program Analysis}},
  url = {http://sdqweb.ipd.kit.edu/publications/pdfs/klatt2014c.pdf},
  volume = {34},
  year = {2014}
}
@article{klatt2014f,
  abstract = {Reusing existing software solutions as initial point for new projects is a frequent approach in software business. Copying existing code and adapting it to customer-specific needs allows for exible and efficient software customization in the short term. But in the long term, a Software Product Line (SPL) approach with a single code base and explicitly managed variability reduces maintenance effort and eases instantiation of new products.},
  author = {Benjamin Klatt and Klaus Krogmann and Christian Wende},
  journal = {Softwaretechnik-Trends},
  month = {May},
  number = {2},
  pages = {64--65},
  title = {{Consolidating Customized Product Copies to Software Product Lines}},
  url = {http://pi.informatik.uni-siegen.de/stt/34_2/01_Fachgruppenberichte/WSRDFF/wsre_dff_2014-08_submission_w8.pdf},
  volume = {34},
  year = {2014}
}
@article{klatt2012b,
  address = {Bamberg, Germany},
  author = {Benjamin Klatt and Klaus Krogmann},
  booktitle = {Proceedings of the 1st Workshop on Model-Based and Model-Driven Software Modernization (MMSM'12)},
  journal = {Softwaretechnik-Trends},
  month = {March},
  number = {2},
  pages = {13-14},
  pdf = {http://sdqweb.ipd.kit.edu/publications/pdfs/klatt2012b.pdf},
  publisher = {K{\"o}llen Druck & Verlag GmbH},
  title = {{Model-Driven Product Consolidation into Software Product Lines}},
  url = {http://dx.doi.org/10.1007/BF03323457},
  volume = {32},
  year = {2012}
}
@article{KlKr2011-STT-SPLToolSupport,
  abstract = {Software vendors often need to vary their products to satisfy customer-specific requirements. In many cases, existing code is reused and adapted to the new project needs. This copy&paste course of action leads a multiproduct code-base that is hard to maintain. Software Product Lines (SPL) emerged as an appropriate concept to manage product families with common functionality and code bases. Evolutionary SPLs, with a product-first-approach and an exposed product line, provide advantages such as a reduced time-to-market and SPLs based on evaluated and proven products.},
  address = {Bad-Honnef, Germany},
  author = {Benjamin Klatt and Klaus Krogmann},
  journal = {{Softwaretechnik-Trends}},
  month = {May},
  number = {2},
  pages = {38--39},
  pdf = {http://sdqweb.ipd.uka.de/publications/pdfs/KlKr2011-WSR-SPLToolSupport.pdf},
  publisher = {K{\"o}llen Druck & Verlag GmbH},
  title = {{Towards Tool-Support for Evolutionary Software Product Line Development}},
  volume = {31},
  year = {2011}
}
@article{krogmann2007a,
  abstract = {Die Verwendung von Komponenten ist ein anerkanntes Prinzip in der Software-Entwicklung. Dabei werden Software-Komponenten zumeist als \textit{Black-Boxes} aufgefasst , deren Interna vor einem Komponenten-Verwender verborgen sind. Zahlreiche Architektur-Analyse-Verfahren, insbesondere solche zur Vorhersage von nicht-funktionalen Eigenschaften, ben{\"o}tigen jedoch Informationen {\"u}ber Interna (bspw. die Anzahl abgearbeiteter Schleifen oder Aufrufe externer Dienste), die von den vielen Komponentenmodellen nicht angeboten werden. F{\"u}r Forscher, die aktuell mit der Analyse nicht-funktionaler Eigenschaften von komponentenbasierten Software-Architekturen besch{\"a}ftigt sind, stellt sich die Frage, wie sie an dieses Wissen {\"u}ber Komponenten-Interna gelangen. Dabei m{\"u}ssen existierende Software-Komponenten analysiert werden, um die ben{\"o}tigten Informationen {\"u}ber das Innere der Komponenten derart zu rekonstruieren, dass sie f{\"u}r anschlie"sende Analyse-Verfahren nicht-funktionaler Eigenschaften genutzt werden k{\"o}nnen. Bestehende Verfahren konzentrieren sich auf die Erkennung von Komponenten oder bspw. das Reengineering von Sequenzdiagrammen gegebener Komponenten, fokussieren aber nicht auf die Informationen, die von Vorhersageverfahren f{\"u}r nicht-funktionale Eigenschaften ben{\"o}tigt werden. Der Beitrag dieses Papiers ist eine genaue Betrachtung der Informationen, die das Reengineering von Komponenten-Interna liefern muss, um f{\"u}r die Vorhersage der nicht-funktionalen Eigenschaft Performanz (im Sinne von Antwortzeit) nutzbringend zu sein. Dazu wird das Palladio Komponentenmodell \cite{Becker} vorgestellt, das genau f{\"u}r diese Informationen vorbereitet ist. Schlie{\ss}lich wird ein Reengineering-Ansatz vorgestellt, der dazu geeignet ist, die ben{\"o}tigten Informationen zu gewinnen.},
  author = {Krogmann, Klaus},
  journal = {Softwaretechnik-Trends},
  month = {May},
  number = {2},
  pages = {44--45},
  title = {{R}eengineering von {S}oftware-{K}omponenten zur {V}orhersage von {D}ienstg{\"u}te-{E}igenschaften},
  url = {http://pi.informatik.uni-siegen.de/stt/27_2/01_Fachgruppenberichte/WSR/21krogmann.pdf},
  volume = {27},
  year = {2007}
}
@article{krogmann2009c,
  abstract = {In component-based software engineering, existing components are often re-used in new applications. Correspondingly, the response time of an entire component-based application can be predicted from the execution durations of individual component services. These execution durations depend on the runtime behaviour of a component, which itself is influenced by three factors: the execution platform, the usage profile, and the component wiring. To cover all relevant combinations of these influencing factors, conventional prediction of response times requires repeated deployment and measurements of component services for all such combinations, incurring a substantial effort. This paper presents a novel comprehensive approach for reverse engineering and performance prediction of components. In it, genetic programming is utilised for reconstructing a behaviour model from monitoring data, runtime bytecode counts and static bytecode analysis. The resulting behaviour model is parametrised over all three performance-influencing factors, which are specified separately. This results in significantly fewer measurements: the behaviour model is reconstructed only once per component service, and one application-independent bytecode benchmark run is sufficient to characterise an execution platform. To predict the execution durations for a concrete platform, our approach combines the behaviour model with platform-specific benchmarking results. We validate our approach by predicting the performance of a file sharing application.},
  author = {Klaus Krogmann and Michael Kuperberg and Ralf Reussner},
  doi = {http://doi.ieeecomputersociety.org/10.1109/TSE.2010.69},
  editor = {Mark Harman and Afshin Mansouri},
  issn = {0098-5589},
  journal = {IEEE Transactions on Software Engineering},
  number = {6},
  pages = {865--877},
  publisher = {{IEEE}},
  title = {{Using Genetic Search for Reverse Engineering of Parametric Behaviour Models for Performance Prediction}},
  url = {http://sdqweb.ipd.kit.edu/publications/pdfs/krogmann2009c.pdf},
  volume = {36},
  year = {2010}
}
@article{krogmann2009b,
  abstract = {Die Verwendung von Komponenten ist ein anerkanntes Prinzip in der Software-Entwicklung. Dabei werden Software-Komponenten zumeist als Black-Boxes aufgefasst, deren Interna vor einem Komponenten-Verwender verborgen sind. Architektur-Analyse- Verfahren zur Vorhersage nicht-funktionaler Eigenschaften erlauben bspw. auf der Architekturebene Dimensionierungsfragestellungen fuer Hardware- / Software-Umgebungen zu beantworten, sowie Skalierbarkeitsanalysen und Was-Waere-Wenn-Szenarien fuer die Erweiterung von Altsystemen durchzufuehren. Dazu benoetigen sie jedoch Informationen ueber Interna (bspw. die Anzahl abgearbeiteter Schleifen oder Aufrufe externer Dienste) von Komponenten. Um an solche Informationen zu gelangen muessen existierende Software-Komponenten analysiert werden. Die benoetigten Informationen ueber das Innere der Komponenten muessen dabei derart rekonstruiert werden, dass sie fuer anschlie{\ss}ende Analyseverfahren nicht-funktionaler Eigenschaften genutzt werden koennen. Eine haendische Rekonstruktion solcher Modelle scheitert haeufig an der Groe{\ss}e der Systeme und ist sehr fehleranfaellig, da konsistente Abstraktionen ueber potentiell tausende Zeilen von Code gefunden werden muessen. Bestehende Verfahren liefern dabei nicht die notwendigen Daten- und Kontrollflussabstraktionen die fuer Analysen und Simulationen benoetigt werden. Der Beitrag dieses Papiers ist ein Reverse Engineering Verfahren fuer Komponentenverhalten. Die daraus resultierenden Modelle (Palladio Komponentenmodell) eignen sich zur Vorhersage von Performanz-Eigenschaften (Antwortzeit, Durchsatz) und damit fuer die oben angefuehrten Fragestellungen. Die aus Quellcode rekonstruierten Modelle umfassen parametrisierten Kontroll- und Datenfluss fuer Software-Komponenten und stellen eine Abstraktion realer Zusammenh\"{a}nge im Quellcode dar. Das Reverse Engineering Verfahren kombiniert dabei ueber Genetische Programmierung (einer Form von Maschinen Lernen) statische und dynamische Analyseverfahren.},
  author = {Klaus Krogmann and Ralf Reussner},
  issn = {ISSN 0720-8928},
  journal = {Softwaretechnik-Trends},
  month = {May},
  number = {2},
  pages = {22--24},
  title = {{Reverse Engineering von Software-Komponentenverhalten mittels Genetischer Programmierung}},
  url = {http://pi.informatik.uni-siegen.de/stt/29_2/01_Fachgruppenberichte/SRE/10-krogmann.pdf},
  volume = {29},
  year = {2009}
}