Self-Aggregation Algorithms for Autonomic Systems

The process of software development is usually described in terms of a progression from the project planning to the final code, passing through intermediate stages such as requirement analysis, system design, coding, system testing, and maintenance. One important aspect of these requirements concerns the reliability of the software. The use of computers for life-critical systems demands extremely high reliability of the computing functions as a whole. The consequences of negative results from unreliable systems and software are becoming public knowledge every day. Since these situations create a negative image for computer professionals and since these episodes create an environment of nontrust for the discipline, a good look at the ethical issues in software engineering is necessary. In this chapter, we look at each of the software engineering steps and the important aspect of their reliability and safety in the analysis, design, and implementation of software. We also examine the ethical aspects of the software and system development.

The rise in complexity of software systems and the rise in sophistication of cyber threats have led to cybersecurity becoming a key issue in software engineering. The conventional security systems are usually unable to capture and react to the current attacks in real time, especially in a large-scale and dynamic environment. The development of Artificial Intelligence (AI) has become a revolutionary solution due to its ability to detect threats intelligently, evaluate vulnerabilities automatically, perform predictive analytics, detect anomalies, and implement adaptive defense mechanisms. This paper will discuss AI-driven cybersecurity in the software engineering field, where machine learning, deep learning, natural language processing, and reinforcement learning can be applied throughout the software development lifecycle to provide increased security. The study assesses the efficacy of AI-powered technologies in secure coding, threat modeling, penetration testing, reviewing code, malware detection, and responding to an incident. It also examines issues like adversarial attacks, data privacy issues, bias in algorithms, explainability, and integration issues in current development pipelines. Based on a systematic review and comparative framework, the paper shows that AI-based cybersecurity can greatly enhance the ability to proactively defend against threats, decrease reaction time, and increase resilience in the face of new threats. The results highlight the importance of ethical governance, human control, and ongoing updates of models to maximize the advantages of AI in safe software engineering activities. The work can be regarded as a valuable roadmap to researchers and developers, as well as organizations aiming to deploy intelligent cybersecurity approaches to the contemporary software environment.

Requirements elicitation process is important to guarantee the quality of software applications. In software engineering, requirements elicitation process has been taught by means of traditional methods. Games have been used to improve teaching of some issues in software engineering, but elicitation has not been the center of this way of teaching. As a way to deal with problems in requirements elicitation process teaching, we create in this paper "Communication and Traceability Game" and we summarize the results of applying this game to several groups of students.

One of the today issues in software engineering is to find new effective ways to deal intelligently with the increasing complexity of distributed computing systems. In particular, one of the aspects under study in the field of autonomic computing concerns the way such systems can autonomously reach a configuration that allows the entire system to work in a more efficient and effective way. In this paper we investigate how it is possible to obtain self-aggregation of distributed components. We have used existing self-aggregation algorithms as a starting point, and, after an analysis phase, we have discovered some aspects that could be improved. Finally we have derived new algorithms that showed improved self-aggregating performances in most of the situations.

Software engineering is a major research area which can integrate other technical application areas into it. The important issue in software engineering is software reuse. It is always better to reuse rather than doing it from scratch. In order to attain the software reusability, an efficient design of software repository is needed. The searching algorithms and retrieval mechanisms will work effectively for a well defined software repository. In this paper, the data mining technique specifically clustering is applied for designing of software component repository. The components considered in our proposed algorithm are functions and the main focus is given to the specifications or behavior of the components. Here the specifications of software components are represented by using preconditions and postconditions. These preconditions and postconditions are converted to first order predicate logic and then the clustering is applied.

Requirement volatility is an issue in software engineering in general, and in Web-based clinical applications in particular, which often originates from an incomplete knowledge of the domain of interest. With advances in the health science, many features and functionalities need to be added to, or removed from, existing software applications in the biomedical domain. At the same time, the increasing complexity of biomedical systems makes them more difficult to understand, and consequently it is more difficult to define their requirements, which contributes considerably to their volatility. In this paper, we present a novel agent-based approach for analyzing and managing volatile and dynamic requirements in an ontology-driven laboratory information management system (LIMS) designed for Web-based case reporting in medical mycology. The proposed framework is empowered with ontologies and formalized using category theory to provide a deep and common understanding of the functional and nonfunctional requirement hierarchies and their interrelations, and to trace the effects of a change on the conceptual framework.

Summary form only given. The use of components in the development of large software systems can have various benefits. Their testing, however, is still an open issue in software engineering. The user of a component is often faced with the problem that information necessary for testing purposes is not available. This lack of information distinguishes the testing of components from other software entities known from non-component-based development. This article gives an overview of the approaches to testing components. Besides the overview, this article also outlines some of the limitations of these approaches. Testing components is still an open problem.

The formal specifications of the Rosetta modules do not fully determine the algorithms that implement them. This leaves ample room for consideration about performance optimisation or subjective criteria such as elegance to influence the actual algorithms. Decisions must be made about the algorithms in each of the Rosetta modules. These algorithms, some of which were discussed in the previous chapter, are not the only subject of design decisions that have to be made, nor are they the most important ones. Many questions must be posed and answered while building a system like Rosetta. What does the user interface look like? What debugging facilities must be offered for developing linguistic software? What are the most convenient interfaces between the Rosetta modules, and what do S-trees, syntactic derivation trees (D-trees), semantic derivation trees and dictionaries look like? Can a translation system be run as one process, or is it better to split it into several subsystems? Each module of the Rosetta system produces a set of results. How does one represent such sets if they are very large? In what order do we process their elements? What programming language is chosen? Is linguistic data written in this language or in a special-purpose language that is subsequently translated into the programming language? Many of these problems can be dealt with in various ways. Their solutions are a matter of taste rather than of principle and do not deserve a detailed discussion here. The design of user interfaces is the subject of another discipline and is also beyond the scope of this book. Below we touch upon issues of software engineering that either involve a problematic aspect of the formalism or have proved to be essential in building our translation system.

The integration of software components becomes a more and more important issue in software engineering. Process-oriented approaches should provide automated information processes. Therefore, the software components have to be integrated in a consistent way, i.e., their export interfaces have to be respected by the importing components. Furthermore, the type system of component interfaces has to support a tunable degree of freedom. This allows the insertion of components with interfaces of restricted but sufficient degree of compatibility. In this paper, we develop a concept for consistent and flexible integration of components. We present a process modeling language that combines UML and XML in order to support consistent, flexible, and executable processes. Finally, we provide a formalization of the proposed component type system.

Summary form only given. Distributed systems verification is one of the main issues in software engineering. It is considered as the major field of the formal specification techniques. However, many difficulties remain. In fact, the principal problem is in producing a coherent specification and providing a fully integrated semantics. Since formal methods are mathematical description models that try to give a response concerning the reliability of a system. It remains a hard way for the designers. Thus, we present, here, an open environment for the integration of formal methods in the description and verification of distributed and concurrent systems. The system currently uses UML notation and provides rewriting logic, model checking, theorem proving, and simulation techniques.

Design-for-testability is a very important issue in software engineering. It becomes crucial in the case of OO designs where control flows are generally not hierarchical, but are diffuse and distributed over the whole architecture. We introduce the concept of a conflict when potentially concurrent client/supplier relationships between the same classes along different paths exist in a system. Such conflicts may be hard to test, especially when dynamic binding and polymorphism are involved. We describe the conflicts using topological class configuration diagrams. An overall architecture is represented as a combination of the initial design and several patterns. We focus on the design patterns as coherent subsets in the architecture, and we explain how their use can provide a way for limiting the complexity of testing for conflicts, and of confining their effects to the classes involved in the pattern.

Software systems play a key role in most businesses nowadays. Building robust, reliable and scalable software systems require going through a software production cycle (or process). However, it has been noticed that software systems are subjected to changes, whether those amendments are important or not. Those changes to software systems are viewed as a considerable issue in software engineering; they are considered as a burden and cost a lot, especially in cases such as enterprises and large-scale software systems. This study aims to identify the reasons that cause software changes and suggest remedies for those reasons. We survey the opinions of experts such as technical managers, team leaders, and senior developers. We collected 81 responses to our questionnaire, which aimed to establish common software development practices in the local industry. We also conducted 16 semi-structured interviews targeting the most senior experts, in which we directly discussed the reasons and remedies for software changes. Our results highlight the most influential reasons that cause changes to software systems, such as changes to user requirements, requests for new features, software development methodology, solving bugs, refactoring, and weak user experience design. Most importantly, the study solicited solutions that can reduce the need for software changes

Design for testability is a very important issue in software engineering. It becomes crucial in the case of Model Based Testing where models are generally not tested before using as input of Model Based Testing. The quality of design models (e.g.; UML models), has received less attention, which are main artifacts of any software design. Testability tends to make the validation phase more efficient in exposing faults during testing, and consequently to increase quality of the end-product to meet required specifications. Testability modeling has been researched for many years. Unfortunately, the modeling of a design for testability is often performed after the design is complete. This limits the functional use of the testability model to determining what level of test coverage is available in the design. This information may be useful to help assess whether a product meets the target requirement to achieve a desired level of test coverage, but has little proactive effect on making the design more testable.

Large Language Models (LLMs) have demonstrated remarkable performance across diverse applications, yet they inadvertently absorb spurious correlations from training data, leading to stereotype associations between biased concepts and specific social groups. These associations perpetuate and even amplify harmful social biases, raising significant concerns about fairness, which is a crucial issue in software engineering. To mitigate such biases, prior studies have attempted to project model embeddings into unbiased spaces during inference. However, these approaches have shown limited effectiveness due to their weak alignment with downstream social biases. Inspired by the observation that concept cognition in LLMs is primarily represented through a linear associative memory mechanism, where key-value mapping occurs in the MLP layers, we posited that biased concepts and social groups are similarly encoded as entity (key) and information (value) pairs, which can be manipulated to promote fairer associations. To this end, we propose Fairness Mediator (FairMed), an effective and efficient bias mitigation framework that neutralizes stereotype associations. Our framework comprises two main components: a stereotype association prober and an adversarial debiasing neutralizer. The prober captures stereotype associations encoded within MLP layer activations by employing prompts centered around biased concepts (keys) to detect the emission probabilities for social groups (values). Subsequently, the adversarial debiasing neutralizer intervenes in MLP activations during inference to equalize the association probabilities among different social groups. Extensive experiments across nine protected attributes show that our FairMed significantly outperforms state-of-the-art methods in effectiveness, achieving average bias reductions of up to 84.42

Engineering disciplines have often experienced learning curves in the responsibility of engineers, as legal measures and professional responsibility were often developed significantly later than the technical discipline’s methods and tools. Understanding ethical issues related to their work developed in many disciplines often as a consequence of experienced incidents.