abstract

Replicating software performance experiments is difficult. A common obstacle to replication is that recreating the hardware and software environments is often impractical. As researchers usually run their experiments on the hardware and software that happens to be available to them, recreating the experiments would require obtaining identical hardware, which can lead to high costs. Recreating the software environment is also difficult, as software components such as particular library versions might no longer be available. Cheap, standardized hardware components like the Raspberry Pi and portable software containers like the ones provided by Docker are a potential solution to meet the challenge of replicability. In this paper, we report on experiences from replicating performance experiments on Raspberry Pi devices with and without Docker and show that good replication results can be achieved for microbenchmarks such as JMH. Replication of macrobenchmarks like SPECjEnterprise 2010 proves to be much more difficult, as they are strongly affected by (non-standardized) peripherals. Inspired by previous microbenchmarking experiments on the Pi platform, we furthermore report on a systematic analysis of response time fluctuations, and present lessons learned on dos and don»ts for replicable performance experiments

abstract
Developing Big Data applications implies a lot of schematic or complex structural tasks, which can easily lead to implementation errors and incorrect analysis results. In this paper, we present a model-based approach that supports the automatic generation of code to handle these repetitive tasks, enabling data engineers to focus on the functional aspects without being distracted by technical issues. In order to identify a solution, we analyzed different Big Data stream-processing frameworks, extracted a common graph-based model for Big Data streaming applications and developed a tool to graphically design and generate such applications in a model-based fashion (in this work for Apache Storm). Here, we discuss the concepts of the approach, the tooling and, in particular, experiences with the approach based on feedback of our partners.

abstract
In large and complex systems there is a need to monitor resources as it is critical for system operation to ensure sufficient availability of resources and to adapt the system as needed. While there are various (resource)-monitoring solutions, these typically do not include an analysis part that takes care of analyzing violations and responding to them. In this paper we report on experiences, challenges and lessons learned in creating a solution for performing requirements-monitoring for resource constraints and using this as a basis for adaptation to optimize the resource behavior. Our approach rests on reusing two previous solutions (one for resource monitoring and one for requirements-based adaptation) that were built in our group.

abstract
EASy-Producer is an open-source research toolset for engineering product lines, variability-rich software ecosystems, and dynamic software product lines. In this tutorial, we will focus on its (textual) variability modeling capabilities as well as its configuration and validation functionality. Further, we will provide an outlook on how EASy-Producer can be applied to variability instantiation.

abstract
Dynamic Software Product Lines (DSPLs) is still an incipient paradigm to support runtime reconfiguration of systems that need to change their behavior under varying circumstances. As many modern systems demand reconfiguration after post-deployment time, this 10th edition of the DSPL workshops attempts to bring new insight and approaches for such needs.

abstract
Replicating results of performance benchmarks can be difficult. A common problem is that researchers often do not have access to identical hardware and software setups. Modern single-board computers like the Raspberry Pi are standardized, cheap, and powerful enough to run many benchmarks, although probably not at the same performance level as desktop or server hardware. In this paper, we use the MooBench micro-benchmark to investigate to what extent Raspberry Pi is suited as a platform for replicable performance benchmarks. We report on our approach to set up and run the experiments as well as the experience that we made.

abstract
Stream processing is a popular paradigm to process huge amounts of data. During processing, the actual characteristics of the analyzed data streams may vary, e.g., in terms of volume or velocity. To provide a steady quality of the analysis results, runtime adaptation of the data processing is desirable. While several techniques for changing data stream processing at runtime do exist, one specific challenge is to minimize the impact of runtime adaptation on the data processing, in particular for real-time data analytics. In this paper, we focus on the runtime switching among alternative distributed algorithms as a means for adapting complex data stream processing tasks. We present an approach, which combines stream re-routing with buffering and stream synchronization to reduce the impact on the data streams. Finally, we analyze and discuss our approach in terms of a quantitative evaluation.

abstract
Creating product lines of Big Data stream processing applications introduces a number of novel challenges to variability modeling. In this paper, we discuss these challenges and demonstrate how advanced variability modeling capabilities can be used to directly model the topology of processing pipelines as well as their variability. We also show how such processing pipelines can be modeled, configured and validated using the Integrated Variability Modeling Language (IVML).

abstract
While dynamic software product lines focus on runtime variability, traditional software product lines typically aim at development-time variability. In this paper, we argue that integrating both kinds of binding times into a single variability model can be beneficial for modeling the adaptation space as well as for controlling runtime decision making. We achieve this by a mix of modeling and constraint capabilities. We illustrate the integration of compile time and runtime variability using a general-purpose variability modeling language and an example from the field of adaptive data stream processing. We also discuss advantages and disadvantages of our approach.

abstract
Big Data aims at the efficient processing of massive amounts of data. Performance modeling is often used to optimize performance of systems under development. Based on experiences from modeling Big Data solutions, we describe some problems in applying performance modeling and discuss potential solution approaches.

abstract
Reproducibility and repeatability are key properties of benchmarks. However, achieving reproducibility can be difficult. We faced this while applying the micro-benchmark MooBench to the resource monitoring framework SPASS-meter. In this paper, we discuss some interesting problems that occurred while trying to reproduce previous benchmarking results. In the process of reproduction, we extended MooBench and made improvements to the performance of SPASS-meter. We conclude with lessons learned for reproducing (micro-)benchmarks.

abstract
Software Product Line Engineering (SPLE) is a systematic approach for the development of related software products. These products share a common infrastructure but vary with respect to their individual capabilities, called variabilities. Variability management is a key part of SPLE and is responsible for developing, combining and configuring such variabilities. As these activities are inherently complex, SPLE significantly benefits from tool-support. We developed a customizable Eclipse extension for SPLE that consists of around 38 plug-ins. The resulting tool, called EASy-Producer, extends the Eclipse IDE by the capability to support the creation and management of software product line projects. To provide this capability, EASy-Producer utilizes the extension concepts of the Eclipse platform and integrates additional frameworks, like Xtext. In this paper, we share our experience while applying the Eclipse technologies and, in particular, realizing specific capabilities of our tool using the Eclipse framework. The focus of this paper is on our lessons learned regarding managing workspace information and conflicting build mechanism as well as using Eclipse extensions outside of Eclipse. These lessons serve as an input to the Eclipse community and may help other developers in realizing a complex Eclipse extension.

abstract
Variability-rich Software Ecosystems need configuration capabilities just as in any product line. However, various additional capabilities are required, taking into account the software ecosystem characteristics. In order to address these specific needs, we developed the Integrated Variability Modeling Language (IVML) for describing configurations of variability-rich software ecosystems. IVML is a variability modeling and configuration language along with accompanying reasoning facilities.

abstract
The EASy-Producer product line environment is a novel open-source tool that supports the lightweight engineering of software product lines and variability-rich software ecosystems. It has been applied in several industrial case studies, showing its practical applicability both from a stability and a capability point of view. The tool set integrates both, interactive configuration capabilities and a DSL-based approach to variability modeling, configuration definition and product derivation. The goal of the tutorial is to provide the participants with an overview of the tool. However, the main focus will be on a brief introduction of the DSLs. After participating in the tutorial, the participants will understand the capabilities of the toolset and will have a basic practical understanding of how to use it to define software ecosystems and derive products from them.

abstract
Big data applications with their high-volume and dynamically changing data streams impose new challenges to application performance management. Efficient and effective solutions must balance performance versus result precision and cope with dramatic changes in real-time load and needs without over-provisioning resources. Moreover, a developer should not be burdened too much with addressing performance management issues, so he can focus on the functional perspective of the system For addressing these challenges, we present a novel comprehensive approach, which combines software configuration, model-based development, application performance management and runtime adaptation.

abstract
Variability modeling is a major part of modern product line engineering. Graphical or table-based approaches to variability modeling are focused around abstract models and specialized tools to interact with these models. However, more recently textual variability modeling languages, comparable to some extent to programming languages, were introduced. We consider the recent trend in product line engineering towards textual variability modeling languages as a phenomenon, which deserves deeper analysis. In this article, we report on the results and approach of a literature survey combined with an expert study. In the literature survey, we identified 11 languages, which enable the textual specification of product line variability and which are sufficiently described for an in-depth analysis. We provide a classification scheme, useful to describe the range of capabilities of such languages. Initially, we identified the relevant capabilities of these languages from a literature survey. The result of this has been refined, validated and partially improved by the expert survey. A second recent phenomenon in product line variability modeling is the increasing scale of variability models. Some authors of textual variability modeling languages argue that these languages are more appropriate for large-scale models. As a consequence, we would expect specific capabilities addressing scalability in the languages. Thus, we compare the capabilities of textual variability modeling techniques, if compared to graphical variability modeling approaches and in particular to analyze their specialized capabilities for large-scale models.

abstract
In software product line engineering, the design of assets for reuse and the derivation of software products entails low-level and high-level decision making. In this process, two major types of decisions must be addressed: variability decisions, i.e., decisions made as part of variability management, and architectural decisions, i.e., fundamental decisions to be made during the design of the architecture of the product line or the products. In practice, variability decisions often overlap with or influence architectural decisions. For instance, resolving a variability may enable or prevent some architectural options. This inherent interdependence has not been explicitly and systematically targeted in the literature, and therefore, is mainly resolved in an ad hoc and informal manner today. In this paper, we discuss possible ways how variability and architectural decisions interact, as well as their management and integration in a systematic manner. We demonstrate the integration between the two types of decisions in a motivating case and leverage existing tools for implementing our proposal.

abstract
Development of software product lines requires tool support, e.g., to define variability models, to check variability models for consistency and to derive the artifacts for a specific product. Further capabilities are required when product lines are combined to software ecosystems, i.e., management and development of distributed product lines across multiple different organizations. In this paper, we describe EASy-Producer, a prototypical tool set for the development of software product lines in general and variant-rich ecosystems in particular. To support the product line engineer, EASy-Producer differentiates between simplified views limiting the capabilities and expert views unleashing its full power. We will discuss how these two views support the definition of variability models, the derivation of product configurations and the instantiation of artifacts.

abstract
The resource requirements of Big Data applications may vary dramatically over time, depending on changes in the context. If resources should not be defined for the maximum case, but available resources are mostly static, there is a need to adapt resource usage by modifying the processing behavior. The QualiMaster project researches such an approach for the analysis of systemic risks in the financial markets.

abstract
Industrial variability models tend to grow in size and complexity due to ever-increasing functionality and complexity of software systems. Some authors report on variability models specifying several thousands of variabilities. However, traditional variability modeling approaches do not seem to scale adequately to cope with size and complexity of such models. Recently, textual variability modeling languages have been advocated as one scalable solution. In this paper, we provide a systematic analysis of the capabilities of current textual variability modeling languages, in particular regarding variability management in the large. Towards this aim, we define a classification schema consisting of five dimensions, classify ten different textual variability modeling languages using the classification schema and provide an analysis. In summary, some textual variability modeling languages go beyond textual representations of traditional variability modeling approaches and provide sophisticated modeling concepts and constraint languages. Three textual variability modeling approaches already support mechanisms for large-scale variability modeling such as model composition, modularization, or evolution support.

abstract
Variability modeling is a core activity of software product line engi-neering. Over the years, many different approaches to variability modeling have been proposed. Typically, the individual approaches have been designed with-out a detailed justification on why certain modeling concepts should be used. This yields a rather unfunded selection of modeling approaches in practice, e.g., selecting approaches that provide higher modeling concepts than actually need-ed, but less analyses capabilities than required. Thus, we propose that the focus of an analysis should not be to determine the best modeling language, but rather to provide a characterization on when to use what kind of approach. In particu-lar, the selection of one approach for a specific situation should be driven from the required modeling concepts (expressiveness) and the required analyzability. In this paper, we propose a classification of core concepts of variability model-ing based on expressiveness and analyzability. We discuss the methodology for and the classification of variability modeling concepts illustrated by a running example. The contribution of this paper is a modeling approach-independent classification of variability modeling concepts and their dependencies to pro-vide a systematic and rationale basis to anyone designing, standardizing, im-plementing or selecting a specific variability modeling approach.

abstract
Service-Oriented Computing (SoC) has been established as an important paradigm over the last decade. A particularly important part in a service-oriented solution is the service-oriented platform. This provides an environment and infrastructure for a number of service-oriented applications. An important challenge in complex application areas is the need to customize these platforms to the demands of a specific context. Product line technologies can support this by providing the concept of variability management to SoC. In this paper, we will provide a reference model for (domain-specific) service platforms and describe different approaches that provide customization possibilities in a service platform context. The complexity of handling the customization of large-scale service platforms in an integrated manner will be addressed by introducing the concept of production strategies for variability implementation techniques.

abstract
In service-oriented systems services can be easily reused and shared without modification. However, there are business situations where a variation of services is needed to meet the requirements of a specific customer or context. Variation of software systems has been well researched in product line engineering in terms of Variability Implementation Techniques (VITs). While most VITs focus on the customization of traditional software systems, several VITs have been developed for service-oriented systems. In this paper, we discuss the problem of service customization and provide an overview of different VITs for service variability. For this purpose, we will define four dimensions to describe, characterize and analyze existing VITs: the technical core idea, the object of variation, the forms of variation, and the binding time.

abstract
Die Erfassung von Produktmetriken zur Laufzeit ist ein wesentlicher Baustein einer Qualitätsstrategie in der Produktentwicklung. Die Erfassung von Produktmetriken in der Entwicklung ist jedoch oft mit signifikantem Aufwand verbunden, da viele Werkzeuge nur bestimmte Eigenschaften erfassen können und ihre Verwendung oft sehr komplex ist. Darüber hinaus entsteht durch die Durchführung der Messung meist ein signifikanter Laufzeit-Overhead. Das Ziel des SPASS-meter-Werkzeugs ist die integrierte Erfassung einer Vielzahl von Metriken bei einfacher Konfiguration und geringem Laufzeit-Overhead. In diesem Beitrag stellen wir SPASS-meter vor und vergleichen es mit bekannten ähnlichen Werkzeugen wie Kieker, OpenCore, Xprof und HPROF. Eine Übersicht der Stärken und Schwächen schließt den Vergleich ab.

abstract
Die Anpassung von Anforderungswerkzeugen an den Projektkontext ist im Regelfall durch die Anpassungsfähigkeiten des jeweiligen Werkzeuges stark eingeschränkt. In diesem Beitrag stellen wir einen generativen Ansatz zur Anpassung von Anforderungswerkzeugen vor und demonstrieren den Ansatz im Rahmen einer Fallstudie. Unser Ansatz ermöglicht die einfache, zielgerichtete und weitreichende Anpassung an die Anwendungssituation.

abstract
Im letzten Jahrzehnt hat sich die Unified Modeling Language (UML) als Modellierungssprache für den praktischen Einsatz im Software Engineering weitgehend durchgesetzt. Aufgrund der Komplexität der UML Spezifikation ist es allerdings für ein einzelnes Werkzeug sehr schwierig, die gesamte Bandbreite der UML Modellierungselemente getreu der UML Spezifikationen umzusetzen. Werkzeugrealisierungen unterscheiden sich daher maßgeblich anhand der von ihnen unterstützten Teile der UML Spezifikation. Die Entscheidung einer Entwicklungsorganisation für ein konkretes Modellierungswerkzeug ist bedeutsam für das ganze Unternehmen. Im Regelfall zieht eine derartige Entscheidung empfindliche Kosten nach sich, z.B. für das Training der Mitarbeiter. Lizenzkosten stellen dabei oft nur einen geringen Anteil der tatsächlichen Kosten für ein Werkzeug dar. Folglich sollte eine Werkzeugauswahl mit großer Sorgfalt durchgeführt werden. Die vorliegende Studie ist zurzeit der wohl umfassendste Vergleich von UML Werkzeugen und stellt damit ein geeignetes Hilfsmittel dar, um zu einer rationalen Entscheidung über einzusetzende Werkzeuge zu gelangen. Der Schwerpunkt dieser Studie liegt auf der Umsetzung von Modellierungfähigkeiten durch die Werkzeuge, d.h. ob und wie Modellierungselementen und -eigenschaften der UML umgesetzt wurden. Um die UML Modellierungsfähigkeiten detailliert prüfen zu können, wurde die UML Spezifikation in 476 Merkmale aufgegliedert, die individuell für jedes betrachtete Werkzeug geprüft wurden. Eine detaillierte Aufschlüsselung verknüpft die für jedes Werkzeug identifizierten Fähigkeiten mit den Anforderungen, die von der UML für einzelne Diagrammtypen gemacht werden. Auf diese Weise kann die Anwendbarkeit eines konkreten Werkzeuges für einen gegebenen Anwendungskontext schnell überprüft werden. Als Bestandteil unserer Analyse charakterisieren wir jedes Werkzeug durch Angabe der individuellen UML compliance, einem Kategorisierungsschema der OMG.

abstract
Die Anpassung von Anforderungswerkzeugen an den Projektkontext ist im Regelfall durch die Anpassungsfähigkeiten des jeweiligen Werkzeuges stark eingeschränkt. In diesem Beitrag stellen wir einen generativen Ansatz zur Anpassung von Anforderungswerkzeugen vor und demonstrieren den Ansatz im Rahmen einer Fallstudie. Unser Ansatz ermöglicht die einfache, zielgerichtete und weitreichende Anpassung an die Anwendungssituation.

abstract
The Unified Modeling Language (UML) has been widely adopted in industrial software engineering as the reference standard for software and systems modeling. A wide range of different tools have been developed both by industrial vendors as well as by the open source community. However, due to the complexity of the UML specification it is very difficult for a single tool to support the full range of UML standards faithfully. In practice tools differ significantly in terms of the parts of the UML specification they support

abstract
The Unified Modeling Language (UML) specification is widely adopted in software engineering. When tools do not fully implement the UML specification, the user might be locked-in to a modeling tool, e.g. when exported models are not compatible among tools or tools implement different subsets of the UML. These compatibility problems also have significant impact on the effectiveness of model-driven development approaches. Compliance, as defined by the UML standard, is intended to characterize tools and to highlight such problems. In this paper we describe an approach to asses the UML compliance levels of modeling tools. Using UML definition of compliance, we could only identify 4 out of 68 tools as being acceptable.

abstract
In the past, formatting guidelines have proved to be a successful method to improve the readability of source code. With the increasing success of visual specification languages such as UML for model-driven software engineering visual guidelines are needed to standardize the presentation and the exchange of modeling diagrams with respect to human communication, understandability and readability. In this article, we introduce a new and encompassing taxonomy of visual guidelines capturing the aestheticquality of UMLclassdiagrams. We propose these guidelines as a framework to improve the aestheticquality and thus the understandability of UMLclassdiagrams. To validate this claim, we describe in detail a controlled experiment carried out as a pilot study to gather preliminary insights on the effects of some of the guideline rules on the understandability of UMLclassdiagrams.

abstract
In this paper, we describe EASy-producer, a prototypical production environment for software product lines (SPL), in particular for the realization of adaptive systems and dynamic SPL.

abstract
Model-based and model-driven development will receive increased attention in future software production processes. Currently, UML and the related Model Driven Architecture attract lot of interest in this area, but so far most tools rely on manual visualization techniques and only few tools support automatic visualizations e.g. of intermediary transformation results to support the understanding and debugging of model-driven transformation processes. Aside from structural models or control flow specifications, in particular UML use case diagrams are frequently used to visualize high level views on system functionality and are also considered as source and target models in upcoming model-driven production chains. To support use case diagrams in future software development, in this paper we present guidelines for the layout of UML use case diagrams, a deterministic layout algorithm supporting these guidelines and a prototypical implementation of the algorithm.

abstract
In this paper, we introduce the concept of metavariability, i.e., variability with respect to basic variability attributes like binding time or constraints. While the main focus of this paper is on the introduction of the concept, we will also illustrate the concept by providing a case study. The case study will feature a simple implementation environment based on aspect-oriented programming and will include an example that will exhibit some key characteristics of the envisioned production process.

abstract
Software product lines are, by their very nature, complex software systems. Due to the interconnectedness of the various products in the product line any form of evolution becomes significantly more complex than in a single system situation. So far most work on product line evolution has focused on specific approaches to supporting special cases of the evolution problem. In this paper, we take a different approach and provide a broad taxonomy of requirements-driven evolution in software product lines. This serves as a basis for the identification of requirements on evolution support.

abstract
Subversion hat sich als leistungsfähiges und einfach zu nutzendes Werkzeug für die Konfigurationsverwaltung im Open Source Bereich durchgesetzt. Die Benutzerfreundlichkeit für den Enduser wird insbesondere durch Erweiterungen wie TortoiseSVN unterstützt. Leider fehlt bisher eine entsprechende Unterstützung für die (Remote-) Administration. Diese Erkenntnis war Ausgangspunkt für die Entwicklung von SVNControl. Im Rahmen des Vortrags werden die Anforderungen und die aktuelle Entwicklungsroadmap des Werkzeuges dargestellt, das bereits frei verfügbar ist.

abstract
An evolutionary algorithm that layouts UML class diagrams is developed and described. It evolves the layout by mutating the positions of class symbols, inheritance relations, and associations. The process is controled by a fitness function that is computed from several well-known and some new layout metrics.

abstract
An evolutionary algorithm that layouts UML class diagrams is developed and described. It evolves the layout by mutating the positions of class symbols, inheritance relations, and associations. The process is controled by a fitness function that is computed from several well-known and some new layout metrics.

abstract
UML class diagrams, internationally specified and widely used in software engineering, are a great challenge in automatic drawing of graphs. Due to the complex nature of UML class diagrams and the requirements of software engineers, who need to read these diagrams, layout rules and algorithms for general graphs can not be applied without adaptions, extensions and modifications. In this paper, we present layout rules, a hierarchical layout algorithm and an edge crossing reduction strategy tailored for UML class diagrams. Furthermore, the problem of measuring aesthetic quality is discussed.

abstract
Code transformation and analysis tools provide support for software engineering tasks such as style checking, testing, calculating software metrics as well as reverse- and re-engineering. In this paper we describe the architecture and the applications of JTransform, a general Java source code processing and transformation framework. It consists of a Java parser generating a configurable parse tree and various visitors (transformers, tree evaluators) which produce different kinds of outputs. While our framework is written in Java, the paper further opens an opportunity for a new generation of XML-based source code tools.

abstract
Code transformation and analysis tools provide support for software engineering tasks such as style checking, testing, calculating software metrics as well as reverse- and reengineering. In a reverse step information is picked from a source text in order to facilitate its comprehension, its visualization or the check of agreed standards concerning coding quality or layout. In this short paper (see [3] for details) we describe JTransform, a general Java source code processing and transformation framework. It consists out of a Java parser generating a configurable parse tree and various visitors (transformers, tree evaluators) which produce different kind of outputs.

abstract
The Unified Modeling Language (UML) [7] has become the standard for specifying object-oriented software systems. Some of the tools are primarily designed to work on a direct mapping between the design diagrams and the software and vice versa. Since understanding the software is usually using more abstract concepts than those defined in programming languages, restriction of the UML used in these tools is not permissible. On the other side, visualization of changes to the software implementation and design documents require sophisticated layout algorithms. In [2] we have shown that most of the tools are not sufficient in that field.

abstract
Even if the standard for specifying software, the Unified Modeling Language, is known in different versions to everybody, CASE tool vendors did not implement all basic features. Even with class diagrams, many features of the standard are ignored. Applying the layout algorithms of these CASE tools to the user defined diagrams, usually horrible results are produced, because state-of-the-art techniques in drawing these diagrams are not respected by the vendors, too. In this paper we give an overview on the current UML tool implementations, the research in the field of drawing class diagrams automatically and the efforts in convincing the community of an agreement on basic aesthetical principles for UML class diagrams in order to simplify reading and understanding of standardized visualization of static aspects of software.

abstract
Analysis and design of programs by using tools has emerged to a standard technique in object-oriented software engineering. Many of these tools claim to implement methods according to the UML standard and some of the tools provide automatic layout of the diagrams drawn by the user or generated automatically from source code. In this paper we propose a set of aesthetic criteria for UML class diagrams and discuss the relation between these criteria, HCI and design aspects of object-oriented software. First we describe critics from the viewpoint of HCI to the UML notation and restrict ourself to changes which do not require nonstandard modifications to the UML notation guide, then we list quality relations between class diagrams and object-oriented software models. After that our set of aesthetic criteria, that redirect the highly sophisticated structural and semantic features of UML class diagrams, is explained. Finally, we show that an implementation and measurement of this proposal is realizable using a prototypical graph drawing framework.

abstract
Fähigkeit existierenden Quellcode einzubinden und das eigene Programm so zu formulieren, dass Teile davon wieder verwendet oder weiter verwertet werden k¨onnen, an. Es ist wichtig die der Programmiersprache zu Grunde liegenden Konzepte [2, 4] zu verstehen und umsetzen zu können. Programmieren kann als ein Handwerk aufgefasst werden, in dem feste Regeln und Konventionen gelten. In letzter Zeit hat sich wie im Handwerk ein Trend ausgebildet, weg von der handwerklichen Erstellung eines Programms von Anfang an, hin zu einer Zusammenstellung und Anpassung vorliegender Halbfabrikate. Wir glauben jedoch, dass die Fähigkeit die Komponenten von Grund auf zu verstehen und auch schreiben zu können unbedingt von einem Informatiker beherrscht werden muss. In diesem Artikel wollen wir Kriterien aufstellen, wie eine Programmierausbildung online über das Internet auszusehen hat, um im Selbststudium Erfolg versprechend eingesetzt werden zu können. Dabei ist die automatische Beurteilung eingereichter Programmieraufgaben wie in [8] ein wesentlicher Punkt, der unseren Ansatz (siehe auch [7, 5]) von den meisten anderen (z.B. [6]) unterscheidet. Wir erläutern dann die Umsetzung dieser Kriterien am Beispiel des Java Online Praktikums (JOP) [5] der vhb.

abstract
In this report we describe the architecture and the applications of JTransform, a general Java source code transformation framework, which consists out of a Java parser generating a parse tree and various visitors (transformers, tree evaluators) which produce different kind of outputs. After a brief introduction, an overview of the current and planned applications is given. Then the architecture and implementation of JTransform is described. The fourth chapter gives advise how to use JTransform and how to construct new applications. In the last chapter we outline some details of the existing applications.

abstract
This report compares the automatic layout facilities of current UML tools including object-oriented CASE tools which support UML. We compare 42 programs listed in different tool lists in the internet [8, 9, 11] which can freely be downloaded or an evaluation licence can be obtained.

abstract
Visualization of object-oriented programs by class diagrams is a widely used technique. So far no commonly agreed aesthetic criteria have been recorded in order to standardize and measure the quality of class diagrams. In this paper we focus on UML class diagrams, the standard notation for class diagrams in software engineering. We propose some aesthetic criteria which reflect the highly sophisticated features of UML class diagrams, a layout algorithm which respects all these features and an implementation of a graph drawing framework which is able to produce drawings according to these criteria.

abstract
Parts of this report have been published in [3] In this report we show how the specification of the Standard Template Library STL and its implementation can be described by UML diagrams. We define appropriate stereotypes to describe STL concepts like containers, iterators, function objects and global algorithms. For the graphical description of the implementation of the STL we extend the UML metamodel. A full set of diagrams comprehending the functional specification of the STL and its implementation is given.

abstract
UMLscript wurde 1998 als Programmiersprache für das objektorientierte Design von Klassendiagrammen entwickelt. Inzwischen wurde die zugrundeliegende Spezifikation der UML Unified Modeling Language überarbeitet. Neben einigen neuen Sprachelementen wurde UMLscript an die Version 1.4 der UML ([2]) angepasst. UMLscript fand Anwendung als Eingabesprache für das Layout-Tool SugiBib. Zunächst wird das Verhältnis zwischen der Originalversion von UMLscript, der vorliegenden Version und UML beleuchtet, dann die Syntax und die informelle Semantik in Form von Syntaxdiagrammen mit Texterläuterung angegeben. Es folgt die Spezifikation von Eigenschaftswerten als Schnittstelle für Tools, einige ausführliche Beispiele und, vor einer abschließenden Diskussion, die Anwendung von UMLscript zur Dokumentation von C++ -Code. Im Anhang ist die Grammatik von UMLscript und ein erweiterter Satz von Eigenschaftswerten zur Anwendung mit dem Layout-Tool SugiBib gegeben.

abstract
UML (Unified Modeling Language) class diagrams, which are widely used for specifying aspects of object-oriented software systems, can be laid out by our tool SugiBib. In 1998 J. Seemann described how to apply the Sugiyama algorithm to class diagrams and the first version of SugiBib was implemented as a masters thesis.

abstract
In this paper we present a graph drawing framework that can be used to automatically draw UML class diagrams and a compiler that extracts the needed information from Java source code. Both components can be combined to a visualization tool for Java programs.

abstract
Sugibib ist ein Framework, das eine allgemeine Implementierung des Sugiyama-Algorithmus bereitstellt. Es wurde ausgeprägt, um das Layout von UML-Klassendiagrammen zu berechnen. In diesem Beitrag wird das Framework und der praktische Einsatz im Software-Entwurf und in der Lehre beschrieben.