Federated Learning (FL) typically assumes unconditional collaboration, a premise that overlooks the complexities of real-world, multi-stakeholder environments in which clients may need to exclude one another for strategic, regulatory, or competitive reasons. This paper addresses this gap, which we term 'client-level disagreements,' by first introducing a taxonomy of such scenarios. We then propose a robust, multi-track resolution strategy that guarantees strict client exclusion by creating and managing isolated model update paths ('tracks'), thereby preventing the cross-contamination and unfairness issues present in naive strategies. Through an empirical evaluation of our custom simulation system across 34 scenarios using the MNIST and N-CMAPSS datasets, we validate that our approach correctly handles permanent, temporal, and overlapping disagreement patterns. Our scalability analysis reveals the server-side resolution algorithm's overhead is negligible (<1 ms per round) even under heavy load. The primary scalability constraint is the client-side training load from participating in multiple tracks, a cost that we show can be effectively mitigated by a submodel reuse strategy. This work presents a scalable and architecturally sound method for managing client-level disagreements, and enhances the practical applicability of FL in settings where policy compliance and strategic control are non-negotiable.

Secure neural network inference (SNNI) enables the use of deep neural networks in scenarios involving multiple stakeholders, protecting the confidentiality of client data and of the neural network’s parameters. The cryptographic techniques used introduce high computational overhead, leading to significant energy consumption. Reducing the energy consumption of SNNI is thus an important objective. A prerequisite for energy optimization is the ability to profile the energy consumption of SNNI. However, this is challenging due to the complexity of the cryptographic techniques, neural networks, and technical setup involved. This paper is the first to propose an energy profiling approach for SNNI. Our approach measures the energy consumption for securely processing individual layers of the neural network, thus providing fine-grained insights into the energy profile of SNNI. We evaluate our approach using the ResNet50 neural network and the Cheetah SNNI framework. Our results show that we can reliably measure the energy consumption of individual layers. By introducing short periods of inactivity between layers to disentangle them, we achieve high correlation between execution time and energy consumption, suggesting that, under appropriate conditions, execution time may be used as a proxy for energy consumption. Our approach and insights can foster the design of more energy-efficient SNNI protocols.

By 2030 greenhouse gas emissions should be reduced by at least 55%. Despite hardware becoming more energy-efficient (Koomey's law), the ever-increasing reliance on computer technology has increased the energy usage due to ICT significantly.

The EULYNX Consortium is a European initiative by 13 infrastructure managers to standardize interfaces of railway signaling systems. The consortium creates specifications based on semi-formal SysML models. In this paper, we research the feasibility of using the EULYNX SysML models for Model-Based Testing (MBT), which contributes to higher quality specifications and more efficient conformance testing of system implementations. MBT promotes safety, which is one of the most important aspects of railway signaling systems. Our approach is to translate EULYNX SysML models to Symbolic Transition Systems (STS) and to use the STS for MBT. We utilize the Axini Modeling Language (AML) and the Axini Modeling Platform (AMP), which are used by ProRail. As our System Under Test (SUT) we use a software simulation of the EULYNX point subsystem, used by EULYNX developers. We revealed several non-conforming behaviors of the SUT which shows that interface specifications like EULYNX benefit from the application of MBT. However, we observe that better advantage of MBT can be taken if EULYNX SysML specifications abstracted from implementation details, which is currently not the case.

In automated compiler testing, the focus typically lies in uncovering bugs caused by optimisations performed by the compiler. However, there is a class of compilers where little to no optimisations are performed: those for migration of legacy software. Therefore, it is not clear to what extent such legacy compilers would benefit from automated compiler testing. We investigated this in the context of the Raincode legacy compiler for PL/I, an industrial compiler targeting the. NET platform. We designed and implemented a framework for automated PL/I compiler testing through precomputation-based program generation and ran it on two versions of the Raincode PL/I compiler: an older with known bugs and the latest release. On the older version, our framework generated around 127.000 programs and found five bugs, two of which were previously unknown to us. For the latest compiler release, after 180 hours of tests and more than 718.000 generated programs, the framework did not reveal any bugs.

Test smells are poor design decisions implemented in test code, which can have an impact on the effectiveness and maintainability of unit tests. Even though test smell detection tools exist, how to rank the severity of the detected smells is an open research topic. In this work, we aim at investigating the severity rating for four test smells and investigate their perceived impact on test suite maintainability by the developers. To accomplish this, we first analyzed some 1,500 open-source projects to elicit severity thresholds for commonly found test smells. Then, we conducted a study with developers to evaluate our thresholds. We found that (1) current detection rules for certain test smells are considered as too strict by the developers and (2) our newly defined severity thresholds are in line with the participants' perception of how test smells have an impact on the maintainability of a test suite. Preprint [https://doi.org/10.5281/zenodo.3744281], data and material [https://doi.org/10.5281/zenodo.3611111].

In a dynamic world of software development, the architectural styles are continuously evolving, adapting to new technologies and trends. Microservice architecture (MSA) is gaining adoption among industry practitioners due to its advantages compared to the monolithic architecture. Although MSA builds on the core concepts of Service Oriented Architecture (SOA), it pushes for a finer granularity, with stricter boundaries. Due to cost rationale, numerous companies choose to migrate from the monolithic style instead of developing from scratch. Recently, semi-automatic decomposition tools assist the migration process, yet a crucial part is still missing: validation. The current study focuses on providing a validation framework for microservices decomposed from monolithic applications and complete the puzzle of architectural migrations. From previous work we select quality attributes of microservices that may be assessed using static analysis. We then provide an implementation specification of the validation framework. We use five applications to evaluate our approach, and the results show that our solution is scalable while providing insightful measurements of the assessed quality attributes of microservices.

Modern applications are often implemented as distributed systems consisting of multiple application layers and spread across many machines. Monitoring and diagnosing are fundamental challenges of such systems, and many solutions have been proposed. They all aim to abstract the distributed nature and offer a concise overview of the system. Distributed logging, monitoring and tracing solutions help with root cause analysis or assessing the performance of the system. In data processing situations, data is the main driver and it should be treated accordingly. Microservices are often used to implement highly distributed data processing systems, so troubleshooting from a data point of view is also difficult. Data should be monitored and traced across machines and applications in order to get reliable insights into how the data is stored and processed. However, existing approaches to distributed tracing are based on tracing requests that are propagated throughout the system instead on their content. In this work we take a data-centric perspective to tracing and data processing to investigate how content can be traced in a distributed system. We evaluate existing tracing approaches to see if they can be extended to the content itself, then we take into consideration new ones. We implement three different approaches to data-centric distributed tracing in a highly distributed data processing system built using microservices and discuss their advantages and disadvantages.

The architectural styles in the world of software development are constantly evolving. Recently the microservice architecture is gaining more and more traction, building on concepts of Service Oriented Architecture (SOA) and steering further away from monolithic architectures. Emerged from agile communities, the microservice oriented architecture implies a number of small-sized microservices independently deployable. The adoption of microservices as the base for creating enterprise applications is certain, yet many companies intend to migrate from the old monolithic style instead of creating new products mainly due to cost related implications as well as challenging and complex tasks. Several tools and approaches for the semi-automatic decomposition of monolithic applications to microservices have emerged, yet many of them still struggle to verify the result of such process, the architect being indispensable for assessing the output microservices. Although this area is intensely studied, no unanimously accepted and clear guidelines for defining a good microservice exist. This survey focuses on providing a comprehensive and broadly applicable set of quality assessment criteria for microservices resulted from semi-automatic migration tools or techniques. Our study aligns with industry requirements, including a case study which further validates our set of quality attributes. In the refinement step of the quality attributes set, the prospect of automating the process of validation is also discussed.

Compute clusters, consisting of many, uniformly built nodes, are used to run a large spectrum of different workloads, like tightly coupled (MPI) jobs, MapReduce, or graph-processing data-analytics applications, each of which with their own resource requirements. Many studies consistently highlight two types of under-utilized cluster resources: memory (up to 50%) and network. In this work, we take a step towards (software) resource disaggregation, and therefore increased resource utilization, by designing a memory scavenging technique that makes unused memory available to applications on other cluster nodes. We implement this technique in MemFSS, an in-memory distributed file system. The scavenging MemFSS extends its storage space by taking advantage of the unused memory and bandwidth of cluster nodes already running other tenants' applications. Our experiments show that our memory scavenging approach incurs negligible overhead (below 10%) for most tenant applications, while the compute resource comsumption of MemFSS applications is largely reduced (by 17%-74%).

Current advanced cloud infrastructure management solutions allow scheduling actions for dynamically changing the number of running virtual machines (VMs). This approach, however, does not guarantee that the scheduled number of VMs will properly handle the actual user generated workload, especially if the user utilization patterns will change. We propose using a dynamically generated scaling model for the VMs containing the services of the distributed applications, which is able to react to the variations in the number of application users. We answer the following question: How to dynamically decide how many services of each type are needed in order to handle a larger workload within the same time constraints? We describe a mechanism for dynamically composing the SLAs for controlling the scaling of distributed services by combining data analysis mechanisms with application benchmarking using multiple VM configurations. Based on processing of multiple application benchmarks generated data sets we discover a set of service monitoring metrics able to predict critical Service Level Agreement (SLA) parameters. By combining this set of predictor metrics with a heuristic for selecting the appropriate scaling-out paths for the services of distributed applications, we show how SLA scaling rules can be inferred and then used for controlling the runtime scale-in and scale-out of distributed services. We validate our architecture and models by performing scaling experiments with a distributed application representative for the enterprise class of information systems. We show how dynamically generated SLAs can be successfully used for controlling the management of distributed services scaling.

This paper presents ongoing work to develop advanced education and training course on the Cloud Computing technologies foundation and engineering by a cooperating group of universities and the professional education partners. The central part of proposed approach is the Common Body of Knowledge in Cloud Computing (CBK-CC) that defines the professional level of knowledge in the selected domain and allows consistent curricula structuring and profiling. The paper presents the structure of the course and explains the principles used for developing course materials, such as Bloom's Taxonomy applied for technical education, and andragogy instructional model for professional education and training. The paper explains the importance of using the strong technical foundation to build the course materials that can address interests of different categories of stakeholders and roles/responsibilities in the Cloud Computing services provisioning and operation. The paper provides a short description of summary of the used Cloud Computing related architecture concepts and models that allow consistent mapping between CBK-CC, stakeholder roles/responsibilities and required skills, explaining also importance of the requirements engineering stage that provides a context for cloud based services design. The paper refers to the ongoing development of the educational course on Cloud Computing at the University of Amsterdam, University of Stavanger and provides suggestions for building advanced online training course for IT professionals.

Modern cloud-based applications and infrastructures may include resources and services (components) from multiple cloud providers, are heterogeneous by nature and require adjustment, composition and integration. The specific application requirements can be met with difficulty by the current static predefined cloud integration architectures and models. In this paper, we propose the Intercloud Operations and Management Framework (ICOMF) as part of the more general Intercloud Architecture Framework (ICAF) that provides a basis for building and operating a dynamically manageable multi-provider cloud ecosystem. The proposed ICOMF enables dynamic resource composition and decomposition, with a main focus on translating business models and objectives to cloud services ensembles. Our model is user-centric and focuses on the specific application execution requirements, by leveraging incubating virtualization techniques. From a cloud provider perspective, the ecosystem provides more insight into how to best customize the offerings of virtualized resources.

Commercial cloud offerings, such as Amazon's EC2, let users allocate compute resources on demand, charging based on reserved time intervals. While this gives great¿exibility to elastic applications, users lack guidance for choosing between multiple offerings, in order to complete their computations within given budget constraints. In this work, we present BaTS, our budget-constrained scheduler. BaTS can schedule large bags of tasks onto multiple clouds with different CPU performance and cost, minimizing completion time while respecting an upper bound for the budget to be spent. BaTS requires no a-priori information about task completion times, and learns to estimate them at runtime. We evaluate BaTS by emulating different cloud environments on the DAS-3 multi-cluster system. Our results show that BaTS is able to schedule within a user-defined-budget (if such a schedule is possible at all.) At the expense of extra compute time, significant cost savings can be achieved when comparing to a cost-oblivious round-robin scheduler.