Alwyn E. Goodloe
Research Subjects
Alwyn E. Goodloe has a total of 13 co-authors. Here are the top co-authors by number of shared publications:
- Ivan Perez
KBR @ NASA Ames Research Center
4 shared publications - Frank Dedden
System F Computing
1 shared publication - Jonathan Laurent
École Normale Supérieure
1 shared publication - Klaus Havelund
California Institute of Technology
1 shared publication - Lee Pike
Groq, Inc
1 shared publication - Lee Pike
Galois, Inc
1 shared publication
Latest Publications
- Open Access
- 13 September 2024
- Published by Springer Nature
- p. 469-491
Runtime Verification in Real-Time with the Copilot Language: A Tutorial
Ultra-critical systems require high-level assurance, which cannot always be guaranteed at compile time. The use of runtime verification (RV) enables monitoring of these systems during runtime, to detect illegal states early and limit their potential consequences. This paper is a tutorial on RV using Copilot, an open-source runtime verification framework actively used by NASA to carry out experiments with robots and unmanned aerial vehicles. Copilot monitors are written in a compositional, stream-based language, which the framework automatically translates into real-time C code that satisfies static memory requirements suitable to run on embedded hardware. Copilot includes multiple libraries that extend the core functionality with higher-level constructs, Boyer-Moore majority voting, and a variety of Temporal Logics (TL), resulting in robust, high-level specifications that are easier to understand than their traditional counterparts.
- 13 September 2024
- Published by Springer Nature
- p. 469-491
Open AccessRuntime Verification in Real-Time with the Copilot Language: A Tutorial
Ultra-critical systems require high-level assurance, which cannot always be guaranteed at compile time. The use of runtime verification (RV) enables monitoring of these systems during runtime, to detect illegal states early and limit their potential consequences. This paper is a tutorial on RV using Copilot, an open-source runtime verification framework actively used by NASA to carry out experiments with robots and unmanned aerial vehicles. Copilot monitors are written in a compositional, stream-based language, which the framework automatically translates into real-time C code that satisfies static memory requirements suitable to run on embedded hardware. Copilot includes multiple libraries that extend the core functionality with higher-level constructs, Boyer-Moore majority voting, and a variety of Temporal Logics (TL), resulting in robust, high-level specifications that are easier to understand than their traditional counterparts.
- 2 April 2024
- Published by Institute of Electrical and Electronics Engineers (IEEE) in Computer
- Vol. 57 (4) , 37-45
High-Integrity Runtime Verification
We introduce the concept of runtime verification that can be a critical element of an assurance case by guaranteeing that specifications hold at runtime. We show how runtime verification can be a trustworthy approach to assuring that critical systems are safe and dependable.
- 2 April 2024
- Published by Institute of Electrical and Electronics Engineers (IEEE) in Computer
- Vol. 57 (4) , 37-45
High-Integrity Runtime Verification
We introduce the concept of runtime verification that can be a critical element of an assurance case by guaranteeing that specifications hold at runtime. We show how runtime verification can be a trustworthy approach to assuring that critical systems are safe and dependable.
- Open Access
- 30 August 2023
- Published by Association for Computing Machinery (ACM) in Proceedings of the ACM on Programming Languages
- Vol. 7 (ICFP) , 305-321
Trustworthy Runtime Verification via Bisimulation (Experience Report)
When runtime verification is used to monitor safety-critical systems, it is essential that monitoring code behaves correctly. The Copilot runtime verification framework pursues this goal by automatically generating C monitor programs from a high-level DSL embedded in Haskell. In safety-critical domains, every piece of deployed code must be accompanied by an assurance argument that is convincing to human auditors. However, it is difficult for auditors to determine with confidence that a compiled monitor cannot crash and implements the behavior required by the Copilot semantics. In this paper we describe CopilotVerifier, which runs alongside the Copilot compiler, generating a proof of correctness for the compiled output. The proof establishes that a given Copilot monitor and its compiled form produce equivalent outputs on equivalent inputs, and that they either crash in identical circumstances or cannot crash. The proof takes the form of a bisimulation broken down into a set of verification conditions. We leverage two pieces of SMT-backed technology: the Crucible symbolic execution library for LLVM and the What4 solver interface library. Our results demonstrate that dramatically increased compiler assurance can be achieved at moderate cost by building on existing tools. This paves the way to our ultimate goal of generating formal assurance arguments that are convincing to human auditors.
- 30 August 2023
- Published by Association for Computing Machinery (ACM) in Proceedings of the ACM on Programming Languages
- Vol. 7 (ICFP) , 305-321
Open AccessTrustworthy Runtime Verification via Bisimulation (Experience Report)
When runtime verification is used to monitor safety-critical systems, it is essential that monitoring code behaves correctly. The Copilot runtime verification framework pursues this goal by automatically generating C monitor programs from a high-level DSL embedded in Haskell. In safety-critical domains, every piece of deployed code must be accompanied by an assurance argument that is convincing to human auditors. However, it is difficult for auditors to determine with confidence that a compiled monitor cannot crash and implements the behavior required by the Copilot semantics. In this paper we describe CopilotVerifier, which runs alongside the Copilot compiler, generating a proof of correctness for the compiled output. The proof establishes that a given Copilot monitor and its compiled form produce equivalent outputs on equivalent inputs, and that they either crash in identical circumstances or cannot crash. The proof takes the form of a bisimulation broken down into a set of verification conditions. We leverage two pieces of SMT-backed technology: the Crucible symbolic execution library for LLVM and the What4 solver interface library. Our results demonstrate that dramatically increased compiler assurance can be achieved at moderate cost by building on existing tools. This paves the way to our ultimate goal of generating formal assurance arguments that are convincing to human auditors.
- 18 August 2023
- Published by Institute of Electrical and Electronics Engineers (IEEE) in Computer
- Vol. 56 (9) , 83-88
Assuring Safety-Critical Machine Learning-Enabled Systems: Challenges and Promise
We outline how assurance processes work for conventional systems and identify the primary difficulty in applying them to machine learning-enabled systems. We then outline a path forward, identifying where considerable research remains.
- 18 August 2023
- Published by Institute of Electrical and Electronics Engineers (IEEE) in Computer
- Vol. 56 (9) , 83-88
Assuring Safety-Critical Machine Learning-Enabled Systems: Challenges and Promise
We outline how assurance processes work for conventional systems and identify the primary difficulty in applying them to machine learning-enabled systems. We then outline a path forward, identifying where considerable research remains.
- Open Access
- 7 May 2020
- Published by Cambridge University Press (CUP) in Journal of Functional Programming
- Vol. 30
Fault-tolerant functional reactive programming (extended version)
Highly critical application domains, like medicine and aerospace, require the use of strict design, implementation, and validation techniques. Functional languages have been used in these domains to develop synchronous dataflow programming languages for reactive systems. Causal stream functions and functional reactive programming (FRP) capture the essence of those languages in a way that is both elegant and robust. To guarantee that critical systems can operate under high stress over long periods of time, these applications require clear specifications of possible faults and hazards, and how they are being handled. Modeling failure is straightforward in functional languages, and many functional reactive abstractions incorporate support for failure or termination. However, handling unknown types of faults , and incorporating fault tolerance into FRP, requires a different construction and remains an open problem. This work demonstrates how to extend an existing functional reactive framework with fault tolerance features. At value level, we tag faulty signals with reliability and probability information and use random testing to inject faults and validate system properties encoded in temporal logic. At type level, we tag components with the kinds of faults they may exhibit and use type-level programming to obtain compile-time guarantees of key aspects of fault tolerance. Our approach is powerful enough to be used in systems with realistic complexity, and flexible enough to be used to guide system analysis and design, validate system properties in the presence of faults, perform runtime monitoring, and study the effects of different fault tolerance mechanisms.
- 7 May 2020
- Published by Cambridge University Press (CUP) in Journal of Functional Programming
- Vol. 30
Open AccessFault-tolerant functional reactive programming (extended version)
Highly critical application domains, like medicine and aerospace, require the use of strict design, implementation, and validation techniques. Functional languages have been used in these domains to develop synchronous dataflow programming languages for reactive systems. Causal stream functions and functional reactive programming (FRP) capture the essence of those languages in a way that is both elegant and robust. To guarantee that critical systems can operate under high stress over long periods of time, these applications require clear specifications of possible faults and hazards, and how they are being handled. Modeling failure is straightforward in functional languages, and many functional reactive abstractions incorporate support for failure or termination. However, handling unknown types of faults , and incorporating fault tolerance into FRP, requires a different construction and remains an open problem. This work demonstrates how to extend an existing functional reactive framework with fault tolerance features. At value level, we tag faulty signals with reliability and probability information and use random testing to inject faults and validate system properties encoded in temporal logic. At type level, we tag components with the kinds of faults they may exhibit and use type-level programming to obtain compile-time guarantees of key aspects of fault tolerance. Our approach is powerful enough to be used in systems with realistic complexity, and flexible enough to be used to guide system analysis and design, validate system properties in the presence of faults, perform runtime monitoring, and study the effects of different fault tolerance mechanisms.
- 1 July 2019
- Published by Institute of Electrical and Electronics Engineers (IEEE)
- Vol. l 19403, 47-54
Fault-Tolerant Swarms
Safety-critical systems must be engineered to be ultra-reliable. Redundancy is critical to tolerate faults that cannot be eliminated by using ruggedized or hardened computing. The use of small satellites allows new missions to be cost-effective, but it also introduces new problems in terms of robustness and fault handling. Apart from the inherent problems of working in a distributed setting, small sats normally lack the redundancy needed to deal with pernicious faults due to constraints on weight, cost and complexity. This paper presents and evaluates fault tolerance mechanisms in a swarm of satellites considered as a whole, making it robust to the failure of one or more satellites. The evaluation is performed with a computer model augmented with the properties desired from our system. We use a random testing tool to inject faults in different parts of our model and evaluate the fault detection and fault correction mechanisms we propose. Our results support the suitability of the proposed fault model, fault tolerant architecture, and evaluation methodology.
- 1 July 2019
- Published by Institute of Electrical and Electronics Engineers (IEEE)
- Vol. l 19403, 47-54
Fault-Tolerant Swarms
Safety-critical systems must be engineered to be ultra-reliable. Redundancy is critical to tolerate faults that cannot be eliminated by using ruggedized or hardened computing. The use of small satellites allows new missions to be cost-effective, but it also introduces new problems in terms of robustness and fault handling. Apart from the inherent problems of working in a distributed setting, small sats normally lack the redundancy needed to deal with pernicious faults due to constraints on weight, cost and complexity. This paper presents and evaluates fault tolerance mechanisms in a swarm of satellites considered as a whole, making it robust to the failure of one or more satellites. The evaluation is performed with a computer model augmented with the properties desired from our system. We use a random testing tool to inject faults in different parts of our model and evaluate the fault detection and fault correction mechanisms we propose. Our results support the suitability of the proposed fault model, fault tolerant architecture, and evaluation methodology.
- Open Access
- 6 January 2018
- Published by Springer Nature in Innovations in Systems and Software Engineering
- Vol. 14 (1) , 47-58
Formal analysis of pilot error with agent safety logic
In this paper, we show that modal logic is a valuable tool for the formal analysis of human errors in aviation safety. We develop a modal logic called agent safety logic (ASL), based on epistemic logic, doxastic logic, and a safety logic grounded in a flight safety manual. We identify a class of human error that has contributed to several aviation incidents involving a specific kind of pilot knowledge failure and formally analyze it. The use of ASL suggests how future avionics might increase aircraft safety.
- 6 January 2018
- Published by Springer Nature in Innovations in Systems and Software Engineering
- Vol. 14 (1) , 47-58
Open AccessFormal analysis of pilot error with agent safety logic
In this paper, we show that modal logic is a valuable tool for the formal analysis of human errors in aviation safety. We develop a modal logic called agent safety logic (ASL), based on epistemic logic, doxastic logic, and a safety logic grounded in a flight safety manual. We identify a class of human error that has contributed to several aviation incidents involving a specific kind of pilot knowledge failure and formally analyze it. The use of ASL suggests how future avionics might increase aircraft safety.
- 5 October 2016
- Published by Springer Nature
- p. 446-460
Challenges in High-Assurance Runtime Verification
- 5 October 2016
- Published by Springer Nature
- p. 446-460
Challenges in High-Assurance Runtime Verification
- 24 August 2013
- Published by Springer Nature in Innovations in Systems and Software Engineering
- Vol. 9 (4) , 235-255
Copilot: monitoring embedded systems
- 24 August 2013
- Published by Springer Nature in Innovations in Systems and Software Engineering
- Vol. 9 (4) , 235-255
Copilot: monitoring embedded systems