Search

Industry 4.0 enacts ad-hoc cooperation between machines, humans, and organizations in supply and production chains. The cooperation goes beyond rigid hierarchical process structures and increases the levels of efficiency, customization, and individualisation of end-products. Efficient processing and cooperation requires exploiting various sensor and process data and sharing them across various entities including computer systems, machines, mobile devices, humans, and organisations. Access control is a common security mechanism to control data sharing between involved parties. However, access control to virtual resources is not sufficient in presence of Industry 4.0 because physical access has a considerable effect on the protection of information and systems. In addition, access control mechanisms have to become capable of handling dynamically changing situations arising from ad-hoc horizontal cooperation or changes in the environment of Industry 4.0 systems. Established access control mechanisms do not consider dynamic changes and the combination with physical access control yet. Approaches trying to address these shortcomings exist but often do not consider how to get information such as the sensitivity of exchanged information. This chapter proposes a novel approach to control physical and virtual access tied to the dynamics of custom product engineering, hence, establishing confidentiality in ad-hoc horizontal processes. The approach combines static design-time analyses to discover data properties with a dynamic runtime access control approach that evaluates policies protecting virtual and physical assets. The runtime part uses data properties derived from the static design-time analysis, as well as the environment or system status to decide about access.

With the increase of connected systems and the ongoing digitalization of various aspects of our life, the security demands for software increase. Software architects should design a secure and resistant system. One solution can be the identification of attack paths or the usage of an access control policy analysis. However, due to the system complexity identifying an attack path or analyzing access control policies is hard. Current attack path calculation approaches, often only focus on the network topology and do not consider the more fine-grained information a software architecture can provide, such as the components or deployment. In addition, the impact of access control policies for a given scenario is unclear. We developed an open-source attack propagation tool, which can calculate an attack graph based on the software architecture. This tool could help software architects to identify potential critical attack paths. Additionally, we extended the used access control metamodel to support a scenario-based access control analysis.

Context: Software architecture (SA) as research area experienced an increase in empirical research, as identified by Galster and Weyns in 2016 [1]. Empirical research builds a sound foundation for the validity and comparability of the research. A current overview on the evaluation and replicability of SA research objects could help to discuss our empirical standards as a community. However, no such current overview exists. Objective: We aim at assessing the current state of practice of evaluating SA research objects and replication artifact provision in full technical conference papers from 2017 to 2021. Method: We first create a categorization of papers regarding their evaluation and provision of replication artifacts. In a systematic literature review (SLR) with 153 papers we then investigate how SA research objects are evaluated and how artifacts are made available. Results: We found that technical experiments (28%) and case studies (29%) are the most frequently used evaluation methods over all research objects. Functional suitability (46% of evaluated properties) and performance (29%) are the most evaluated properties. 17 papers (11%) provide replication packages and 97 papers (63%) explicitly state threats to validity. 17% of papers reference guidelines for evaluations and 14% of papers reference guidelines for threats to validity. Conclusions: Our results indicate that the generalizability and repeatability of evaluations could be improved to enhance the maturity of the field; although, there are valid reasons for contributions to not publish their data. We derive from our findings a set of four proposals for improving the state of practice in evaluating software architecture research objects. Researchers can use our results to find recommendations on relevant properties to evaluate and evaluation methods to use and to identify reusable evaluation artifacts to compare their novel ideas with other research. Reviewers can use our results to compare the evaluation and replicability of submissions with the state of the practice.

In this technical report, we present the supplementary information for the evaluation of the Layered Reference Architecture for Model-based Quality Analysis. In chapter 2, we present the case studies, rst in their monolithic and then in their modular form. We present installation instructions for the tools required to reproduce the evaluation results in chapter 3. In chapter 4, we provide detailed information about the evolution scenarios. The tooling and the results of the scenarios can be found online [7].

In this report, we present an approach for the quantification of correctness of service-oriented software systems by combining the modeling tool Palladio and the deductive verification approach KeY. Our approach uses Palladio for modeling the service-oriented architecture, the usage scenarios of the system (called services) in particular, and the distribution of values for the parameters provided by the users. The correctness of a service is modeled as a Boolean condition. We use Palladio to compute the probability of a service being called with critical parameters, i.e., in a way that its correctness condition is violated. The critical parameters are computed by KeY, a deductive verification tool for Java. The approach is not limited to KeY: Other techniques, such as bug finding (testing, bounded model checking) can be used, as well as other verification tools. We present two scenarios, which we use as examples to evaluate the feasibility of the approach. Finally, we close with remarks on the extension to security properties. Furthermore, we discuss a possible approach to guide developers to locations of the code that should be verified or secured.

Cham, Switzerland : Springer V, 140 Seiten : Illustrationen (2020). doi:10.1007/978-3-030-58617-1, Published by Springer, Cham, Switzerland

Die Definition und Umsetzung von Sicherheitsanforderungen ist für alle Arten von Anwendungen essentiell, jedoch in komplexen Softwaresystemen nicht trivial. Verletzungen müssen so früh wie möglich erkannt werden, um sie kosteneffizient beheben zu können. In frühen Entwicklungsstadien können Entwurfszeitanalysen genutzt werden. Datenflussorientierte Analysen erlauben hier das Formulieren von Analysezielen in der Anforderungsterminologie, sind jedoch nicht gut in bestehende architekturelle Beschreibungssprachen (ADLs) integriert. In unserem Ansatz haben wir daher Datenflussmodellierung in die ADL Palladio integriert, um Analysen bzgl. der Einhaltung von Vertraulichkeitsanforderungen durchführen zu können. Eine Evaluierung mittels zweier Fallstudien zeigte, dass eine gute Präzision mittels der Analyse erreicht werden kann

The increasing complexity of software and cyberphysical systems is handled by dividing the description of the system under construction into different models or views, each with an appropriate abstraction for the needs of specific roles. Since all such models describe the same system, they usually share an overlap of information, which can lead to inconsistencies if overlapping information is not modified uniformly in all models. A well-researched approach to make these overlaps explicit and resolve inconsistencies are incremental, bidirectional model transformations. They specify the constraints between two metamodels and the restoration of consistency between their instances. Relating more than two metamodels can be achieved by combining bidirectional transformations to a network. However, such a network may contain cycles of transformations, whose consistency constraints can be contradictory if they are not aligned with each other and thus cannot be fulfilled at the same time. Such transformations are considered incompatible. In this article, we provide a formal definition of consistency and compatibility of transformations and propose an inductive approach to prove compatibility of a given network of transformations. We prove correctness of the approach based on these formal definitions. Furthermore, we present an operationalization of the approach at the example of QVT-R. It detects contradictions between relations by transforming them into first-order logic formulae and evaluating them with an SMT solver. The approach operates conservatively, i.e., it is not able to prove compatibility in all cases, but it identifies transformations as compatible only if they actually are. We applied the approach to different evaluation networks and found that it operates conservatively and is able to properly prove compatibility in 80% of the cases, indicating its practical applicability. Its limitations especially arise from restricted capabilities of the used SMT solver, but not from conceptual shortcomings. Our approach enables multiple domain experts to define transformations independently and to check their compatibility when combining them to a network, relieving them from the necessity to align the transformations with each other a priori and to ensure compatibility manually

Digitization not only affects society, it also requires a redefinition of the location of computer science and computer scientists, as the science journalist Yogeshwar suggests. Since all official aspects of digitalization are based on software, this article is intended to attempt to redefine the role of software engineering and its research. Software-based products, systems or services are influencing all areas of life and are a critical component and central innovation driver of digitization in all areas of life. Scientifically, there are new opportunities and challenges for software engineering as a driving discipline in the development of any technical innovation. However, the chances must not be sacrificed to the competition for bibliometric numbers as an end in themselves., Comment: in German

Software ist ein wesentlicher Bestandteil unseres täglichen Lebens. Mobilität, Energie, Wirtschaft, Produktion und Infrastruktur hängen stark von Software ab, die allerdings nicht immer von hoher Qualität ist. Kritische Probleme, wie Effizienzeinbrüche oder hohe Wartungsaufwände, können durch schlechte Softwarequalität verursacht werden. Beispiele sind vielfältig in der Presse zu finden. Qualitätseigenschaften hängen stark von Entwurfsentscheidungen bzgl. der Architektur eines Systems ab. Um eine hohe Qualität bei der Systemevolution zu gewährleisten, sind Forschung und Praxis an Ansätzen interessiert, mit denen verschiedene Entwurfsalternativen modelliert und analysiert werden können. Dieser Beitrag zeigt Herausforderungen bei der architektur-basierten Evolution von software-intensiven Systemen auf. Es werden Modellierungs- und Analysetechniken vorgestellt, die zur Untersuchung verschiedener Qualitätseigenschaften auf Architekturebene geeignet sind. Darüber hinaus werden Modularisierungskonzepte für Sprachen (definiert durch Metamodelle) und Analysetechniken vorgestellt. Diese führen zur ersten Referenzarchitektur für Metamodelle zur Qualitätsmodellierung und -analyse.

Model-driven technologies are widely used in the development of systems in the automotive domain. Although modelling tools and code generation increase the development speed and the quality of the developed system in general, the availability of several modelling languages for different stages of the development process also introduces additional problems: Developers use several models to describe the same system on different levels of abstraction, which serve as documentation, basis for code generation, but also for model-based analyses of system properties such as security, performance, or reliability. If models are modified independently, inconsistencies can arise, which lead to incorrect results of these analyses, complicate the implementation of new features, and create errors at later stages in development that are costly to fix. In this paper, we apply the model-based Vitruvius approach, which preserves consistency in heterogeneous modelling environments, to a scenario of automotive systems development. The scenario includes the modelling standards SysML, AMALTHEA and ASCET. We show, at the example of an onboard controlling unit, how the Vitruvius approach can be used to increase consistency in automotive system development and reduce the accidental complexity that arises for developers who have to work with heterogeneous modelling languages.

In modern vehicles, embedded software is mainly the driving force for the realisation of new functionality. Spread on more than hundred electronic control units, software parts work together in a network to fulfil certain tasks of safety, comfort, energy management and of course vehicle dynamics. Currently, this software is flashed at the end of the assembly line. In regular terms (normally six months), a software baseline of all the electronic control units is released. As a consequence, a distinct variety of releases is deployed on vehicles on the road for each vehicle type. Combined with the alternatives of engines, chassis and customer wishes, the variants of vehicles rise to a number beyond millions. Opening now the chance for over the air updates demands for restrictive and rigorous consistency checks before any update is spread among all the vehicles of one brand or type in the field. In an empirical study based on a survey, we collected and interpreted the answers of participants from different automotive institutions concerning the current state of practice and the faced challenges during release development and management. The outcome of the survey revealed that field updates are getting more and more important due to the rising software part inside vehicles and that over the air communication is an efficient way to realise them in the future. The shortening release and update cycles together with increasing number of variants and the multidisciplinarity in the automotive field were identified as the main challenges in the current development of automotive engineering.

Modern software engineering paradigms, such as model-driven development, multi-view modelling, or role-based software development, use different types and combinations of abstraction techniques to decompose systems into human-tractable pieces. This leads to an increasing number of models and views that have to be considered, which presents fundamental challenges for engineers of complex softwareintensive systems. Software developers need technologies for operationally managing views of systems in a consistent way, and software architects require concepts that indicate in which way views and models should be developed, evolved, and navigated as projects evolve. The goal of this workshop is to distil a common understanding of existing approaches and current research directions in treating heterogeneous models of software and systems.

Symbolic execution has been applied, among others, to check programs against contract specifications or to generate path-based test suites. We propose to adapt symbolic execution to perform a probabilistic reasoning about possible executions of a program. We present a compositional and incremental approach to approximate the probability of a program path.

This paper discusses technical aspects of how business workflow management systems can be improved in order to apply them in the field of scientific workflows and reap all their benefits. We give recommendations how to address the discovered gaps in support for scientific applications. The approach we follow addresses the requirements of scientists and scientific applications, which we also identify in this work.

Between 20.10.09 and 23.10.09, the Dagstuhl Seminar 09432, Quantitative Software Design, was held at the International Conference and Research Center (IBFI), Schloss Dagstuhl. Quantitative software design is a field of research that is not yet firmly established. A number of challenging open research issues are only recently being addressed by the academic research community (see below). The topic is also gaining increasing emphasis in industrial research, as any progress towards a more systematic and goal-driven software design promises the reduction of costs and risks of software projects, by avoiding current trial-and-error approaches to design. The whole field is therefore of high industrial relevance, though it is far from providing ready-to-use solutions. The seminar was structured around ten discussion groups that considered the question of how quantitative software engineering is, could and should be done. A number of interesting insights were gained, particularly due to the interdisciplinary nature of the seminar group and the mix of industrialists and academics. This collection summarizes these group discussions.

Das Projekt MINT (Modellgetriebene Integration von Informationssystemen) beschäftigt sich mit der Entwicklung von Methoden zur Umsetzung modellgetriebener Ansätze, wie z. B. der Model Driven Architecture (MDA) der Object Management Group (OMG), im Bereich der Integration von betrieblichen Informationssystemen. Dabei werden sowohl die Integration von Legacy Systemen in moderne Umgebungen als auch die Integration von Individualsoftware in einen Standardsoftware-Kontext berücksichtigt.

Justifying reliance in computer systems is based on some form of evidence about such systems. This in turn implies the existence of scientific techniques to derive such evidence from given systems or predict such evidence of systems. In a general sense, these techniques imply a form of measurement. The workshop Dependability Metrics'', which was held on November 10, 2008, at the University of Mannheim, dealt with all aspects of measuring dependability.

Das Projekt MINT (Modellgetriebene Integration von Informationssystemen) beschäftigt sich mit der Entwicklung von Methoden zur Umsetzung modellgetriebener Ansätze, wie z. B. der Model Driven Architecture (MDA) der Object Management Group (OMG), im Bereich der Integration von betrieblichen Informationssystemen. Dabei werden sowohl die Integration von Legacy Systemen in moderne Umgebungen als auch die Integration von Individualsoftware in einen Standardsoftware-Kontext berücksichtigt.

In der Welt der komponentenbasierten Software-Entwicklung werden Komponentenmodelle unter Anderem dazu eingesetzt, Software-Systeme mit vorhersagbaren Eigenschaften zu erstellen. Die Bandbreite reicht von Forschungs- bis zu Industrie-Modellen. In Abhängigkeit von den Zielen der Modelle werden unterschiedliche Aspekte von Software in ein Komponentenmodell abgebildet. In diesem technischen Bericht wird ein Überblick über die heute verfügbaren Software-Komponentenmodelle vermittelt.

Die Entwicklung von Software mit Hilfe von Eclipse gehört heute zu den Standard-Aufgaben eines Software-Entwicklers. Die Artikel in diesem technischen Bericht beschäftigen sich mit den umfangreichen Möglichkeiten des Eclipse-Frameworks, die nicht zuletzt auf Grund zahlreicher Erweiterungsmöglichkeiten mittels Plugins möglich sind. Dieser technische Bericht entstand aus einem Proseminar im Wintersemester 2006/2007.

odellgetriebene Software-Entwicklung ist in den letzten Jahren insbesondere unter Schlagworten wie MDA oder MDD zu einem Thema von allgemeinem Interesse für die Software-Branche geworden. Dabei ist ein Trend weg von der codezentrierten Software-Entwicklung hin zum (Architektur-) Modell im Mittelpunkt der Software-Entwicklung festzustellen. Modellgetriebene Software-Entwicklung verspricht eine stetige und automatisierte Synchronisation von Software-Modellen verschiedenster Ebenen. Dies verspricht eine Verkürzung von Entwicklungszyklen und mehr Produktivität. Primär wird nicht mehr reiner Quellcode entwickelt, sondern Modelle und Transformationen übernehmen als eine höhere Abstraktionsebene die Rolle der Entwicklungssprache für Software-Entwickler. Software-Architekturen lassen sich durch Modell beschreiben. Sie sind weder auf eine Beschreibungssprache noch auf eine bestimmte Domänen beschränkt. Im Zuge der Bemühungen modellgetriebener Entwicklung lassen sich hier Entwicklungen hin zu standardisierten Beschreibungssprachen wie UML aber auch die Einführung von domänen-spezifischen Sprachen (DSL) erkennen. Auf diese formalisierten Modelle lassen sich schließlich Transformationen anwenden. Diese können entweder zu einem weiteren Modell ("Model-to-Model") oder einer textuellen Repräsentation ("Model-to-Text") erfolgen. Transformationen kapseln dabei wiederholt anwendbares Entwurfs-Wissen ("Muster") in parametrisierten Schablonen. Für die Definition der Transformationen können Sprachen wie beispielsweise QVT verwendet werden. Mit AndoMDA und openArchitectureWare existieren Werkzeuge, welche die Entwickler bei der Ausführung von Transformationen unterstützen.

From 12.12.04 to 17.12.04, the Dagstuhl Seminar 04511 ``Architecting Systems with Trustworthy Components'' was held in the International Conference and Research Center (IBFI), Schloss Dagstuhl. During the seminar, several participants presented their current research, and ongoing work and open problems were discussed. Abstracts of the presentations given during the seminar as well as abstracts of seminar results and ideas are put together in this paper. The first section describes the seminar topics and goals in general. Links to extended abstracts or full papers are provided, if available.

WCOP 2006 is the eleventh event in a series of highly successful workshops, which took place in conjunction with every ECOOP since 1996. Component oriented programming (COP) has been described as the natural extension of object-oriented programming to the realm of independently extensible systems. Several important approaches have emerged over the recent years, including component technology standards, such as CORBA/CCM, COM/COM+, J2EE/EJB, and .NET, but also the increasing appreciation of software architecture for component-based systems, and the consequent effects on organizational processes and structures as well as the software development business as a whole. COP aims at producing software components for a component market and for late composition. Composers are third parties, possibly the end users, who are not able or willing to change components. This requires standards to allow independently created components to interoperate, and specifications that put the composer into the position to decide what can be composed under which conditions. On these grounds, WCOP'96 led to the following definition: "A component is a unit of composition with contractually specified interfaces and explicit context dependencies only. Components can be deployed independently and are subject to composition by third parties." After WCOP'96 focused on the fundamental terminology of COP, the subsequent workshops expanded into the many related facets of component software. WCOP 2006 emphasizes reasons for using components beyond reuse. While considering software components as a technical means to increase software reuse, other reasons for investing into component technology tend to be overseen. For example, components play an important role in frameworks and product-lines to enable configurability (even if no component is reused). Another role of components beyond reuse is to increase the predictability of the properties of a system. The use of components as contractually specified building blocks restricts the degrees of freedom during software development compared to classic line-by-line programming. This restriction is beneficial for the predictability of system properties. For an engineering approach to software design, it is important to understand the implications of design decisions on a system's properties. Therefore, approaches to evaluate and predict properties of systems by analyzing its components and its architecture are of high interest. To strengthen the relation between architectural descriptions of systems and components, a comprehensible mapping to component-oriented middleware platforms is important. Model-driven development with its use of generators can provide a suitable link between architectural views and technical component execution platforms. WCOP 2006 accepted 13 papers, which are organised according to the program below. The organisers are looking forward to an inspiring and thought provoking workshop. The organisers thank Jens Happe and Michael Kuperberg for preparing the proceedings volume.

This report deals with the specification of software component protocols (i.e., the set of service call sequences). The contribution of this report is twofold: (a) We discuss specific requirements of real-world protocols, especially in the presence of components wich make use of limited resources. (b) We define counter-constrained finite state machines (CC-FSMs), a novel extension of finite state machines, specifically created to model protocols having dependencies between services due to their access to shared resources. We provide a theoretical framework for reasoning and analysing CC-FSMs. Opposed to finite state machines and other approaches, CC-FSMs combine two valuable properties: (a) CC-FSMs are powerful enough to model realistic component protocols with resource allocation, usage, and de-allocation dependencies between methods (as occurring in common abstract datatypes such as stacks or queues) and (b) CC-FSMs have a decidabile equivalence- and inclusion problem as proved in this report by providing algorithms for efficient checking equivalence and inclusion. These algorithms directly lead to efficient checks for component interoperability and substitutability. Keywords: software component protocols, finite state machine extension, decidable inclusion check, interoperability, substitutability.

Architecture description languages (ADLs) are used to specify high-level, compositional views of a software application. ADL research focuses on software composed of prefabricated parts, so-called software components. ADLs usually come equipped with rigorous state-transition style semantics, facilitating verification and analysis of specifications. Consequently, ADLs are well suited to configuring distributed and event-based systems. However, additional expressive power is required for the description of enterprise software architectures – in particular, those built upon newer middleware, such as implementations of Java’s EJB specification, or Microsoft’s COM+/.NET. The enterprise requires distributed software solutions that are scalable, business-oriented and mission-critical. We can make progress toward attaining these qualities at various stages of the software development process. In particular, progress at the architectural level can be leveraged through use of an ADL that incorporates trust and dependability analysis. Also, current industry approaches to enterprise development do not address several important architectural design issues. The TrustME ADL is designed to meet these requirements, through combining approaches to software architecture specification with rigorous design-by-contract ideas. In this paper, we focus on several aspects of TrustME that facilitate specification and analysis of middleware-based architectures for trusted enterprise computing systems.