abstract

Machine Learning Operations (MLOps) involves software development practices for Machine Learning (ML), including data management, preprocessing, model training, deployment, and monitoring. While MLOps have received significant interest, much less work has been published addressing MLOps in industrial production settings lately, particularly if solutions are not cloud-based. This article addresses this shortcoming based on our and our partner’s real industrial experience in various projects. While there is a broad range of challenges for MLOps in cyber-physical production systems (CPPS), we focus on those related to data, models, and operations as we assume these will directly benefit the reader and provide solutions such as lightweight integration, integration of domain knowledge, periodic calibration, and interactive interfaces. In this way, we want to support practitioners in setting up
industrial MLOps environments in CPPS. Further, we discuss explainability as an additional part of MLOps, which should be explored in more detail in the future.

abstract

Asset Administration Shells are trending in Industry 4.0. In February 2024, the Industrial Digital Twin Association announced 84 and released 18 AAS sub model specifications. As an enabler on programming level, dedicated APIs are needed, for which, at this level of scale, automated creation is desirable. In this paper, we present a model-driven approach, which transforms extracted information from IDTA specifications into an intermediary meta-model and, from there, generates API code and tests. We show we can process all current IDTA specifications successfully leading in total to more than 50000 lines of code. However, syntactical variations and issues in the specifications impose obstacles that require human intervention or AI support. We also discuss experiences that we made and lessons learned.

abstract

Software product line techniques encourage the reuse and adaptation of software components for creating customized products or software systems. These different product variants have commonalities and differences, which are managed by variability modeling. Over the past three decades, both academia and industry have developed numerous variability modeling methods, each with its own advantages and disadvantages. Many of these methods have demonstrated their utility within specific domains or applications. However, comprehending the capabilities and differences among these approaches to pinpoint the most suitable one for a particular use case remains challenging. Thus, new modeling techniques and tailored tools for handling variability are frequently created. Transitioning between variability models through transformations from different approaches can help in understanding the benefits and drawbacks of different modeling approaches. However, implementing such transformations presents challenges, such as semantic preservation and avoiding information loss. TRAVART is a tool that helps with transitioning between different approaches by enabling the transformation of variability models into other variability models of different types. This paper discusses the challenges for such transformations between UVL and IVML. It also presents a one-way transformation from the UVL to IVML with as little information loss as possible

abstract

Container-based virtualization is a popular technique, e.g., to realize microservice architectures. Recently, containers became popular in Industry 4.0 / IIoT systems, which typically consist of hundreds of (edge) devices and machines. In such setups, efficient management of containers is essential as offered by container orchestrators like Kubernetes. However, currently no specific overviews discussing orchestrator capabilities for Industry 4.0 are available. In this paper, we analyze nine open source container orchestrators for their application in Industry 4.0 or IIoT settings as a basis for future research and development. We contribute a systematic literature review to identify 23 basic orchestration requirements. We complement this by insights from an intensive requirements collection in a research project on intelligent industrial production, as well as selected features from a published generic orchestrator analysis. From these 66 requirements, we derive a requirements/feature taxonomy, which we use to analyze the nine open source orchestrators including Kubernetes. We show that there is, e.g., still a lack of support regarding edge devices, IIoT protocols, security mechanisms, and specialized resources for artificial intelligence.

abstract

Real-time and in-process measurements are important in the manufacturing domain, e.g., for real-time process monitoring. For performance reasons, such data is often processed in virtualized environments on edge devices, as e.g., provided by the company Beckhoff. For exploring modern AI methods, integration with high-level languages such as Python or even with Industry 4.0 platforms for advanced data flows is needed.
In this paper, we analyze the read/write performance of a Beckhoff device integrated via Python or Java. For our experiments, we use a simulation on a PC as well as a networked setup with a Beckhoff device. We show that the Java-based solution is faster than the Python one by 2-3 times. We also show that small arrays can be read as fast as a single value, that there is no difference between operations for small or big data types and that there is no difference between reading and writing data.

abstract

Continuous Deployment automates the delivery of new versions of software systems. To ease installation and delivery, often container virtualization is applied. In some applications, container images may be subject to variants, as, e.g., device-specific software is needed on Edge devices in Industry 4.0. Here, model-driven approaches can prevent human errors and save development efforts. However, employing a naive approach, creating one container image per variant can be time-consuming. In this paper, we discuss the impact of different (Docker) container image creation techniques for variant-rich Industry 4.0 applications. Our results show that a combination of techniques like container image stacking or semantic fingerprinting can save up to 59% build time and up to 89% deployment time, while not affecting the container startup time.

abstract

The development of intelligent solutions for manufacturing is a challenging task. Industry 4.0 platforms can provide a unifying layer here. However, flexible AI support, openness for evolving service and components from different vendors and adaptability to the diverse and changing requirements is required from such a platform to boost IIoT development. For this purpose, our approach combines - as a "power trio" - (1) wide use of Asset Administration Shells (AAS) for targeting device, component and service heterogeneity, with (2) configuration support for dealing with the diverse and changing requirements and (3) code generation for cost-effective creation of customer specific platform instances, AAS and AI-based Industry 4.0 applications on top of the IIP-Ecosphere platform. The platform has been implemented based on vertically scaled AAS and evaluated with two Industry 4.0 demonstrators. In this context, we discuss the experiences we made with our approach.

abstract

Um den effektiven und effizienten Betrieb von Cyberphysischen Produktionssystemen (CPPSen) sicherzustellen, spielt Software eine zunehmend wichtige Rolle. Die enormen Fortschritte bei Softwareentwicklungsmethoden, welche in den letzten Jahren erzielt wurden, scheinen jedoch die aktuellen Herausforderungen der Industrie nicht zu erfüllen, weil diese die Industrie nicht oder nur langsam erreichen. In diesem Beitrag werden die Herausforderungen für die Softwareentwicklung in CPPSen aus Sicht von neun Industrievertretern aus acht europäischen Unternehmen unterschiedlicher Größe diskutiert. Um den digitalen Transformationsprozess für eine zukunftsfähige Produktion zu begleiten, wurden aus den beschriebenen Herausforderungen Perspektiven für die Forschung erarbeitet. Die Umsetzung dieser Ziele ist vor dem Hintergrund von ökonomischen, sozialen und Nachhaltigkeitsanforderungen notwendig.

abstract

For a broader adoption of AI in industrial production, adequate infrastructure capabilities and ecosystems are crucial. This includes easing the integration of AI with industrial devices, support for distributed deployment, monitoring, and consistent system configuration. IIoT platforms can play a major role here by providing a unified layer for the heterogeneous Industry 4.0/IIoT context.

However, existing IIoT platforms still lack required capabilities to flexibly integrate reusable AI services and relevant standards such as Asset Administration Shells or OPC UA in an open, ecosystem-based manner. This is exactly what our next level Intelligent Industrial Production Ecosphere (IIP-Ecosphere) platform addresses, employing a highly configurable low-code based approach.

In this paper, we introduce the design of this platform and discuss an early evaluation in terms of a demonstrator for AI-enabled visual quality inspection. This is complemented by insights and lessons learned during this early evaluation activity.

abstract

An important part of the Industry 4.0 vision is the use of machine learning (ML) techniques to create novel capabilitiesand flexibility in industrial production processes. Currently, there is a strong emphasis on MLOps as an enabling collectionof practices, techniques, and tools to integrate ML into industrial practice. However, while MLOps is often discussed inthe context of pure software systems, Industry 4.0 systems received much less attention. So far, there is only little researchfocusing on MLOps for Industry 4.0. In this paper, we discuss whether MLOps in Industry 4.0 leads to significantly dif-ferent challenges compared to typical Internet systems. We provide an initial analysis of MLOps approaches and identifyboth context-independent MLOps challenges (general challenges) as well as challenges particular to Industry 4.0 (specificchallenges) and conclude that MLOps works very similarly in Industry 4.0 systems to pure software systems. This indicatesthat existing tools and approaches are also mostly suited for the Industry 4.0 context.

abstract

Maximizing the benefits of AI for Industry 4.0 is about more than just developing effective new AI methods. Of equal importance is the successful integration of AI into production environments. One open challenge is the dynamic deployment of AI on industrial edge devices within close proximity to manufacturing machines. Our IIP-Ecosphere platform was designed to overcome limitations of existing Industry 4.0 platforms. It supports flexible AI deployment through employing a highly configurable low-code based approach, where code for tailored platform components and applications is generated.
In this paper, we measure the performance of our platform on an industrial demonstrator and discuss the impact of deploying AI from a central server to the edge. As result, AI inference automatically deployed on an industrial edge is possible, but in our case three times slower than on a desktop computer, requiring still more optimizations.

abstract

The Asset Administration Shell (AAS) is an upcoming information model standard, which aims at interoperable modeling of “assets”, i.e., products, machines, services or digital twins in IIoT/Industry 4.0. Currently, a number of IIoT-platforms use proprietary information models similar to AAS, but not a common standard, which affects interoperability.
A key question for a broad uptake is if AAS can be applied in a performant and scalable manner. In this paper, we examine this question for the open source Eclipse BaSyx middleware. To explore capabilities and possible performance limitations, we present four experiments measuring the performance of experimental AAS in BaSyx and, within the context set by our experiments, i.e., 10-1000 AAS instances, can conclude good scalability.

abstract

Kubernetes (K8s) is one of the most frequently used container orchestration tools offering, as it offers a rich set of functions to manage containerized applications, it is customizable and extensible. Container virtualization of applications and their orchestration on heterogeneous resources including edge devices is a recent trend in Industrial Internet of Things (IIoT)/Industry 4.0, where K8s is also applied. However, IIoT/Industry 4.0 is a domain with high standardization requirements. Besides equipment standards, e.g., for electrical control cabinets, there are also demands to standardize network protocols, data formats or information models. Such standards can foster interoperability and reduce complexity or deployment/integration costs. Here, the proprietary communication protocol of K8s and similar orchestrators can be an obstacle for adoption.
To explore this situation from an interoperability and integration perspective, we present in this paper an approach to replace the communication protocol of K8s without modifying its code base. We show by an experiment that applying our approach with three current forms of IIoT communication, namely Message Queuing Telemetry Transport (MQTT), Advanced Message Queuing Protocol (AMQP), and Asset Administration Shell (AAS), does not significantly affect the validity and the performance of K8s.

abstract

An important part of the Industry 4.0 vision is the use of machine learning (ML) techniques to create novel capabilities and flexibility in industrial production processes. Currently, there is a strong emphasis on MLOps as an enabling collection of practices, techniques, and tools to integrate ML into industrial practice. However, while MLOps is often discussed in the context of pure software systems, Industry 4.0 systems received much less attention. So far, there is no specialized research for Industry 4.0 in this regard. In this position paper, we discuss whether MLOps in Industry 4.0 leads to significantly different challenges compared to typical Internet systems. We identify both context-independent MLOps challenges (general challenges) as well as challenges particular to Industry 4.0 (specific challenges) and conclude that MLOps works very similarly in Industry 4.0 systems to pure software systems. This indicates that existing tools and approaches are also mostly suited for the Industry 4.0 context.

abstract

For a broader adoption of AI in industrial production, adequate infrastructure capabilities are crucial. This includes easing the integration of AI with industrial devices, support for distributed deployment, monitoring, and consistent system configuration.

abstract

Für die erfolgreiche Digitalisierung in der Produktion ist die IT-Infrastruktur, zum Beispiel zur einfachen Anbindung von Geräten und Steuerung von Datenflüssen, von zentraler Bedeutung.
Bisherige Lösungen basieren jedoch meist auf proprietären Protokollen und bieten wenig Konfigurations- und Kontrollmöglichkeiten. Basierend auf industriellen Standards, wie z. B. Verwaltungsschalen, wird im Projekt IIP-Ecosphere daher eine offene Code-Basis für die ganzheitliche Umsetzung von Digitalisierungsprojekten in der Produktion entwickelt.

abstract

Cyber-Physical Production Systems (CPPSs) are envisioned as next-generation adaptive production systems combining modern production techniques with the latest information technology. A CPPS creates a complex environment between different domains (mechanical, electrical, software engineering), requiring multidisciplinary solutions to tackle growing complexity issues and reduce (maintenance) effort. Software plays an increasingly important role in assuring an effective and efficient operation of CPPSs. However, software engineering methods applied for CPPSs seem to lag behind modern software engineering methods, where tremendous progress has been made in the last years. We initiated the Software Engineering in Cyber-Physical Production Systems Workshop (SECPPS-WS) to analyze and overcome this gap. After two instances with mostly academic participants, we conducted a full-day workshop with nine industry representatives from eight companies that develop and maintain CPPSs. Each industry representative presented their current work and challenges. We collected these challenges and condensed a categorized list of challenges backed by industry statements and literature. This paper presents the resulting list and pointers to (partial) solutions to offer guidance for academia and identify promising research opportunities in this area.

abstract

Intelligent manufacturing is one goal of smart industry/ Industry 4.0 that could be achieved through Artificial Intelligence (AI). Flexibly combining AI methods and platform capabilities, such as dynamic offloading of code close to production machines, security or interoperability mechanisms are major demands in this context. However, recent Industry 4.0 software platforms fall short in various of these demands, in particular in upcoming ecosystem scenarios, e.g., when data or services shall be shared across platforms or companies without vendor lock-ins. The aim of the funded Intelligent Industrial Production (IIP) IIP-Ecosphere project is to research concepts and solutions for ‘easy-to-use’ AI in Industry 4.0 and to demonstrate the results in a prototypical software platform. Core questions are which demands shall drive the development of such a platform and how a feasible set of requirements can be determined that balances scientific and industrial interests. In this paper, we discuss our approach on eliciting requirements in this context for two interlinked requirements perspectives, a usage and a functional view. In summary, we collected 67 usage view activities / scenarios and 141 top-level requirements with 179 detailing sub-requirements. About 35% of the requirements have so far been realized in a prototype and some of the identified concepts are currently being taken up by a standardization initiative for edge devices in Industry 4.0.

abstract

Industry 4.0/IIoT setups are often distributed and consist of hundreds of sensors, devices or machines.
Nowadays, powerful edge devices enable the execution of software services like Artificial Intelligence
close to production machines to reduce latency. Although several supporting Industry 4.0 platforms do
exist, industrial stakeholders aim for more open, interoperable and vendor-neutral solutions.
In this paper, we focus on the monitoring of runtime properties in Industry 4.0 for services and (edge)
devices. We propose a realization based on existing components like Micrometer, MQTT and upcoming
standards such as the Asset Administration Shell. We discuss patterns for their integration, the impact
of the patterns on performance in terms of an experiment as well as experiences that we made so far.

abstract

In recent years, artificial intelligence (AI) became a key enabling technology for many domains. To
achieve best performance, modern AI methods have high resource demands, e.g., GPU servers for the
training of neural networks. With the advent of further processor technologies, such as tensor processors
or re-wirable processors, AI methods may be executed in shorter time while even saving energy. For
many application domains such as autonomous driving or unmanned aerial vehicles, real-time constraints
mandate low end-to-end latencies in AI processing.
In this paper, we present a combined micro- and macro-benchmarking approach to analyze the
performance as well as the power demands of modern processor architectures using convolutional neural
networks as workload. We discuss tradeoffs among the different processor types and indicate issues and
challenges that arise when performing such benchmarks on heterogeneous hardware resources.
We show that FPGAs allow for an increase of 7x up to 45x in performance over high-end GPUs while
using only 10% of the power. In the consumer space, novel architectures such as the Apple M1 are able
to offer 3-5x better performance at 10-20% the power draw of current x86 CPU or GPU hardware.

abstract

This is a summary of an article published in the Information and Software Technology Journal in 2019 (see Bibliography) describing a domain model we developed to structure and systematize the field of software monitoring as well as a reference architecture to support developing software monitoring approaches.

abstract

This summary refers to the paper Enactment of adaptation in data stream processing with latency implications – A systematic literature review. This paper is a journal paper published in Information and Software Technology (IST) in July 2019. Runtime adaptation in stream processing plays a significant role in supporting the optimization of data processing tasks. In recent years, runtime adaptation, particularly its enactment, has received significant interest in scientific literature. However, so far no categorization of the enactment approaches for runtime adaptation in stream processing has been established. This paper presents a systematic literature review (SLR), where we identify and characterize different approaches towards the enactment of runtime adaptation in stream processing with a main focus on latency as quality dimension. We discovered 75 relevant papers out of 244 papers from the search. We identified 17 different enactment categories and developed a taxonomy to characterize all possible enactment approaches. We extracted the realization techniques of each identified enactment approach and classified them into categories. Furthermore, we identified 9 categories of processing problems, 6 adaptation goals, 9 evaluation metrics and 12 evaluation parameters from the identified enactment approaches. The research interest on enactment approaches has significantly increased in recent years. The most commonly applied enactment approaches are parameter adaptation to tune parameters or settings of the processing, load balancing used to re-distribute workloads, and processing scaling to dynamically scale up and down the processing.

abstract

This tutorial introduces the EASy-Producer product line environment. EASy-Producer is an open-source toolset for engineering product lines, variability-rich software ecosystems, and dynamic software product lines. In particular, it features a variability modeling and a variability implementation DSL. It has been applied in several industrial case studies and research projects showing its practical applicability both from a stability and a capability point of view. While the tool-set also includes an interactive approach to product line definition and configuration through DSLs, the focus of this tutorial will be on the DSL-based techniques. We cover both the modeling of software product lines using the Integrated Variability Modeling Language (IVML) and its underlying conceptual approach, which differs from traditional feature modeling, but we will also provide an overview of the approach to variability instantiation with EASy-Producer (using the Variability Instantiation Language (VIL)).

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 introduce its (textual) variability modeling capabilities realized by the Integrated Variability Modeling Language (IVML) and its model-based development and implementation capabilities, which are realized by the Variability Instantiation Language (VIL) and the Variability Template Language (VTL).

abstract

During the three decades since the invention of the first variability modeling approach [27], there have been multiple attempts to introduce advanced variability modeling capabilities. More recently, there has been increased attention on textual variability modeling languages. In this paper,we summarize the main capabilities of state of the art textual variability modeling languages, based on [23], including some updates regarding more recent work.We also provide a short discussion of some additional concerns that are relevant when designing (textual) variability modeling languages. From this perspective, the paper also summarizes relevant contributions the authors made to the field in earlier research.

abstract

Compute platforms for modern automotive systemstend to combine embedded properties, increasingly complex architectures and even virtualization. However, analyzing the performance of such systems, e.g., to identify performance bottlenecks, is not trivial. In this paper, we report our experience in analyzing the performance of a camera-vision application on a virtualized vehicle-compute platform. We discuss issues that we faced during the analysis, impacts of the virtualization on the performance as well as causes.

abstract

[Context] Complex and heterogeneous software systems need to be monitored as their full behavior often only emerges at runtime, e.g., when interacting with other systems or the environment. Software monitoring approaches observe and check properties or quality attributes of software systems during operation. Such approaches have been developed in diverse communities for various kinds of systems and purposes. For instance, requirements monitoring aims to check at runtime whether a software system adheres to its requirements, while resource or performance monitoring collects information about the consumption of computing resources by the monitored system. Many venues publish research on software monitoring, often using diverse terminology, and focusing on different monitoring aspects and phases. The lack of a comprehensive overview of existing research often leads to re-inventing the wheel. [Objective] We provide a domain model to structure and systematize the field of software monitoring, starting with requirements and resource monitoring. [Method] We developed an initial domain model based on (i) our extensive experiences with requirements and resource monitoring, (ii) earlier efforts to develop a comparison framework for monitoring approaches, and (iii) an earlier systematic literature review on requirements monitoring frameworks. We then systematically analyzed 47 existing requirements and resource monitoring approaches to iteratively refine the domain model and to develop a reference architecture for software monitoring approaches. [Results] Our domain model covers the key elements of monitoring approaches and allows analyzing their commonalities and differences. Together with the reference architecture, our domain model supports the development of integrated monitoring solutions. We provide details on 47 approaches we analyzed with the model to assess its coverage. We also evaluate the reference architecture by instantiating it for five different monitoring solutions. [Conclusions] We conclude that requirements and resource monitoring have more commonalities than differences, which is promising for the future integration of existing monitoring solutions.

abstract

[Context] Stream processing is a popular paradigm to continuously process huge amounts of data. Runtime adaptation plays a significant role in supporting the optimization of data processing tasks. In recent years runtime adaptation has received significant interest in scientific literature. However, so far no categorization of the enactment approaches for runtime adaptation in stream processing has been established. [Objective] This paper identifies and characterizes different approaches towards the enactment of runtime adaptation in stream processing with a main focus on latency as quality dimension. [Method] We performed a systematic literature review (SLR) targeting five main research questions. An automated search, resulting in 244 papers, was conducted. 75 papers published between 2006 and 2018 were finally included. From the selected papers, we extracted data like processing problems, adaptation goals, enactment approaches of adaptation, enactment techniques, evaluation metrics as well as evaluation parameters used to trigger the enactment of adaptation in their evaluation. [Results] We identified 17 different enactment approaches and categorized them into a taxonomy. For each, we extracted the underlying technique used to implement this enactment approach. Further, we identified 9 categories of processing problems, 6 adaptation goals, 9 evaluation metrics and 12 evaluation parameters according to the extracted data properties. [Conclusion] We observed that the research interest on enactment approaches to the adaptation of stream processing has significantly increased in recent years. The most commonly applied enactment approaches are parameter adaptation to tune parameters or settings of the processing, load balancing used to re-distribute workloads, and processing scaling to dynamically scale up and down the processing. In addition to latency, most adaptations also address resource fluctuation / bottleneck problems. For presenting a dynamic environment to evaluate enactment approaches, researchers often change input rates or processing workloads.

abstract

Monitoring complex distributed and heterogeneous systems such as cyber-physical or internet-of-things systems is challenging. Different kinds of information must be aggregated in a flexible manner to provide an overview on the actual state of the system. Recently, even heterogeneous Big Data systems have been proposed, which integrate classical server machines and hardware co-processors, such as Graphical Processing Units. In this paper, we present a system-level monitoring approach for a heterogeneous Big Data streaming system. We discuss the requirements stemming from a recent research project, a solution architecture and discuss experiences and promising results from preliminary experiments with the realization.

abstract

In recent years, the development of systems for processing and analyzing large amounts of data (so-called Big Data) has become an important sub-discipline of software engineering. However, to date there exits no comprehensive summary of the specific idiosyncrasies and challenges that the development of Big Data systems imposes on software engineers. With this paper, we aim to provide a first step towards filling this gap based on our collective experience from industry and academic projects as well as from consulting and initial literature reviews. The main contribution of our work is a concise summary of 26 challenges in engineering Big Data systems, collected and consolidated by means of a systematic identification process. The aim is to make practitioners more
aware of common challenges and to offer researchers a solid baseline for identifying novel software engineering research directions.

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

The development of efficient and robust algorithms for Big Data processing is a demanding task, which has to cope with the characteristics of this type of data (3Vs). Putting such algorithms as processing elements into larger pipelines adds an extra level of complexity, which can be alleviated by relying on a model-based approach including code generation. This allows data analysts to compose such pipelines on a higher level of abstraction, reducing the development effort as well as the risk of errors. In this chapter, we outline a model-based and adaptive approach to the development of data processing pipelines in heterogeneous processing contexts. It relies on a  flexible, tool-supported approach to configuration, which embraces three levels: (a) a heterogeneous processing infrastructure - including reconfigurable hardware, (b) the pipelines as well as (c) the stakeholder applications built upon the pipelines. Furthermore, selected aspects of implementing the approach, which is validated in the context of the financial domain, are presented.

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

In the last decade, the Unified Modeling Language (UML) has become a de-facto standard as modeling language in software engineering. However, due to the complexity of the UML specification it is rather difficult for an individual tool to provide a faithful implementation of the entire breath of modelling elements defined by UML. Thus, tools differ significantly due to their individual support of the UML.

The decision for a software development organization regarding a specific modeling tool is important, in an extreme case for an entire company. Usually, such a decision leads to different kinds of costs such as training of the employees. Licensing costs are often only a small portion of the actual costs for such a tool. Thus, the decision for a modelling tool shall be done carefully. This study is probably the most comprehensive comparison of UML tools at the moment and, therefore, provides adequate support in making rational decisions on modeling tools.

The focus of this study is on the realization of modeling capabilities by individual tools, i.e. whether and how modeling elements of the UML have been implemented. As a basis for a detailed analysis of the modelling capabilities, we decomposed the UML specification into 476 features and inspected the tools for their individual support of these features. A detailed summary per tool links the identified capabilities to the requirements for individual diagram types as stated in the UML specification. This enables the reader to quickly check the appropriateness of a certain tool for a given application context. As a part of our analysis, we characterize each individual tool in terms of its UML compliance according to the classification schema of the 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
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.