https://www.mdu.se/

In graph theory and its applications to networking, such as telecommunications or transportation, path-finding is a central problem. While single-path algorithms are well established, methods for handling sets of multiple paths are less developed. A companion paper introduced a formal model for defining attributes over sets of paths based on their structural properties; this paper addresses that model's practical implementation. We present an optimized algorithm for computing cut sets of a path set - a nontrivial task that can be infeasible without efficient methods - and validate its performance via systematic benchmarks on network simulations of varying complexity. Additionally, we introduce a vectorized computational framework that expresses property calculations as matrix operations, enabling concise implementations in array-oriented languages. Together, these contributions establish practical foundations for the companion model, demonstrating that its implementation is both feasible and characterized by predictable, acceptable execution times.

In graph theory and its practical networking applications, e.g., telecommunications and transportation, the problem of finding paths has particular importance. Selecting paths requires giving scores to the alternative solutions to drive a choice. While previous studies have provided comprehensive evaluation of single-path solutions, the same level of detail is lacking when considering sets of paths. This paper emphasizes that the path characterization strongly depends on the properties under consideration. While property-based characterization is also valid for single paths, it becomes crucial to analyse multiple path sets. From the above consideration, this paper proposes a mathematical approach, defining a functional model that lends itself well to characterizing the path set in its general formulation. The paper shows how the functional model contextualizes specific attributes.

There is a widely held belief that implementing fault management always costs less than handling faults in the field. However, the relationship between the costs of fault management and maintenance is more complex, and formal decision-making support is often lacking. This paper proposes quantitative methods to evaluate the economic sustainability of fault management solutions and the quality levels that support a product's business case. It introduces a mathematical model describing how investments in fault management reduce expected maintenance costs, and a second model linking the product's fault coverage to its return rate, which reflects both product reliability and potential impacts on brand reputation. Together, these models provide a framework to guide decisions on fault management investment and to quantify the trade-off between implementation cost, operational cost, and product quality.

Engineering education must not only be scientifically based, but also relevant to the future job market. Education incorporating elements of work-integrated learning (WIL) aims to achieve this by combining academic learning with practical work experience. This literature review examines WIL's impact on engineering education. Through a snowballing process, 29 empirical studies published between 2000 and 2023 were identified and analyzed. Key findings reveal that WIL enhances employability, fosters critical thinking, and improves problem-solving skills by connecting classroom concepts with real-world applications. Successful WIL programs depend on strong collaborations between educational institutions and industry stakeholders, structured support systems, and reflective learning practices. The review underscores the need for carefully designed WIL programs that integrate contextual understanding. Based on these findings, a new model for WIL in engineering education is proposed, in which elements of contextual understanding from an end-user perspective are accentuated.

Let us consider an embedded system as a specific combination of hardware and software that is capable of consistently providing a certain service. Depending on the boundary conditions of the system, such as the working environment and the number of users served, we can say that the statistical distribution of resource usage is a characterization of the embedded system itself and its footprint. The consequence of this distinguishable footprint for embedded systems is that it becomes possible to use the statistical deviation of the resource usage distribution to identify anomalies. In this paper, we will analyze which Performance Metric Unit counters (e.g., CPU usage, memory usage) and resource profiles (e.g., system logs, performance metrics) are most characteristic for detecting a lowlevel anomaly: an alteration of the firmware working cycle or the propagation of a hardware error in the system. We will do this by using baseband products for radio access networks. We will demonstrate that using a machine learning model makes it possible to distinguish both the firmware cycle alteration and the hardware error reporting with an accuracy of more than 99% on unseen and new dataset.

Requirement Engineering (RE) is crucial for identifying, analysing and documenting stakeholders' needs and constraints for developing software systems. In most safety-critical domains, maintaining requirements and their links to other artifacts is also often required by regulatory bodies. Furthermore, in such contexts, requirements for new products often share similarities with previous existing projects performed by the company. Therefore, similar requirements can be retrieved to facilitate the feasibility analysis of new projects. In addition, when a new customer requests a new product, retrieval of similar requirements can enable requirements-driven software reuse and avoid redundant development efforts. Manually retrieving similar requirements for reuse is typically dependent on the engineer's experience and is not scalable, as the set could be quite large. In this regard, applying natural language processing (NLP) techniques for automated similarity computation and retrieval ensures the independence of the process from the human experience and makes the process scalable. This chapter introduces linguistic similarity and several NLP-based similarity computation techniques that leverage linguistic features for similarity computation. Specifically, we cover techniques for computing similarity ranging from lexical to state-of-the-art deep neural network-based methods. We demonstrate their application in two example cases: (a) requirements reuse and (b) requirements-driven software retrieval. The practical guidance and example cases presented in the chapter can help practitioners apply the concepts to improve their processes where similarity computation is relevant. 

Fault tree analysis is a system malfunction hazard evaluation quantitative and qualitative procedure. The method is well-known and widely used, especially in the safety systems domain, where it is a mandatory integral part of the so-called "Hazard Evaluation"documentation. This paper proposes an alternative or complementary deductive fault analysis method: it uses system topology to build a hypergraph representation of the system to identify component criticality and support loss of functionality probability evaluation. Once automated, the proposed method seems promising when the system engineers explore the different architectures. They may have indication about architecture's reliability without continuous feedback from the system safety team. The system safety team must check the solution once the engineers select the final architecture. They can also use the proposed method to validate the correctness of the fault tree analysis.

The ability of a system to maintain the availability of its services for the end user is a crucial indicator of performance, both in terms of infrastructure and serviceability. In other words, the service's availability depends on the system's resilience, which is its ability to handle disruptions in the deployed service. Fault management is crucial to increasing system resilience because it aims to control and recover error conditions. However, the efficiency of the fault management implementation depends on the infrastructure design: hardware-assisted fault management allows the quickest recovery action and a better fault isolation. From what we have written above, we can understand why an efficient infrastructure design and practical implementation of fault management can lead to high system resilience. How can we evaluate the efficiency of fault management and infrastructure design relative to system resilience? This paper proposes a new model for measuring system resilience that considers the different fault management aspects contributing to resilience.

This paper describes the Architecture Life Cycle Effect Analysis (ALCEA) method, a structured method for evaluating proposed new architectures for software-intensive systems. The method evaluates a proposed architecture by quantifying its effect on the performance of system life-cycle phases. The method is instantiated by identifying (i) the relevant life-cycle phases of the system under investigation and (ii) a set of evaluation functions that capture, in terms of basic factors, the effect of different architectural decisions on key life-cycle performance attributes, such as revenue, operating resources, and investments. The method results in a transparent cost and revenue structure, documented in a tabular form, based on quantifiable factors from the developing organization. The results of the method can be used directly as part of a business case, and their robustness can be estimated by sensitivity analysis. The ALCEA method is designed for system-level architectural analysis, covering both software and hardware aspects. In this paper, we introduce the ALCEA method and provide a detailed example of how to apply it in the evolution of embedded systems. Moreover, we share early experiences of using the method in large-scale industrial settings.

Understanding the behaviour of a system’s API can be hard. Giving users access to relevant examples of how an API behaves has been shown to make this easier for them. In addition, such examples can be used to verify expected behaviour or identify unwanted behaviours. Methods for automatically generating examples have existed for a long time. However, state-of-the-art methods rely on either white-box information, such as source code, or on formal specifications of the system behaviour. But what if you do not have access to either? This may be the case, for example, when interacting with a third-party API. In this paper, we present an approach to automatically generate relevant examples of behaviours of an API, without requiring either source code or a formal specification of behaviour. Evaluation on an industry-grade REST API shows that our method can produce small and relevant examples that can help engineers to understand the system under exploration.