Using induction and rewriting to verify and complete parameterized specifications

The generation of traceability links or traceability matrices is vital to many software engineering activities. It is also person-power intensive, time-consuming, error-prone, and lacks tool support. The activities that require traceability information include, but are not limited to, risk analysis, impact analysis, criticality assessment, test coverage analysis, and verification and validation of software systems. Information Retrieval (IR) techniques have been shown to assist with the automated generation of traceability links by reducing the time it takes to generate the traceability mapping. Researchers have applied techniques such as Latent Semantic Indexing (LSI), vector space retrieval, and probabilistic IR and have enjoyed some success. This paper concentrates on examining issues not previously widely studied in the context of traceability: the importance of the vocabulary base used for tracing and the evaluation and assessment of traceability mappings and methods using secondary measures. We examine these areas and perform empirical studies to understand the importance of each to the traceability of software engineering artifacts.

The research objective of this work is to develop an approach to reach inter-enterprise interoperability and to test its achievement using practices from the software engineering process. Four fundamental activities are identified in the software process: software specification, software development, software validation and software evolution [1]. In this work, the interoperability requirements specification is based on measurable and non-measurable quality characteristics. It is also demonstrated that the improvement proposed in software specification activity will have positive impact on the software development activity. For the validation activity, the definition of a interoperability testing sub-process is made through a two-step decomposition: one step to verify measurable requirements and another to validate non-measurable ones.KeywordsEnterprise interoperabilitySoftware specificationSoftware validationService Oriented ArchitecturesBusiness Process Modeling

BackgroundBioinformatics software quality assurance is essential in genomic medicine. Systematic verification and validation of bioinformatics software is difficult because it is often not possible to obtain a realistic "gold standard" for systematic evaluation. Here we apply a technique that originates from the software testing literature, namely Metamorphic Testing (MT), to systematically test three widely used short-read sequence alignment programs.ResultsMT alleviates the problems associated with the lack of gold standard by checking that the results from multiple executions of a program satisfy a set of expected or desirable properties that can be derived from the software specification or user expectations. We tested BWA, Bowtie and Bowtie2 using simulated data and one HapMap dataset. It is interesting to observe that multiple executions of the same aligner using slightly modified input FASTQ sequence file, such as after randomly re-ordering of the reads, may affect alignment results. Furthermore, we found that the list of variant calls can be affected unless strict quality control is applied during variant calling.ConclusionThorough testing of bioinformatics software is important in delivering clinical genomic medicine. This paper demonstrates a different framework to test a program that involves checking its properties, thus greatly expanding the number and repertoire of test cases we can apply in practice.

Well-Definedness is important for many formal methods. In B and Event-B it ensures that certain kinds of errors (e.g., division by 0) cannot appear and that proof rules based on two-valued logic are sound. For validation tools such as ProB, well-definedness is important for constraint solving. B and Event-B establish well-definedness by generating dedicated proof obligations (POs). Unfortunately, the standard provers are not always very good at discharging them. In this paper, we present a new integrated technique to simultaneously generate and discharge well-definedness POs. The implementation contains a dedicated rule-based prover written in Prolog supporting B, Event-B and extensions thereof for data validation. We show that the generation and discharging is significantly faster than existing implementations in rodin and Atelier-B and that a large number of POs are automatically discharged. The POs are fine-grained enough to provide precise source code feedback, and allow inspection of problematic POs within various editors.

Distributing the Workload in a Lazy Theorem-Prover

Many regard widespread development and reuse of software components as one of the next biggest phenomena for software. However, widespread reuse of a software component with poor quality may lead to disasters. Improper reuse of software components of good quality may also be disastrous. Testing and quality assurance is therefore critical for both software components and component-based software systems. This tutorial provides an in-depth look at the technical issues, challenges, managerial aspects, and needs in testing of components and systems. Moreover, this tutorial reports on the recent advances and research efforts in developing new solutions to solve those problems and meet those needs, from the perspectives of component-based software engineering. The tutorial will discuss the state-of-the-art practice, issues, and challenges, new solutions and research efforts in third-party component testing, component-based program validation, and test automation. The targeted audience includes technical managers, software testing engineers, quality assurance people, and development engineers who are working on component-based software projects. The tutorial will be useful for professionals, researchers, and students interested in understanding the general concepts and methods in component testing and component-based software validation. This tutorial assumes that participants have a general understanding of software engineering and software testing methods, and have some working experience in software development and validation.

In software validation, regression testing aims to check the absence of regression faults in new releases of a software system. Typically, test cases used in regression testing are executed during a limited amount of time and are selected to check a given set of user requirements. When testing large systems, the number of regression tests grows quickly over the years, and yet the available time slot stays limited. In order to overcome this problem, an approach known as test suite reduction (TSR), has been developed in software engineering to select a smallest subset of test cases, so that each requirement remains covered at least once. However solving the TSR problem is difficult as the underlying optimization problem is NP-hard, but it is also crucial for vendors interested in reducing the time to market of new software releases. In this paper, we address regression testing and TSR with Constraint Programming (CP). More specifically, we propose new CP models to solve TSR that exploit global constraints, namely NVALUE and GCC. We reuse a set of preprocessing rules to reduce a priori each instance, and we introduce a structureaware search heuristic. We evaluated our CP models and proposed improvements against existing approaches, including a simple greedy approach and MINTS, the state-of-theart tool of the software engineering community. Our experiments show that CP outperforms both the greedy approach and MINTS when it is interfaced with MiniSAT, in terms of percentage of reduction and execution time. When MINTS is interfaced with CPLEX, we show that our CP model performs better only on percentage of reduction. Finally, by working closely with validation engineers from Cisco Systems, Norway, we integrated our CP model into an industrial regression testing process.

In this paper we report the outcomes of the 1st and 2nd edition of the International Workshop on Gamification in Software Development, Verification, and Validation (Gamify 2022 and Gamify 2023) which were held as part of the 30th and 31st ACM Joint European Software Engineering Conference and Symposium on the Foundations of Software Engineering (ESEC/FSE 2022, in Singapore, November 17, 2022 and ESEC/FSE 2023, online workshop, December 4, 2023).

Different calculi of partial or three-valued predicates have been used and studied by several authors in the context of software specification, development and validation. This paper offers a critical survey on the development of three-valued logics based on such calculi.

A model of security is presented which integrates notions of confidentiality and integrity. This model has been developed to fulfil the needs of the RSRE SMITE project because existing modeling approaches proved to be inadequate. The authors introduce the model and subsequently compare and contrast it with existing approaches. Both an inductive confidentiality property and a noninductive integrity property have been modeled. To successfully utilize the second property, the authors have used an approach whereby the noninductiveness is absent in the model, but appears in proof obligations on refinement. >

Event-B is a formal modelling method which is claimed to be suitable for diverse modelling domains, such as reactive systems and sequential program development. This claim hinges on the fact that any particular model has an appropriate semantics. In Event-B this semantics is provided implicitly by proof obligations associated with a model. There is no fixed semantics though. In this article we argue that this approach is beneficial to modelling because we can use similar proof obligations across a variety of modelling domains. By way of two examples we show how similar proof obligations are linked to different semantics. A small set of proof obligations is thus suitable for a whole range of modelling problems in diverse modelling domains.KeywordsAbstract EventSequential ProgramProof ObligationAbstract MachineConcrete EventThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

The engineering of software systems is supported by tools in different phases of the software development. The integration of these tools is crucial to assure the trace ability of existing models and artifacts, and to support the automation of critical software development phases such as software testing and validation. In particular, the integration of novel software quality assurance tools into existing environments must be performed in a way that minimizes its impact on existing software process, while the benefits of the tool are leveraged. This guarantees the adoption of new methodologies with minimal interference in existing production workflow. In this paper we discuss our experience in integrating a model-driven software testing tool developed within SIEMENS with a widely-adopted model-driven design tool. In particular, we establish a set of design principles from the lessons learned in this integration. We conclude showing a design that prioritizes data integration over control and presentation that achieves a high degree of tool integration while minimizing the integration development effort.

The Lunar Surface Systems (LSS) Software Workshop was held March 2009 in Houston, Texas to explore options and trades for software design concepts that could be used in lunar habitat assets, mobile assets, and lunar infrastructure. The workshop explored specific challenges for LSS software architectural support including autonomous operations, automation consistent with human-robotic surface operations concepts, and international partnering. It also addressed novel approaches to the ongoing software challenges of requirements, integrating systems and software engineering, verification and validation, and reliability for long-lived systems. The workshop was sponsored by NASA’s Constellation Lunar Surface Systems Project, and Software and Avionics Integration Office (SAvIO). The recommendations of the workshop informed further ongoing design studies and technology prioritizations which remain relevant even as NASA redefines its path towards the longrange goal of human exploration of the Martian surface. This paper summarizes the nonsensitive technical material and recommendations of the workshop.

Human interaction and behavior are at the core of most software engineering (SE) activities. Furthermore, software is created to fulfill human stakeholders' needs and wishes, and the resulting software is ultimately utilized (directly or indirectly) by human users. Today's software is highly intertwined with our lives, and it possesses an increasing ability to act and influence us. Besides the obvious example of self-driving cars and their potential harmfulness, more mundane software such as social networks may introduce bias, break privacy preferences, lead to digital addiction, etc. Additionally, the SE process itself is highly affected by ethical issues, such as diversity and business ethics. This paper introduces ethics-aware SE, a version of SE in which the ethical values of the stakeholders (including developers and users) are captured, analyzed, and reflected in software specifications and in the SE processes.

Large Language Models (LLM) are reshaping the field of Software Engineering (SE). They enable innovative methods for executing many SE tasks, including automation of entire process of Software Development Life Cycle (SDLC). However, only a limited number of existing works have thoroughly explored the potential of LLM based AI agents to automate the entire lifecycle in SE. In this paper, we demonstrate the success of our initial efforts in automating the entire lifecycle autonomously based on given software specification as input, which has shown remarkable efficiency and significantly reduced development time. Our preliminary results suggest that the careful implementation of AI agents can enhance the development lifecycle. We aim to streamline the SDLC by integrating all phases into an AI-driven chat interface, enhancing efficiency and transparency. Furthermore, we seek to enhance collaboration, creating an environment where stakeholders from various backgrounds can contribute, review, and refine ideas and requirements in real-time. This forward-looking direction guarantees to redefine the paradigms of SE and also make software creation more inclusive, collaborative, and efficient.