In recent years, architecture decision records (ADRs) have emerged as a lightweight way to capture information about software architecture, decisions, context, and consequences. ADRs have a simple structure, which makes them easy to use even for software architects with little experience. A promising research direction is the reuse of the recorded architecture knowledge on a cross-project basis. The rapidly growing number of design decisions in different technology stacks, however, makes manual analysis arduous, which is why AI-based methods are required to facilitate efficient identification of relevant knowledge. In this paper, we investigate the suitability of knowledge graphs for analyzing ADRs for providing easy access to domain knowl-edge and enabling the discovery of additional insights. The main challenges are to model the ontology (i.e., the knowledge graph schema) from ADRs and to find a mapping to Wikidata concepts to enrich the knowledge graph with public knowledge. We explain and verify our approach to create a semantic model of existing data sources within a case study, for which we derived over 4,000 pre-filtered open-source ADRs from GitHub, and present initial analysis results. We believe that this approach could impact software engineering practice by assisting software architects in the deeper analysis of current ADR practices and the creation of new ADRs by proposing best practices in specific domains.

Security is an important quality attribute of today’s systems and services. Much security knowledge is encoded in technical security standards that define requirements on how to develop secure systems. Applying this knowledge is challenging and strives for the development of intelligent applications supporting developers and security experts in their work. We report on the development of an ontology as the structural basis for a knowledge graph that enables reasoning and AI-based methods. For the development of the ontology, we systematically analyzed technical standards in the field of industrial automation and control systems and industrial internet of things to identify the elements and concepts required to describe the standards in a machine-processable form. In this paper, we describe the systematic development and the structure of an ontology to represent technical security standards. The ontology is available online to facilitate further discussion. In our ongoing work, we use the ontology to populate a KG, which serves as basis for a domain expert evaluation on how semantically encoded security standards can support system developer in practice.

Low-Code (Software) Development (LCD or LCSD) promises to reduce time-to-market, lower development costs, and make software development accessible to domain experts without software development training. By raising the level of abstraction beyond code through visual programming and model-driven development, a Low-Code Development Platform (LCDP) provides the tools to create software using the low-code approach. LCDPs typically support specific application types and domains such as web applications, mobile applications, data analytics platforms and dashboards. While some LCDPs exist for control systems in the manufacturing industry, this domain is not yet fully supported. In this paper, we present a multiple-case study based on five interviews to explore the role LCDPs can play in industrial automation. In particular, we investigate which use cases are considered relevant for LCDPs and what the actual requirements for such platforms are from an industrial perspective. Our results show that many different manufacturing use cases could be implemented by or already benefit from LCDPs. However, successful future LCDPs must meet certain industry-specific requirements.

Microservices are widely used by large internet companies as they support scalable systems with high resilience and fault-tolerance, flexible and agile development, and continuous delivery enabling fast time to market. Hence, there is an increasing interest in adopting microservices in the field of industrial automation. This raises the question, if and to what degree this architectural style can also be applied for the development of industrial control systems (ICS). In this paper, we have systematically analyzed the applicability of microservices for ICS development. Together with domain experts from industry, we have developed a migration path from a monolithic ICS towards cloud-ready systems based on microservices. By studying the central principles for microservice development and operation, we found that microservices can be applied in the context of ICS and the use of microservices leads to increased flexibility with regard to frequent software releases and the development of new deployment variants. However, communication between real-time services is still an open research challenge that poses a potential technical risk in the migration towards adopting full microservice-based system architectures.

Architecture conformance checking is an important means for quality control to assess that the system implementation adheres to its defined software architecture. Ideally, this process is automated to support continuous quality control. Many different approaches exist for automated conformance checking. However, these approaches are often limited in terms of supported concepts for describing and analyzing software architectures. We have developed an ontology-based approach that seeks to overcome the limited expressiveness of existing approaches. As a frontend of the formalism, we provide a Controlled Natural Language. In this paper, we present an industrial validation of the approach. For this, we collected architectural rules from three industrial projects. In total, we discovered 56 architectural rules in the projects. We successfully formalized 80% of those architectural rules. Additionally, we discussed the formalization with the corresponding software architect of each project. We found that the original intention of each architectural rule is properly reflected in the formalization. The results of the study show that projects could greatly benefit from applying an ontology-based approach, since it helps to precisely define and preserve concepts throughout the development process.

Technical software documentation is an essential source of knowledge supporting many different software development activities and stakeholders. In this paper we report on use cases, existing documentation practices, and open challenges for technical software documentation in a company from the manufacturing domain. Further, we present an approach for automatically providing technical software documentation as a service. The approach has been validated in an industrial setting, i.e., we report on our experiences and lessons learned. Validation shows that while up-to-date and dynamically explorable documentation could be provided, the proposed solution failed in sufficiently supporting different stakeholders and their concerns i.e., it failed in providing sustainable documentation and knowledge preservation over time.

Manufacturing execution systems (MES) are key elements of industrial automation systems. MES can be deployed at different levels of scale from a single site or plant to a company with globally distributed production sites all over the world. Establishing or extending an MES is a complex process, which requires taking the already existing software and system architecture into account in addition to the desired MES features. We developed an approach and an associated tool to support the process of creating offers for customer-specific MES solutions based on a vendor-specific automation platform. We define architecture variants for selecting a specific MES feature set and for supporting different MES expansion stages. Additionally, we provide an architecture modeling approach to explore the integration with existing software and system infrastructures. The approach has been applied at the STIWA Group, a vendor of MES for industrial production lines.

High resource demand for system testing is a major obstacle for continuous delivery. This resource demand can be reduced by prioritizing test cases, e.g., by focusing on tests that cover a lot of functionality. For large-scale systems, like an enterprise SOA, defining such test cases can be difficult for the tester because of the lack of relevant knowledge about the system. We propose an approach for test case prioritization and selection that is based on architectural viewpoint that provides software testers with the required architectural information. We outline how architectural information is used for defining and selecting prioritized test cases. The approach has been developed in close cooperation with the provider of an enterprise SOA in the banking domain in Austria following an action research approach. In addition, the approach has been validated in an industrial case study. Validation showed that there is no further need for manual architectural analysis to be able to prioritize and select test cases. We also show the limitations of our approach as it is based on static code analysis.

Company-wide reference architectures are an important means for standardization and reuse. Standardization is enforced through reference architecture conformance checking. Manual conformance checking is too time- and resource-intensive to be performed continuously for the various systems that are part of a SOA. We present an approach for automatic reference architecture conformance checking of SOA-based software systems. Reference architectures are defined based on rules consisting of roles and of constraints on roles and role relationships. By mapping the roles to the elements of a software architecture representation, reference architecture specifications are reusable for different software systems. Through automating the whole checking process, including architecture extraction, role mapping, and rule evaluation, the approach can be applied continuously for the different systems that are part of a SOA. The approach has been developed and refined by applying it to a SOA in the banking domain. During its evolution from semi-automatic to a fully automatic approach it has also changed the way of how architecture information is provided as part of the system implementation in this domain.

Traceability requires capturing the relations between software artifacts like requirements, architecture and implementation explicitly. Manual discovery and recovery of tracing information by studying documents, architecture documentation and implementation is time-intensive, costly, and may miss important information not found in the analyzed artifacts. Approaches for explicitly capturing traces exist, but either require manual capturing or lack comprehensive tracing to both architecture and implementation. In this paper we present an approach for (semi)automatically capturing traceability relationships from requirements and design decisions to architecture and implementation. Traces are captured in a non-intrusive way during architecture design and implementation. The captured traces are integrated with a semi-formally defined architecture description model and serve as the basis for different kinds of architecture-related activities.

Software architecture analysis is a central activity in software development. Multiple software architecture analysis techniques exist, which differ in cost and complexity, the addressed stakeholders and the supported kinds of analysis. To support comprehensive software architecture analysis, multiple analysis techniques need to be applied within one project. Currently available techniques are not integrated with each other and require the use of different processes, tools, and of different means for architecture representation. This makes the application of different, though potentially complementing analysis techniques time- and resource-intensive, and thus costly. In this paper we present an approach that combines multiple analysis techniques to support comprehensive, integrated and cost-efficient software architecture analysis. Our approach combines analysis functionality provided by software architecture management tools, architecture description languages, and scenario-based analysis techniques.

Principles of component-based software construction like decomposition, decoupling, late binding and late composition are mainstream concepts found in many software systems, technologies and domains. The definition of individual components and component properties is well supported on the level of programming languages. However, tool support for component-based software architectures is insufficient. In particular, component-level abstractions are not integrated well enough with lower-level architectural elements, architectural views are not editable or missing, and validation of component-based system configurations is not provided. In addition, existing approaches only support a specific component technology and lack support for heterogeneous systems. We present a toolkit supporting the design, analysis and implementation of component-based software systems independent of concrete component models and technologies. The foundation of the toolkit is an architecture description metamodel that unifies concepts of existing component models and that scales from component-based applications to distributed service-oriented architectures. In this paper we focus on the concepts provided for modeling and visualizing different structural relationship of component-based system architectures.

Many software projects suffer from problems related to non-existent, incomplete, inaccurate, or invalid architecture descriptions. The hypothesis underlying our approach is that architecture related activities, notations, and artifacts are not integrated well enough with the development process,with the development tools and, in particular, with the implementation of a software system. We present an approach in which we emphasize the architectural description of a system as a central element during the whole software development process. The main idea is to incorporate a formalized architecture description model into a software system which is always kept up-to-date during software development. A toolkit, which is based on the model, is used for continuously defining, validating, visualizing and evolving the architecture during development.