Software Engineering and Formal Methods 1st edition by Frank de Boer, Antonio Cerone ISBN 3030587681 9783030587680

Software Engineering and Formal Methods 1st edition by Frank de Boer, Antonio Cerone – Ebook PDF Instant Download/Delivery: 3030587681, 978-3030587680
Full dowload Software Engineering and Formal Methods 1st Edition after payment

Product details:

ISBN 10:  3030587681
ISBN 13: 978-3030587680
Author:      Frank de Boer, Antonio Cerone

Software Engineering and Formal Methods 1st Table of contents:

1. Multi-purpose Syntax Definition with SDF3

• Context: SDF3 (Syntax Definition Formalism) is a framework for defining programming languages and syntax-directed translation rules. This topic likely discusses how to use SDF3 for creating multiple language definitions or syntax specifications that can be used for different purposes such as compilers, interpreters, or language analyzers.

2. Finding and Fixing a Mismatch Between the Go Memory Model and Data-Race Detector

• Context: Go’s memory model defines how variables are shared and accessed concurrently across goroutines. A data-race detector finds situations where variables are read and written simultaneously in an unsafe manner. This research might focus on discrepancies between Go’s memory model and existing data-race detection tools, proposing methods to resolve these mismatches for better concurrency safety.

3. Formal Verification of COLREG-Based Navigation of Maritime Autonomous Systems

• Context: COLREG (International Regulations for Preventing Collisions at Sea) defines maritime navigation rules. Formal verification ensures that autonomous maritime systems (such as drones or ships) adhere to COLREG regulations. This topic likely focuses on mathematically proving that the system’s navigation logic complies with these rules, using formal verification techniques.

4. End-to-End Verification of Initial and Transition Properties of GR(1) Designs in SPARK

• Context: GR(1) is a fragment of linear temporal logic (LTL) used for specifying control systems. SPARK is a formal programming language designed for high-assurance software. This paper likely explores techniques for verifying properties of GR(1) specifications (e.g., initial and transition properties) in SPARK to ensure correctness and safety in system behavior.

5. Affine Systems of ODEs in Isabelle/HOL for Hybrid-Program Verification

• Context: Hybrid systems combine continuous dynamics (modeled by ordinary differential equations, ODEs) with discrete events (such as state transitions). Isabelle/HOL is a proof assistant for higher-order logic. This topic likely involves using Isabelle/HOL to verify properties of hybrid programs that include affine ODEs, ensuring their correctness under different system conditions.

6. Interoperability and Integration Testing Methods for IoT Systems: A Systematic Mapping Study

• Context: The Internet of Things (IoT) connects a multitude of devices that must interoperate seamlessly. This study likely provides a systematic review of the methods and tools used for testing the interoperability and integration of IoT systems to ensure they work together as intended.

7. FRed: Conditional Model Checking via Reducers and Folders

• Context: FRed appears to be a model-checking tool or technique that uses “reducers” and “folders” to efficiently verify systems under certain conditions. Model checking is a formal verification method used to automatically check whether a model of a system satisfies given specifications.

8. Difference Verification with Conditions

• Context: This topic likely explores the verification of differences between two systems or versions of a system (e.g., in software updates or revisions) under specific conditions. It could involve comparing system behavior while ensuring that the differences do not introduce errors or violations of desired properties.

9. A Formal Modeling Approach for Portable Low-Level OS Functionality

• Context: Low-level OS functionality is crucial for ensuring hardware-software interaction and performance. This research may propose a formal modeling approach that allows for the specification, verification, and portability of OS features across different hardware platforms.

10. Model-Based Testing Under Parametric Variability of Uncertain Beliefs

• Context: Model-based testing is a technique where models of the system under test are used to generate test cases. This topic likely addresses how to deal with parametric variability (i.e., uncertain parameters) in models, perhaps in scenarios where the system operates under incomplete or uncertain knowledge.

11. Hoare-Style Logic for Unstructured Programs

• Context: Hoare logic is a formal system used to reason about the correctness of programs. This topic may focus on extending Hoare-style logic to handle unstructured programs (i.e., programs without a regular control structure, like goto-based programs), which are harder to analyze and verify.

12. Synthesis of P-Stable Abstractions

• Context: P-stable abstractions might refer to abstractions that remain stable with respect to certain properties or behaviors in a system. This topic likely discusses techniques for automatically generating abstractions that are robust and can be used in the verification or synthesis of systems with desired properties.

13. Runtime Verification of Contracts with Themulus

• Context: Runtime verification involves checking properties of a system while it is running. Themulus is likely a tool for checking contracts (e.g., formal specifications or properties) at runtime. This topic focuses on ensuring that systems adhere to their contracts during execution.

14. Sound C Code Decompilation for a Subset of x86-64 Binaries

• Context: Decompilation is the process of converting machine code (e.g., x86-64 binaries) back into human-readable source code. This topic focuses on developing methods to decompile C code from a subset of x86-64 binaries and ensuring that the decompiled code is correct (sound) and faithful to the original program.

15. Statically Checking REST API Consumers

• Context: REST APIs are commonly used for communication between systems. This research likely addresses methods for statically analyzing code that consumes REST APIs (i.e., making requests to RESTful services) to ensure that the API calls are correct and well-formed before runtime.

16. A Layered Implementation of DR-BIP Supporting Run-Time Monitoring and Analysis

• Context: DR-BIP (Dynamic Reconfiguration for BIP) is a framework for modeling and verifying systems with dynamic reconfiguration. This research likely focuses on an implementation of DR-BIP that supports runtime monitoring and analysis, allowing for the verification and adaptation of systems during execution.

17. Formal Verification of Human-Robot Interaction in Healthcare Scenarios

• Context: Human-robot interaction (HRI) in healthcare settings is critical for safety and efficiency. This topic focuses on formal methods to verify the correctness and safety of robot behaviors when interacting with humans in healthcare scenarios, ensuring compliance with regulations and safety protocols.

People also search for Software Engineering and Formal Methods 1st :

international conference on software engineering and formal methods
advantages and disadvantages of formal methods in software engineering
verification and formal methods in software engineering
formal methods and dependability in software engineering
software formal methods

Tags:

Frank de Boer,Antonio Cerone,Software,Engineering,Formal,Methods 1st