Programming Journal, Volume 7, Issue 2: "Out-of-Things Debugging: A ..."
Out-of-Things Debugging: A Live Debugging Approach for Internet of Things
Carlos Rojas Castillo, Matteo Marra, Jim Bauwens, and Elisa Gonzalez Boix
(Vrije Universiteit Brussel, Belgium)
Context Internet of Things (IoT) has become an important kind of distributed systems thanks to the wide-spread of cheap embedded devices equipped with different networking technologies. Although ubiquitous, developing IoT systems remains challenging.
Inquiry A recent field study with 194 IoT developers identifies debugging as one of the main challenges faced when developing IoT systems. This comes from the lack of debugging tools taking into account the unique properties of IoT systems such as non-deterministic data, and hardware restricted devices. On the one hand, offline debuggers allow developers to analyse post-failure recorded program information, but impose too much overhead on the devices while generating such information. Furthermore, the analysis process is also time-consuming and might miss contextual information relevant to find the root cause of bugs. On the other hand, online debuggers do allow debugging a program upon a failure while providing contextual information (e.g., stack trace). In particular, remote online debuggers enable debugging of devices without physical access to them. However, they experience debugging interference due to network delays which complicates bug reproducibility, and have limited support for dynamic software updates on remote devices.
Approach This paper proposes out-of-things debugging, an online debugging approach especially designed for IoT systems. The debugger is always-on as it ensures constant availability to for instance debug post-deployment situations. Upon a failure or breakpoint, out-of-things debugging moves the state of a deployed application to the developer’s machine. Developers can then debug the application locally by applying operations (e.g., step commands) to the retrieved state. Once debugging is finished, developers can commit bug fixes to the device through live update capabilities. Finally, by means of a fine-grained flexible interface for accessing remote resources, developers have full control over the debugging overhead imposed on the device, and the access to device hardware resources (e.g., sensors) needed during local debugging.
Knowledge Out-of-things debugging maintains good properties of remote debugging as it does not require physical access to the device to debug it, while reducing debugging interference since there are no network delays on operations (e.g., stepping) issued on the debugger since those happen locally. Furthermore, device resources are only accessed when requested by the user which further mitigates overhead and opens avenues for mocking or simulation of non-accessed resources.
Grounding We implemented an out-of-things debugger as an extension to a WebAssembly Virtual Machine and benchmarked its suitability for IoT. In particular, we compared our solution to remote debugging alternatives based on metrics such as network overhead, memory usage, scalability, and usability in production settings. From the benchmarks, we conclude that our debugger exhibits competitive performance in addition to confining overhead without sacrificing debugging convenience and flexibility.
Importance Out-of-things debugging enables debugging of IoT systems by means of classical online operations (e.g., stepwise execution) while addressing IoT-specific concerns (e.g., hardware limitations). We show that having the debugger always-on does not have to come at cost of performance loss or increased overhead but instead can enforce a smooth-going and flexible debugging experience of IoT systems.
@Article{Programming Journal, Volume23p5,
author = {Carlos Rojas Castillo and Matteo Marra and Jim Bauwens and Elisa Gonzalez Boix},
title = {Out-of-Things Debugging: A Live Debugging Approach for Internet of Things},
journal = {},
volume = {},
number = {},
articleno = {5},
numpages = {33},
doi = {10.22152/programming-journal.org/2023/7/5},
year = {2023},
}
Publisher's Version
Programming Journal, Volume 7, Issue 2: "A Theory of Composing Protocols ..."
A Theory of Composing Protocols
Laura Bocchi, Dominic Orchard, and A. Laura Voinea
(University of Kent, UK; University of Cambridge, UK; University of Glasgow, UK)
In programming, protocols are everywhere. Protocols describe the pattern of interaction (or communication) between software systems, for example, between a user-space program and the kernel or between a local application and an online service. Ensuring conformance to protocols avoids a significant class of software errors. Subsequently, there has been a lot of work on verifying code against formal protocol specifications. The pervading approaches focus on distributed settings involving parallel composition of processes within a single monolithic protocol description. However we observe that, at the level of a single thread/process, modern software must often implement a number of clearly delineated protocols at the same time which become dependent on each other, e.g., a banking API and one or more authentication protocols. Rather than plugging together modular protocol-following components, the code must re-integrate multiple protocols into a single component.
We address this concern of combining protocols via a novel notion of 'interleaving' composition for protocols described via a process algebra. User-specified, domain-specific constraints can be inserted into the individual protocols to serve as 'contact points' to guide this composition procedure, which outputs a single combined protocol that can be programmed against. Our approach allows an engineer to then program against a number of protocols that have been composed (re-integrated), reflecting the true nature of applications that must handle multiple protocols at once.
We prove various desirable properties of the composition, including behaviour preservation: that the composed protocol implements the behaviour of both component protocols. We demonstrate our approach in the practical setting of Erlang, with a tool implementing protocol composition that both generates Erlang code from a protocol and generates a protocol from Erlang code. This tool shows that, for a range of sample protocols (including real-world examples), a modest set of constraints can be inserted to produce a small number of candidate compositions to choose from.
As we increasingly build software interacting with many programs and subsystems, this new perspective gives a foundation for improving software quality via protocol conformance in a multi-protocol setting.
@Article{Programming Journal, Volume23p6,
author = {Laura Bocchi and Dominic Orchard and A. Laura Voinea},
title = {A Theory of Composing Protocols},
journal = {},
volume = {},
number = {},
articleno = {6},
numpages = {76},
doi = {10.22152/programming-journal.org/2023/7/6},
year = {2023},
}
Publisher's Version
Artifact Reusable
Programming Journal, Volume 7, Issue 2: "Revisiting Language Support ..."
Revisiting Language Support for Generic Programming: When Genericity Is a Core Design Goal
Benjamin Chetioui, Jaakko Järvi, and Magne Haveraaen
(University of Bergen, Norway; University of Turku, Finland)
- Context
- Generic programming, as defined by Stepanov, is a methodology for writing efficient and reusable algorithms by considering only the required properties of their underlying data types and operations. Generic programming has proven to be an effective means of constructing libraries of reusable software components in languages that support it. Generics-related language design choices play a major role in how conducive generic programming is in practice.
- Inquiry
- Several mainstream programming languages (e.g. Java and ) were first created without generics; features to support generic programming were added later, gradually. Much of the existing literature on supporting generic programming focuses thus on retrofitting generic programming into existing languages and identifying related implementation challenges. Is the programming experience significantly better, or different when programming with a language designed for generic programming without limitations from prior language design choices?
- Approach
- We examine Magnolia, a language designed to embody generic programming. Magnolia is representative of an approach to language design rooted in algebraic specifications. We repeat a well-known experiment, where we put Magnolia’s generic programming facilities under scrutiny by implementing a subset of the Boost Graph Library, and reflect on our development experience.
- Knowledge
- We discover that the idioms identified as key features for supporting Stepanov-style generic programming in the previous studies and work on the topic do not tell a full story. We clarify which of them are more of a means to an end, rather than fundamental features for supporting generic programming. Based on the development experience with Magnolia, we identify variadics as an additional key feature for generic programming and point out limitations and challenges of genericity by property.
- Grounding
- Our work uses a well-known framework for evaluating the generic programming facilities of a language from the literature to evaluate the algebraic approach through Magnolia, and we draw comparisons with well-known programming languages.
- Importance
- This work gives a fresh perspective on generic programming, and clarifies what are fundamental language properties and their trade-offs when considering supporting Stepanov-style generic programming. The understanding of how to set the ground for generic programming will inform future language design.
@Article{Programming Journal, Volume23p4,
author = {Benjamin Chetioui and Jaakko Järvi and Magne Haveraaen},
title = {Revisiting Language Support for Generic Programming: When Genericity Is a Core Design Goal},
journal = {},
volume = {},
number = {},
articleno = {4},
numpages = {39},
doi = {10.22152/programming-journal.org/2023/7/4},
year = {2023},
}
Publisher's Version
Programming Journal, Volume 7, Issue 2: "Out-of-Things Debugging: A ..."
Out-of-Things Debugging: A Live Debugging Approach for Internet of Things
Carlos Rojas Castillo, Matteo Marra, Jim Bauwens, and Elisa Gonzalez Boix
(Vrije Universiteit Brussel, Belgium)
Context Internet of Things (IoT) has become an important kind of distributed systems thanks to the wide-spread of cheap embedded devices equipped with different networking technologies. Although ubiquitous, developing IoT systems remains challenging.
Inquiry A recent field study with 194 IoT developers identifies debugging as one of the main challenges faced when developing IoT systems. This comes from the lack of debugging tools taking into account the unique properties of IoT systems such as non-deterministic data, and hardware restricted devices. On the one hand, offline debuggers allow developers to analyse post-failure recorded program information, but impose too much overhead on the devices while generating such information. Furthermore, the analysis process is also time-consuming and might miss contextual information relevant to find the root cause of bugs. On the other hand, online debuggers do allow debugging a program upon a failure while providing contextual information (e.g., stack trace). In particular, remote online debuggers enable debugging of devices without physical access to them. However, they experience debugging interference due to network delays which complicates bug reproducibility, and have limited support for dynamic software updates on remote devices.
Approach This paper proposes out-of-things debugging, an online debugging approach especially designed for IoT systems. The debugger is always-on as it ensures constant availability to for instance debug post-deployment situations. Upon a failure or breakpoint, out-of-things debugging moves the state of a deployed application to the developer’s machine. Developers can then debug the application locally by applying operations (e.g., step commands) to the retrieved state. Once debugging is finished, developers can commit bug fixes to the device through live update capabilities. Finally, by means of a fine-grained flexible interface for accessing remote resources, developers have full control over the debugging overhead imposed on the device, and the access to device hardware resources (e.g., sensors) needed during local debugging.
Knowledge Out-of-things debugging maintains good properties of remote debugging as it does not require physical access to the device to debug it, while reducing debugging interference since there are no network delays on operations (e.g., stepping) issued on the debugger since those happen locally. Furthermore, device resources are only accessed when requested by the user which further mitigates overhead and opens avenues for mocking or simulation of non-accessed resources.
Grounding We implemented an out-of-things debugger as an extension to a WebAssembly Virtual Machine and benchmarked its suitability for IoT. In particular, we compared our solution to remote debugging alternatives based on metrics such as network overhead, memory usage, scalability, and usability in production settings. From the benchmarks, we conclude that our debugger exhibits competitive performance in addition to confining overhead without sacrificing debugging convenience and flexibility.
Importance Out-of-things debugging enables debugging of IoT systems by means of classical online operations (e.g., stepwise execution) while addressing IoT-specific concerns (e.g., hardware limitations). We show that having the debugger always-on does not have to come at cost of performance loss or increased overhead but instead can enforce a smooth-going and flexible debugging experience of IoT systems.
@Article{Programming Journal, Volume23p5,
author = {Carlos Rojas Castillo and Matteo Marra and Jim Bauwens and Elisa Gonzalez Boix},
title = {Out-of-Things Debugging: A Live Debugging Approach for Internet of Things},
journal = {},
volume = {},
number = {},
articleno = {5},
numpages = {33},
doi = {10.22152/programming-journal.org/2023/7/5},
year = {2023},
}
Publisher's Version
Programming Journal, Volume 7, Issue 2: "Little Tricky Logic: Misconceptions ..."
Little Tricky Logic: Misconceptions in the Understanding of LTL
Ben Greenman, Sam Saarinen, Tim Nelson, and Shriram Krishnamurthi
(Brown University, USA)
@Article{Programming Journal, Volume23p7,
author = {Ben Greenman and Sam Saarinen and Tim Nelson and Shriram Krishnamurthi},
title = {Little Tricky Logic: Misconceptions in the Understanding of LTL},
journal = {},
volume = {},
number = {},
articleno = {7},
numpages = {37},
doi = {10.22152/programming-journal.org/2023/7/7},
year = {2023},
}
Publisher's Version
Artifact Reusable
Programming Journal, Volume 7, Issue 2: "Revisiting Language Support ..."
Revisiting Language Support for Generic Programming: When Genericity Is a Core Design Goal
Benjamin Chetioui, Jaakko Järvi, and Magne Haveraaen
(University of Bergen, Norway; University of Turku, Finland)
- Context
- Generic programming, as defined by Stepanov, is a methodology for writing efficient and reusable algorithms by considering only the required properties of their underlying data types and operations. Generic programming has proven to be an effective means of constructing libraries of reusable software components in languages that support it. Generics-related language design choices play a major role in how conducive generic programming is in practice.
- Inquiry
- Several mainstream programming languages (e.g. Java and ) were first created without generics; features to support generic programming were added later, gradually. Much of the existing literature on supporting generic programming focuses thus on retrofitting generic programming into existing languages and identifying related implementation challenges. Is the programming experience significantly better, or different when programming with a language designed for generic programming without limitations from prior language design choices?
- Approach
- We examine Magnolia, a language designed to embody generic programming. Magnolia is representative of an approach to language design rooted in algebraic specifications. We repeat a well-known experiment, where we put Magnolia’s generic programming facilities under scrutiny by implementing a subset of the Boost Graph Library, and reflect on our development experience.
- Knowledge
- We discover that the idioms identified as key features for supporting Stepanov-style generic programming in the previous studies and work on the topic do not tell a full story. We clarify which of them are more of a means to an end, rather than fundamental features for supporting generic programming. Based on the development experience with Magnolia, we identify variadics as an additional key feature for generic programming and point out limitations and challenges of genericity by property.
- Grounding
- Our work uses a well-known framework for evaluating the generic programming facilities of a language from the literature to evaluate the algebraic approach through Magnolia, and we draw comparisons with well-known programming languages.
- Importance
- This work gives a fresh perspective on generic programming, and clarifies what are fundamental language properties and their trade-offs when considering supporting Stepanov-style generic programming. The understanding of how to set the ground for generic programming will inform future language design.
@Article{Programming Journal, Volume23p4,
author = {Benjamin Chetioui and Jaakko Järvi and Magne Haveraaen},
title = {Revisiting Language Support for Generic Programming: When Genericity Is a Core Design Goal},
journal = {},
volume = {},
number = {},
articleno = {4},
numpages = {39},
doi = {10.22152/programming-journal.org/2023/7/4},
year = {2023},
}
Publisher's Version
Programming Journal, Volume 7, Issue 2: "Revisiting Language Support ..."
Revisiting Language Support for Generic Programming: When Genericity Is a Core Design Goal
Benjamin Chetioui, Jaakko Järvi, and Magne Haveraaen
(University of Bergen, Norway; University of Turku, Finland)
- Context
- Generic programming, as defined by Stepanov, is a methodology for writing efficient and reusable algorithms by considering only the required properties of their underlying data types and operations. Generic programming has proven to be an effective means of constructing libraries of reusable software components in languages that support it. Generics-related language design choices play a major role in how conducive generic programming is in practice.
- Inquiry
- Several mainstream programming languages (e.g. Java and ) were first created without generics; features to support generic programming were added later, gradually. Much of the existing literature on supporting generic programming focuses thus on retrofitting generic programming into existing languages and identifying related implementation challenges. Is the programming experience significantly better, or different when programming with a language designed for generic programming without limitations from prior language design choices?
- Approach
- We examine Magnolia, a language designed to embody generic programming. Magnolia is representative of an approach to language design rooted in algebraic specifications. We repeat a well-known experiment, where we put Magnolia’s generic programming facilities under scrutiny by implementing a subset of the Boost Graph Library, and reflect on our development experience.
- Knowledge
- We discover that the idioms identified as key features for supporting Stepanov-style generic programming in the previous studies and work on the topic do not tell a full story. We clarify which of them are more of a means to an end, rather than fundamental features for supporting generic programming. Based on the development experience with Magnolia, we identify variadics as an additional key feature for generic programming and point out limitations and challenges of genericity by property.
- Grounding
- Our work uses a well-known framework for evaluating the generic programming facilities of a language from the literature to evaluate the algebraic approach through Magnolia, and we draw comparisons with well-known programming languages.
- Importance
- This work gives a fresh perspective on generic programming, and clarifies what are fundamental language properties and their trade-offs when considering supporting Stepanov-style generic programming. The understanding of how to set the ground for generic programming will inform future language design.
@Article{Programming Journal, Volume23p4,
author = {Benjamin Chetioui and Jaakko Järvi and Magne Haveraaen},
title = {Revisiting Language Support for Generic Programming: When Genericity Is a Core Design Goal},
journal = {},
volume = {},
number = {},
articleno = {4},
numpages = {39},
doi = {10.22152/programming-journal.org/2023/7/4},
year = {2023},
}
Publisher's Version
Programming Journal, Volume 7, Issue 2: "Little Tricky Logic: Misconceptions ..."
Little Tricky Logic: Misconceptions in the Understanding of LTL
Ben Greenman, Sam Saarinen, Tim Nelson, and Shriram Krishnamurthi
(Brown University, USA)
@Article{Programming Journal, Volume23p7,
author = {Ben Greenman and Sam Saarinen and Tim Nelson and Shriram Krishnamurthi},
title = {Little Tricky Logic: Misconceptions in the Understanding of LTL},
journal = {},
volume = {},
number = {},
articleno = {7},
numpages = {37},
doi = {10.22152/programming-journal.org/2023/7/7},
year = {2023},
}
Publisher's Version
Artifact Reusable
Programming Journal, Volume 7, Issue 2: "Out-of-Things Debugging: A ..."
Out-of-Things Debugging: A Live Debugging Approach for Internet of Things
Carlos Rojas Castillo, Matteo Marra, Jim Bauwens, and Elisa Gonzalez Boix
(Vrije Universiteit Brussel, Belgium)
Context Internet of Things (IoT) has become an important kind of distributed systems thanks to the wide-spread of cheap embedded devices equipped with different networking technologies. Although ubiquitous, developing IoT systems remains challenging.
Inquiry A recent field study with 194 IoT developers identifies debugging as one of the main challenges faced when developing IoT systems. This comes from the lack of debugging tools taking into account the unique properties of IoT systems such as non-deterministic data, and hardware restricted devices. On the one hand, offline debuggers allow developers to analyse post-failure recorded program information, but impose too much overhead on the devices while generating such information. Furthermore, the analysis process is also time-consuming and might miss contextual information relevant to find the root cause of bugs. On the other hand, online debuggers do allow debugging a program upon a failure while providing contextual information (e.g., stack trace). In particular, remote online debuggers enable debugging of devices without physical access to them. However, they experience debugging interference due to network delays which complicates bug reproducibility, and have limited support for dynamic software updates on remote devices.
Approach This paper proposes out-of-things debugging, an online debugging approach especially designed for IoT systems. The debugger is always-on as it ensures constant availability to for instance debug post-deployment situations. Upon a failure or breakpoint, out-of-things debugging moves the state of a deployed application to the developer’s machine. Developers can then debug the application locally by applying operations (e.g., step commands) to the retrieved state. Once debugging is finished, developers can commit bug fixes to the device through live update capabilities. Finally, by means of a fine-grained flexible interface for accessing remote resources, developers have full control over the debugging overhead imposed on the device, and the access to device hardware resources (e.g., sensors) needed during local debugging.
Knowledge Out-of-things debugging maintains good properties of remote debugging as it does not require physical access to the device to debug it, while reducing debugging interference since there are no network delays on operations (e.g., stepping) issued on the debugger since those happen locally. Furthermore, device resources are only accessed when requested by the user which further mitigates overhead and opens avenues for mocking or simulation of non-accessed resources.
Grounding We implemented an out-of-things debugger as an extension to a WebAssembly Virtual Machine and benchmarked its suitability for IoT. In particular, we compared our solution to remote debugging alternatives based on metrics such as network overhead, memory usage, scalability, and usability in production settings. From the benchmarks, we conclude that our debugger exhibits competitive performance in addition to confining overhead without sacrificing debugging convenience and flexibility.
Importance Out-of-things debugging enables debugging of IoT systems by means of classical online operations (e.g., stepwise execution) while addressing IoT-specific concerns (e.g., hardware limitations). We show that having the debugger always-on does not have to come at cost of performance loss or increased overhead but instead can enforce a smooth-going and flexible debugging experience of IoT systems.
@Article{Programming Journal, Volume23p5,
author = {Carlos Rojas Castillo and Matteo Marra and Jim Bauwens and Elisa Gonzalez Boix},
title = {Out-of-Things Debugging: A Live Debugging Approach for Internet of Things},
journal = {},
volume = {},
number = {},
articleno = {5},
numpages = {33},
doi = {10.22152/programming-journal.org/2023/7/5},
year = {2023},
}
Publisher's Version
Programming Journal, Volume 7, Issue 2: "Little Tricky Logic: Misconceptions ..."
Little Tricky Logic: Misconceptions in the Understanding of LTL
Ben Greenman, Sam Saarinen, Tim Nelson, and Shriram Krishnamurthi
(Brown University, USA)
@Article{Programming Journal, Volume23p7,
author = {Ben Greenman and Sam Saarinen and Tim Nelson and Shriram Krishnamurthi},
title = {Little Tricky Logic: Misconceptions in the Understanding of LTL},
journal = {},
volume = {},
number = {},
articleno = {7},
numpages = {37},
doi = {10.22152/programming-journal.org/2023/7/7},
year = {2023},
}
Publisher's Version
Artifact Reusable
Programming Journal, Volume 7, Issue 2: "A Theory of Composing Protocols ..."
A Theory of Composing Protocols
Laura Bocchi, Dominic Orchard, and A. Laura Voinea
(University of Kent, UK; University of Cambridge, UK; University of Glasgow, UK)
In programming, protocols are everywhere. Protocols describe the pattern of interaction (or communication) between software systems, for example, between a user-space program and the kernel or between a local application and an online service. Ensuring conformance to protocols avoids a significant class of software errors. Subsequently, there has been a lot of work on verifying code against formal protocol specifications. The pervading approaches focus on distributed settings involving parallel composition of processes within a single monolithic protocol description. However we observe that, at the level of a single thread/process, modern software must often implement a number of clearly delineated protocols at the same time which become dependent on each other, e.g., a banking API and one or more authentication protocols. Rather than plugging together modular protocol-following components, the code must re-integrate multiple protocols into a single component.
We address this concern of combining protocols via a novel notion of 'interleaving' composition for protocols described via a process algebra. User-specified, domain-specific constraints can be inserted into the individual protocols to serve as 'contact points' to guide this composition procedure, which outputs a single combined protocol that can be programmed against. Our approach allows an engineer to then program against a number of protocols that have been composed (re-integrated), reflecting the true nature of applications that must handle multiple protocols at once.
We prove various desirable properties of the composition, including behaviour preservation: that the composed protocol implements the behaviour of both component protocols. We demonstrate our approach in the practical setting of Erlang, with a tool implementing protocol composition that both generates Erlang code from a protocol and generates a protocol from Erlang code. This tool shows that, for a range of sample protocols (including real-world examples), a modest set of constraints can be inserted to produce a small number of candidate compositions to choose from.
As we increasingly build software interacting with many programs and subsystems, this new perspective gives a foundation for improving software quality via protocol conformance in a multi-protocol setting.
@Article{Programming Journal, Volume23p6,
author = {Laura Bocchi and Dominic Orchard and A. Laura Voinea},
title = {A Theory of Composing Protocols},
journal = {},
volume = {},
number = {},
articleno = {6},
numpages = {76},
doi = {10.22152/programming-journal.org/2023/7/6},
year = {2023},
}
Publisher's Version
Artifact Reusable
Programming Journal, Volume 7, Issue 2: "Out-of-Things Debugging: A ..."
Out-of-Things Debugging: A Live Debugging Approach for Internet of Things
Carlos Rojas Castillo, Matteo Marra, Jim Bauwens, and Elisa Gonzalez Boix
(Vrije Universiteit Brussel, Belgium)
Context Internet of Things (IoT) has become an important kind of distributed systems thanks to the wide-spread of cheap embedded devices equipped with different networking technologies. Although ubiquitous, developing IoT systems remains challenging.
Inquiry A recent field study with 194 IoT developers identifies debugging as one of the main challenges faced when developing IoT systems. This comes from the lack of debugging tools taking into account the unique properties of IoT systems such as non-deterministic data, and hardware restricted devices. On the one hand, offline debuggers allow developers to analyse post-failure recorded program information, but impose too much overhead on the devices while generating such information. Furthermore, the analysis process is also time-consuming and might miss contextual information relevant to find the root cause of bugs. On the other hand, online debuggers do allow debugging a program upon a failure while providing contextual information (e.g., stack trace). In particular, remote online debuggers enable debugging of devices without physical access to them. However, they experience debugging interference due to network delays which complicates bug reproducibility, and have limited support for dynamic software updates on remote devices.
Approach This paper proposes out-of-things debugging, an online debugging approach especially designed for IoT systems. The debugger is always-on as it ensures constant availability to for instance debug post-deployment situations. Upon a failure or breakpoint, out-of-things debugging moves the state of a deployed application to the developer’s machine. Developers can then debug the application locally by applying operations (e.g., step commands) to the retrieved state. Once debugging is finished, developers can commit bug fixes to the device through live update capabilities. Finally, by means of a fine-grained flexible interface for accessing remote resources, developers have full control over the debugging overhead imposed on the device, and the access to device hardware resources (e.g., sensors) needed during local debugging.
Knowledge Out-of-things debugging maintains good properties of remote debugging as it does not require physical access to the device to debug it, while reducing debugging interference since there are no network delays on operations (e.g., stepping) issued on the debugger since those happen locally. Furthermore, device resources are only accessed when requested by the user which further mitigates overhead and opens avenues for mocking or simulation of non-accessed resources.
Grounding We implemented an out-of-things debugger as an extension to a WebAssembly Virtual Machine and benchmarked its suitability for IoT. In particular, we compared our solution to remote debugging alternatives based on metrics such as network overhead, memory usage, scalability, and usability in production settings. From the benchmarks, we conclude that our debugger exhibits competitive performance in addition to confining overhead without sacrificing debugging convenience and flexibility.
Importance Out-of-things debugging enables debugging of IoT systems by means of classical online operations (e.g., stepwise execution) while addressing IoT-specific concerns (e.g., hardware limitations). We show that having the debugger always-on does not have to come at cost of performance loss or increased overhead but instead can enforce a smooth-going and flexible debugging experience of IoT systems.
@Article{Programming Journal, Volume23p5,
author = {Carlos Rojas Castillo and Matteo Marra and Jim Bauwens and Elisa Gonzalez Boix},
title = {Out-of-Things Debugging: A Live Debugging Approach for Internet of Things},
journal = {},
volume = {},
number = {},
articleno = {5},
numpages = {33},
doi = {10.22152/programming-journal.org/2023/7/5},
year = {2023},
}
Publisher's Version
Programming Journal, Volume 7, Issue 2: "Little Tricky Logic: Misconceptions ..."
Little Tricky Logic: Misconceptions in the Understanding of LTL
Ben Greenman, Sam Saarinen, Tim Nelson, and Shriram Krishnamurthi
(Brown University, USA)
@Article{Programming Journal, Volume23p7,
author = {Ben Greenman and Sam Saarinen and Tim Nelson and Shriram Krishnamurthi},
title = {Little Tricky Logic: Misconceptions in the Understanding of LTL},
journal = {},
volume = {},
number = {},
articleno = {7},
numpages = {37},
doi = {10.22152/programming-journal.org/2023/7/7},
year = {2023},
}
Publisher's Version
Artifact Reusable
Programming Journal, Volume 7, Issue 2: "A Theory of Composing Protocols ..."
A Theory of Composing Protocols
Laura Bocchi, Dominic Orchard, and A. Laura Voinea
(University of Kent, UK; University of Cambridge, UK; University of Glasgow, UK)
In programming, protocols are everywhere. Protocols describe the pattern of interaction (or communication) between software systems, for example, between a user-space program and the kernel or between a local application and an online service. Ensuring conformance to protocols avoids a significant class of software errors. Subsequently, there has been a lot of work on verifying code against formal protocol specifications. The pervading approaches focus on distributed settings involving parallel composition of processes within a single monolithic protocol description. However we observe that, at the level of a single thread/process, modern software must often implement a number of clearly delineated protocols at the same time which become dependent on each other, e.g., a banking API and one or more authentication protocols. Rather than plugging together modular protocol-following components, the code must re-integrate multiple protocols into a single component.
We address this concern of combining protocols via a novel notion of 'interleaving' composition for protocols described via a process algebra. User-specified, domain-specific constraints can be inserted into the individual protocols to serve as 'contact points' to guide this composition procedure, which outputs a single combined protocol that can be programmed against. Our approach allows an engineer to then program against a number of protocols that have been composed (re-integrated), reflecting the true nature of applications that must handle multiple protocols at once.
We prove various desirable properties of the composition, including behaviour preservation: that the composed protocol implements the behaviour of both component protocols. We demonstrate our approach in the practical setting of Erlang, with a tool implementing protocol composition that both generates Erlang code from a protocol and generates a protocol from Erlang code. This tool shows that, for a range of sample protocols (including real-world examples), a modest set of constraints can be inserted to produce a small number of candidate compositions to choose from.
As we increasingly build software interacting with many programs and subsystems, this new perspective gives a foundation for improving software quality via protocol conformance in a multi-protocol setting.
@Article{Programming Journal, Volume23p6,
author = {Laura Bocchi and Dominic Orchard and A. Laura Voinea},
title = {A Theory of Composing Protocols},
journal = {},
volume = {},
number = {},
articleno = {6},
numpages = {76},
doi = {10.22152/programming-journal.org/2023/7/6},
year = {2023},
}
Publisher's Version
Artifact Reusable