Industrial Automation and Control Systems (IACS) increasingly face security challenges. While refactoring enhances code maintainability, improper restructuring in custom IACS software can introduce new vulnerabilities. Applied without security awareness, refactoring may weaken access controls, aggregate sensitive data, or disrupt validation mechanisms, expanding the attack surface. This work presents a risk-based prioritization methodology for refactoring data clumps, integrating security factors such as Data Sensitivity (DS), Input Validation Inconsistency (IVI), and Access Control Inconsistency (ACI) alongside traditional maintainability metrics in a structured, quantifiable approach to security-aware refactoring. Empirical validation on five open-source projects reveals that security-sensitive functions are 63% more likely to exhibit long parameter names (LN) and high numbers of parameters (NP), highlighting a strong correlation between code complexity and security risk. This study provides actionable insights for identifying high-risk code structures and mitigating vulnerabilities through security-focused refactoring, forming the foundation for risk-informed strategies in large-scale IACS software.

In this paper, a novel chatbot for risk reduction as an aid during machinery design is presented. The general workflow of the chatbot involves the identification of the hazard described by the user using a neural network model followed by an interactive dialog based conversation, in which the risk reduction measures are outlined. A prototype implementation of the chatbot presents the steps to generate and pre-process the training data for Artificial Intelligence (AI) based models. Different neural network models are trained and evaluated for the proposed risk reduction chatbot. A comparative study is presented by employing an in-depth qualitative and quantitative evaluation. The work presented in this paper shows significant promise in ensuring safety awareness, thereby aiding in implementing functional safety in the early stages of machinery design and development.

The use of Artificial Intelligence (AI) in machinery functional safety can enhance efficiency and accuracy by automating tasks previously carried out by humans. This paper presents an experimental evaluation of Neural Network (NN) models for hazard identification in machinery functional safety. The systematic study includes own implementations of NN models using open source building blocks and the use of an open source conversational AI framework with various pipeline configurations. The paper provides a comparative analysis of the qualitative and quantitative parameters for the models and configurations.

Standards such as ISO 13849 and ISO 12100 enable users to model safety related control elements with safety functions, according to a specified architecture and required performance level. In this direction, a novel Artificial Intelligence (AI)-based assistant is introduced in this paper to aid in determining the required performance level parameter by indulging the user in a dialog-based conversation regarding hazard scenarios. This will help inexperienced machinery safety personnel (e.g. mechanical engineer) to get an overview of the safety engineering aspects, before consulting with safety experts for risk assessment.

The (improved) digitalization of economy and administration is a common major endeavor. In general digitalization looks quite simpe: the currently semi-automated business processes are to be formalized and based of these formal business process models highly automated systems are to be developed. One challenge is to formalize the informal knowledge of the stakeholders driving the processes. To optimize and document business processes, it is important that different stakeholders can form a common understanding of them. This understanding is formally expressed in modeling languages like BPMN (Business Process Model and Notation). However, misunderstandings and errors occur time and time again. This paper presents a novel approach, based on a three-dimensional representation of the process, which on the one hand maintains the clarity of the overall process, but also allows an improved representation of details. The stakeholders may play their roles in the processes with avatars, and these roles may be recorded as the base of a formal process model.

Due to the resource-constrained nature of embedded systems, it is crucial to support the estimation of their power consumption as early in the development process as possible. Non-functional requirements based on power consumption directly impact the software design, e.g., watt-hour thresholds and expected lifetimes based on battery capacities. Even if software affects hardware behavior directly, these types of requirements are often overlooked by software developers because they are commonly associated with the hardware layer. Modern trends in software engineering such as Model-Driven Development (MDD) can be used in embedded software development to evaluate power consumption-based requirements in early design phases. However, power consumption aspects are currently not sufficiently considered in MDD approaches. In this paper, we present a model-driven approach using Unified Modeling Language profile extensions to model hardware components and their power characteristics. Software m odels are combined with hardware models to achieve a system-wide estimation, including peripheral devices, and to make the power-related impact in early design stages visible. By deriving energy profiles, we provide software developers with valuable feedback, which may be used to identify energy bugs and evaluate power consumption-related requirements. To demonstrate the potential of our approach, we use a sensor node example to evaluate our concept and to identify its energy bugs.

In this paper we propose an approach for an integrated and iterative performance tuning of an Industrial Internet of Things (IIoT) digital twin. Using the systematic series of steps in the proposed approach, the digital twin- linked to its real-world counterpart, can now be used in different ways to predict, refine, fine tune and optimize the operation of the asset (e.g. Cyber Physical System (CPS) in the IIoT plant) during various stages of its software development life cycle.

With the increasing size and complexity of embedded systems, the impact of software on energy consumption is becoming more important. Previous research focused mainly on energy optimization at the hardware level. However, little research has been carried out regarding energy optimization at the software design level. This paper focuses on the software design level and addresses the gap between software and hardware design for embedded systems. This is achieved by proposing a framework for software design patterns, which takes aspects of power consumption and time behavior of the hardware level into account. We evaluate the expressiveness of the framework by applying it to well-known and novel design patterns. Furthermore, we introduce a dimensionless numerical efficiency factor to make possible energy savings quantifiable.

Process modeling languages help to define and execute processes and workflows. The Business Process Model and Notation (BPMN) 2.0 is used for business processes in commercial areas such as banks, shops, production and supply industry. Due to its flexible notation, BPMN is increasingly being used in non-traditional business process domains like Internet of Things (IoT) and agriculture. However, BPMN does not fit well to scenarios taking place in environments featuring limited, delayed, intermittent or broken connectivity. Communication just exists for BPMN - characteristics of message transfers, their priorities and connectivity parameters are not part of the model. No backup mechanism for communication issues exists, resulting in error-prone and failing processes. This paper introduces resilient BPMN (rBPMN), a valid BPMN extension for process modeling in unreliable communication environments. The meta model addition of opportunistic message flows with Quality of Service (QoS) parameters and connectivity characteristics allows to verify and enhance process robustness at design time. Modeling of explicit or implicit, decision-based alternatives ensures optimal process operation even when connectivity issues occur. In case of no connectivity, locally moved functionality guarantees stable process operation. Evaluation using an agricultural slurry application showed significant robustness enhancements and prevented process failures due to communication issues.

Standards such as IEC 61508 or ISO 26262 provide a general guideline on how to develop embedded systems in a safety-critical context. However, they offer no actual support for the implementation of safety mechanisms. This paper proposes such development support by employing Model Driven Development (MDD). For this, we target the issue of soft errors, which may lead to silent data corruption due to radiation effects. We propose an MDD workflow including a model representation and model transformations, which are able to automatically generate memory protection for variables inside a program based on a model specification via UML stereotypes.

Heterogeneous sensor device networks with diverse maintainers and information collected via social media as well as crowdsourcing tend to be elements of uncertainty in IoT and Smart City networks. Often, there is no ground truth available that can be used to check the plausibility and concordance of the new information. This paper proposes the Valid.IoT Framework as an attachable IoT framework component that can be linked to generate QoI vectors and Interpolated sensory data with plausibility and quality estimations to a variety of platforms. The framework utilises extended infrastructure knowledge and infrastructure-aware interpolation algorithms to validate crowdsourced and device generated sensor information through sensor fusion.

Internet of Things (IoT)-enabled applications are gaining inroads in various domains. Several IoT platforms, with support for rich set of device libraries, facilitate rapid development of embedded IoT applications. But, none of the approaches deal with an early analysis of performance characteristics such as energy and timing properties. Such analysis (and feedback) during early design stages would help in identifying problems in meeting the performance attributes, reduce development time/effort, and deliver better quality without budget overshoot. Addressing this gap, a novel, generic workflow to carry out a quick, early, model-driven, system-level energy-aware timing validation of IoT-enabled hand-written code in specialized timing analysis tools, such as SymTA/S, is proposed in this paper. A prototype of the workflow is realized using a light-weight interfacing tool framework (with plug-ins) employing the Eclipse environment. A discussion on the various implementation aspects of the workflow and its qualitative and quantitative analysis based on experiments on real-world, model-based, IoT-enabled use cases of varying complexities is presented. The IoT-enabled emission monitoring system described in this paper is a full-fledged use case (in its completeness) and tested including live data captured from emission monitoring with the IBM Watson IoT platform. A tradeoff analysis among the energy and timing characteristics of an IoT-enabled automotive real-time emission monitoring use case, with the aid of the workflow/prototype implementation is presented in a timing-energy analysis tool. The main benefit of the proposed workflow is the feedback regarding energy and timing characteristics of the IoT-enabled application, early during development stages. Such analysis results providing early feed back regarding performance characteristics (load and schedulability) of the IoT application software system can be termed as a breakthrough for software architects and design engineers toward realizing reliable and cutting edge IoT-enabled systems.

Several IoT platforms, with support for a rich set of device libraries, facilitate rapid development of embedded IoT applications. But, none of the approaches deal with the analysis of performance characteristics. An example is the early timing validation of IoT use cases in specialized timing analysis tools. Addressing this gap, a generic workflow for a quick, early model-driven, system-level timing validation of IoT compliant hand-written code in specialized timing analysis tools, such as SymTA/S, is proposed in this paper. A prototype implementation of the workflow and its experimental evaluation in a novel, IoT-compliant real-time emission monitoring use case is presented. The main benefit of the proposed workflow is the early feedback regarding performance characteristics of the embedded IoT application, under varying timing constraints.

In model-based Embedded Software Engineering (ESE), individual systems are modeled with chains of components that are translated to chains of tasks/runnables for a scheduling analysis. Early analysis of response time of such systems (e.g. end-to-end path delay) provides important feedback to understand how the function blocks/components in the system may actually behave. In this paper we report on work in progress pertaining to an overall workflow for model-driven specification, translation and validation of such timing constraints in ESE projects developed using Matlab/Simulink. The challenges addressed in this workflow and future directions are outlined.

In the recent decade, many formalisms and tools have emerged for model-driven Non-Functional Property (NFP) specification and assessment. In this direction, model-driven reliability and safety assessment of engineering systems developed using Matlab/Simulink is an emerging research challenge. However, a generic mechanism for NFP specification in the Simulink design model is not yet supported. Further, a completely automated model-based workflow for synthesis of a NFP analysis model and its subsequent analysis in a NFP analysis tool is missing. In this context, this paper proposes a novel approach and a fully automated workflow towards model-driven reliability analysis of Simulink models. An approach to annotate the Simulink design models with reliability attributes and subsequent synthesis of fault trees from the annotated design model is described. A prototype and initial experimental results are discussed.

The increasing complexity of realtime embedded software systems necessitates them to support a variety of functions. Therefore, a practice is to split the overall system into different sub-systems and use various (modeling) tools for describing different parts of the system. On the other hand, though guaranteeing realtime properties forms an integral part of realtime embedded software development, it is often overlooked during system specification. Thereby, much effort is needed to solve timing problems, when they occur after implementing a system. Therefore, it is desirable to specify and validate timing properties during early development stages. As different parts of an overall system can be developed using various tools, elements which influence the timing behavior can be located in different sources. In order to analyze the overall timing behavior with a timing validation tool, all timing properties of the overall system are needed. Therefore, this paper presents an approach to couple timing properties from different sources. The approach allows to create links between elements across different sources and to synchronize timing properties. Thereby, timing properties can be followed, kept consistent and combined to be validated.

In Embedded Software Engineering (ESE) scenarios involving heterogeneous modeling domains, the sub-systems may be developed using more than one modeling domain. In such scenarios, the need arises for co-engineering and model-based synchronization of Non-Functional Properties (NFPs) which are spread/linked across various modeling domains, before performing an NFP analysis. This paper proposes an integrated, generic workflow for model-based co-engineering and NFP analysis of embedded software systems developed by interdisciplinary teams, using heterogeneous modeling domains. Based on this workflow, a mechanism for model-based co-engineering and reliability analysis of an embedded software system, developed using Unified Modeling Language (UML) and Matlab/Simulink is discussed. An experimental evaluation of the proposed mechanism is presented.

The development process for new algorithms or data structures often begins with the analysis of benchmark results to identify the drawbacks of already existing implementations. Furthermore it ends with the comparison of old and new implementations by using one or more well established benchmark. But how relevant, reproducible, fair, verifiable and usable those benchmarks may be, they have certain drawbacks. On the one hand a new implementation may be biased to provide good results for a specific benchmark. On the other hand benchmarks are very general and often fail to identify the worst and best cases of a specific implementation. In this paper we present a new approach for the comparison of algorithms and data structures on the implementation level using code coverage. Our approach uses model checking and multi-objective evolutionary algorithms to create test cases with a high code coverage. It then executes each of the given implementations with each of the test cases in order to calculate a cross coverage. Using this it calculates a combined coverage and weighted performance where implementations, which are not fully covered by the test cases of the other implementations, are punished. These metrics can be used to compare the performance of several implementations on a much deeper level than traditional benchmarks and they incorporate worst, best and average cases in an equal manner. We demonstrate this approach by two example sets of algorithms and outline the next research steps required in this context along with the greatest risks and challenges.

In the domain of embedded systems, the complexities involved in embedded software development are being successfully addressed by the emerging field of model-based software development and testing. However, in embedded systems, the underlying embedded software is often expected to collaborate with various hardware, mechanical, electrical modules/technologies. To address this aspect of heterogeneity in embedded systems, practitioners of model-based embedded software engineering are required to use more than one modeling language. This is essential to address the multi-faceted design aspects/requirements of an embedded system. This paper elaborates on the existing data interchange and coupling mechanisms between embedded software sub-systems modeled using UML and Matlab/Simulink. While there are some existing coupling mechanisms for data exchange among heterogenous modeling domains, they are all not applicable to all real-time operating systems and/or limited to a few simulation studies. This paper addresses the aforementioned gaps and proposes a simple, generic methodology for data exchange between events (in UML domain) and signals (in Matlab/Simulink domain). The proposed approach is elaborated using a seesaw (real-word) embedded software system application scenario example. Initial prototype implementation of the proposed approach, experimental results and some future directions are outlined.

Model Driven Development (MDD) is deemed as a key to address the increasing complexity of software systems. It is imperative that the developed software fulfills the end-user's requirements. This implies that a collaboration between the Requirements Management (RM) tools and the modeling tools, enabling complete traceability and interfacing among these tools, is essential. On the other hand, existing tools collaborating between RM and modeling tools support a very limited sub-set of new features (e.g. traceability analysis) and are compatible with only a few tools. As a result, software engineers are often required to educate themselves on another (often complex), intermediate (collaborating) tool, merely to realize a very limited sub-set of supported features. This paper addresses these gaps and introduces an approach for exchanging information between RM tools and Unified Modeling Language (UML) tools by using the standardized Requirements Interchange Format (ReqIF). The proposed approach (a) enables software developers to create links between requirements and UML elements in their modeling tool and (b) facilitates requirements engineers to make traceability/other analyses down to linked model elements inside their RM tool. In contrast to many other approaches, no additional user interface is needed for traceability.

Embedded software development is moving towards the model-based paradigm to support the complexity of today's embedded systems, as they become more and more important and omnipresent in our daily lives. In this context, the Unified Modeling Language (UML) is a widely used standard. Code generators can be executed to generate source code from UML models. Usually the code generators are proprietary for one UML tool. If code generators for different targets or programming languages have to be supported by various modeling tools, the wheel must be reinvented. Code generators could use the standardized Extensible Markup Language Metadata Interchange (XMI) format of the UML as a basis. However, tools export their data to XMI differently. Therefore, the paper shows how the proprietary models of UML tools can be mapped to a standardized UML model. This is realized by using techniques for model to model transformations. These techniques need a meta-model for the source and the target model. Hence, an approach is introduced for creating meta-models for Application Programming Interfaces (APIs) of UML-tools, which act as a facade. Then the code generators can work with the standardized UML model to generate the source code. This results in an improved scalability of the code generators.

The existing model-based tools employ runtime monitoring methodologies for debugging and testing of embedded systems. In these tools, the additional instrumentation for incorporating and executing the test code varies based on the application. Such techniques could also introduce significant, non-deterministic overhead in the embedded system. This is a hurdle in applying Model-Based Testing (MBT) for resource constrained embedded systems and industrially relevant examples. To address this gap, this paper elaborates on the monitoring methodology used in a test framework for executing the model-based test cases in the embedded system. Two variants of the proposed monitoring methodology, (a) software and (b) on-chip monitoring are discussed. An empirical evaluation based on a prototype implementation of the proposed runtime monitoring mechanisms is discussed.

Automated checking concepts for business process models support human testers considerably by saving time. However, this new checking ability results in a comparatively large number of rules representing requirements. But without a comprehensible representation of the relations between the rules on the one hand its hard to keep track on the validated rules and on the other hand to correctly interpret the validation results. In this paper we propose an improvement for the automated validation of business process models by offering elements to create abstract rules and arranging these rules in hierarchies. Top-down and bottom-up testing are supported by stepwise activating (and validating) the rules starting from the top of the hierarchy (or bottom respectively). Moreover, the rule hierarchies may be reused when similar systems are to be validated by configuring a valid rule sub-set for the specific business process system.

Regulatory compliance management is now widely recognized as one of the main challenges still to be efficiently dealt with in information systems. In the discipline of business process management in particular, compliance is considered as an important driver of the efficiency, reliability and market value of companies. It consists of ensuring that enterprise systems behave according to some guidance provided in the form of regulations. This paper gives a definition of the research problem of regulatory compliance. We show why we expect a formal policy-based and model-driven approach to provide significant advantages in allowing enterprises to flexibly manage decision-making related to regulatory compliance. For this purpose, we contribute CoReL, a domain-specific modeling language for representing compliance requirements that has a graphical concrete syntax. Informal semantics of CoReL are introduced and its use is illustrated on an example. CoReL allows to leverage business process compliance modeling and checking, enhancing it with regard to, among other dimensions, user-friendliness, genericity, and traceability.

Model-based methodologies such as the Model-Driven Development (MDD) and Model-Based Testing (MBT) are being explored, in the recent decade, for automation in embedded software engineering projects. In this context, the target of this paper is to demonstrate the adoption and applicability of the Unified Modeling Language (UML) and the UML Testing Profile (UTP) for deploying MBT in Resource-Constrained (RC)-Real-Time Embedded Systems (RTES). Though the UTP standard has been introduced several years ago, concrete approaches or tool support for generating the test artifacts based on the UTP is currently unavailable. This paper aims to close this gap and discusses a concise set of UTP artifacts in the context of MBT for RC-RTES. A detailed discussion on the test artifacts generation algorithm demonstrating the applicability of our approach in a real-life RC-RTES example is presented.

Components have been introduced in order to support software reuse. Components are reusable building blocks for larger systems consisting of units (code pieces) and their construction plan. Technologies like COM+, .Net, CORBA JavaBeans and EJBs (or web services which may be considered as web-based components) have been developed to support the component concept. However, components still have the problem of both unavailable and unreliable documentation of their properties. Moreover, a lack of validation support concerning the components' or composed systems' behavior may be observed. In other words, there is a lot of knowledge about how to combine components technically but less experience to validate the interactions between the components.

Model driven design and development of real-time embedded systems has been gaining a lot of attention in the recent past. It is imperative for a hard real-time embedded system to execute and respond to sequenced exchanges of messages under critical temporal constraints. The UML provides artifacts such as communication diagrams, sequence diagrams and timing diagrams to aid software engineers to model and precisely document such a schedule of interactions or state changes at the design level. While modeling at the design level is interesting on one hand, it is also significant to understand the run time behavior of the embedded software. A step forward in this direction is to provide a real-time representation of the target system behavior on the host side. We propose an approach to realize a target debugger on the host side with a monitor solution in the target side. With the back annotated information from the target, a visual representation of the system behavior in real-time is now available at the design level. This way, a debugging solution in real-time is provided, thus taking a step forward towards understanding the behavior of the embedded software at hand. We illustrate our proposed approach with a prototype and examples.

Business Process Management is a paradigm for enterprise computing that uses IT not only to support or execute business processes but also to continuously monitor and improve these processes to better achieve business objectives. A variant on Business Process Management, called Semantic Business Process Management, is meant to further close the gap between business and IT by attaching business semantics to the technology artifacts used for Business Process Management. A current problem in Semantic Business Process Management is that the specification of the business requirements that processes must respond to and that follow from the enterprise's strategic decisions, is not fully integrated within the design of the processes themselves. In this paper, we propose an approach in which business requirements for business processes are formally modeled and the skeleton of the designs of these business processes is automatically generated from these models. The approach presented here focuses upon the modeling of policies (i.e., a kind of business requirements for business processes) and on the subsequent design of business processes that comply to these policies. A first contribution is extending an existing goal-oriented requirements specification language, i.e. Formal Tropos, to incorporate policies, called Policy-extended Formal Tropos. A second contribution is offering an automated transformation to create business process design skeletons out of the Policy-extended Formal Tropos models. The paper also reports upon three pilot studies that were conducted as a first, though preliminary, empirical test of our approach. © 2010 Wiley Periodicals, Inc.

A variety of models and notations are available to support the software developers. Such models help to gather requirements and to build a system implementing these requirements. However, it is often neglected to verify that the requirements are actually fulfilled in the design and implementation. The increasing demand for compliancy to requirements (e.g. due to laws) together with the increasing system complexity re-attracts notice to automatic verification technologies for that purpose. The low user-friendliness and, thus, the low applicability of the verification technologies often prevents their employment. In this paper we aim at closing the gap between software development models with their rich notation and semantics (e.g. Event Process Chains, EPCs) on the one hand and verification-oriented models (typically just simple structures like finite state automata) on the other hand. This is approached by extending the verification model in a controlled manner towards more semantics resulting in our extended Kripke structure. To profit from such a semantic extension we, in addition, extend the temporal logic language CTL. Our new temporal logic language allows to express the expected requirements more precisely.

The automated generation of systems (e.g. within model-driven development) is a considerable improvement of the software development. However, besides the automated generation the verification of these generated systems needs to be supported, too. By applying generators it is not necessarily guaranteed that the generation outcome is correct. Typical problems may be, firstly, the use of a wrong operator resulting in an erroneous generation (static aspects of the generation). Secondly, the interactions between the different generated system assets (snippets) of the generated outcome might be incorrect, since the snippets might be connected in a wrong sequence (dynamic aspect of the generation). Therefore, the hierarchical dependencies of the snippets which are the input of the generator as well as the dynamic behavior resulting from the generation have to be checked. We describe the hierarchy in a version model based on Boolean logic. The temporal behavior may be checked by model checkers. For the generation we apply our XOpT concept which provides domain-specific transformation operators on the XML representation. Besides the principles of the static and dynamic elements of our checking approach the paper presents the way to map program assets to the version model and to finite state automata which are the prerequisite for the checking. Though the proposed checking is presented at the code level the approach may be applied to different kinds of assets, e.g. also on the model level.