Software engineering aspects

Aloha and Welcome to Hawaii and SEAMS-2011, the 6th International Symposium on Software Engineering for Adaptive and Self-Managing Systems, an ICSE co-located event. An increasingly important requirement for a software-based system is the ability to self-manage by adapting itself at run time to handle changing user needs, system intrusions or faults, a changing operational environment, and resource variability. Such a system must configure and reconfigure itself, augment its functionality, continually optimize itself, protect itself, and recover itself, while keeping its complexity hidden from the user. The topic of self-adaptive and self-managing systems has been studied in a large number of specific areas, including software architectures, fault-tolerant computing, robotics, control systems, programming languages, and biologically-inspired computing. The objective of this symposium is to bring together researchers and practitioners from many of these diverse areas to engage in stimulating dialogue regarding the fundamental principles, state of the art, and critical challenges of self-adaptive systems. Specifically, the symposium focuses on the software engineering aspects, including the methods, architectures, algorithms, techniques, and tools that can be used to support dynamic adaptive behavior that includes self-adaptive, self-managing, self-healing, self-optimizing, and self-configuring, and autonomic software. While this year is the first for SEAMS as a symposium, the SEAMS community has been steadily growing for the past 6 years, originally starting as an ICSE Workshop. It is particularly noteworthy that SEAMS has continued to attract and retain researchers and practitioners from a variety of adaptive systems-related areas, including interesting application areas that pose wonderful research challenges for the community. We received 77 submissions, where 21 full papers and 5 position papers were accepted for inclusion in the symposium. Each paper was reviewed by at least 3 program committee members. In short, the quality of the submissions was quite high, with a tough selection process, all of which have yielded a high-quality program. This year we have a program that illustrates on the one hand, the maturity of the field with sessions on programming language, modeling, and framework support for the development of adaptive systems, while on the other hand, we are clearly making significant advances in techniques that provide true run-time support for adaptive activities, such as monitoring, automatic reconfiguration, and service composition. We also have a great collection of position papers that describe exciting and promising work for the adaptive systems area. As adaptive systems become more prevalent, particularly in high-assurance applications, the need for explicitly addressing assurance in adaptive systems becomes paramount. It has become clear that many of the traditional software engineering techniques cannot be directly applied to adaptive systems due to the added level of complexity posed by the run-time requirements. As such, this year, we have a special focus on Assurance for Adaptive Systems. We launch this focus with a keynote by Professor Carlo Ghezzi (Politecnico di Milano) who will share his work and vision in this area. We follow it by a paper session comprising several papers that describe assurance techniques ranging from testing to model-driven techniques. Finally, Professor David Garlan (Carnegie Mellon University) will moderate a session comprising several researchers working on assurance for adaptive systems who will provide insight to the research challenges in this area and a preview of promising future directions.

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.

An amalgamation of cognitive aspects in software engineering: A content analysis

There has long been a close association between research in software engineering and the design of programming languages. Part of the IMPACT project involves an exploration of the interrelations of these two fields and documentation in a report of how fundamental research in software engineering has been a valuable resource for programming language features commonly used today. The resulting report investigates the relationship by considering features in currently used languages, including exceptions, control and data abstractions, types, inheritance, concurrency and visualization mechanisms.This paper, exerpted from the report, focuses on the influence of software engineering research on the development of exceptions. The paper demonstrates that there is a symbiotic relationship between software engineering research and the design of exception handing in programming languages. Publication of these partial results is aimed at soliciting feedback and comments from both the programming languages and software engineering communities.

Over the past decade, there have been increasing expectations and pressures placed on health care providers to deliver more efficient, quality, and safe health care services. As a result, this shifts the balance between supply‐and‐demand of health care services. It also brings about new challenges for health care professionals' capabilities to deliver safe and quality care in a timely manner. There are significant opportunities to exploit information and communications technology and transform how health care service is provided. Connected Health is one such transformation for health care management and changes in health care practice. However, the field of Connected Health is still in its infancy. This Special Issue in Software Engineering for Connected Health begins to address this and presents 5 quality contributions to demonstrate how software engineering research plays an important role in Connected Health research. These contributions also identify the limitations of the existing theories and to develop new or revised theories of Software Engineering for Connected Health.

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.

This work is a contribution of Artificial Intelligence to Software Engineering. We present a comprehensive approach to metamodel instantiation using CSP. The generation of models which conform to a given metamodel is a crucial issue in Software Engineering, especially when it comes to produce a variate and large dataset of relevant models to test model transformations or to properly design new metamodels. We define an original constraint modeling of the problem of generating a model conform to a metamodel, also taking into account its additional OCL constraints. The generation process we describe appears to be quicker, more efficient and flexible than any other state-of-the-art approach.

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.

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

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.