A concurrency-agnostic protocol for multi-paradigm concurrent debugging tools

Marr, Stefan; Lopez, Carmen Torres; Aumayr, Dominik; Boix, Elisa Gonzalez; Mössenböck, Hanspeter

doi:10.1145/3170472.3133842

Cited by 4 publications

(5 citation statements)

References 18 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…In our experience, capturing this information requires typically a single line of code per token type. Marr et al [2017] demonstrated the use of AST tagging to a similar effect. Unfortunately, this requires many different AST tags, and will only highlight the body of functions and methods.…”

Section: Informational Featuresmentioning

confidence: 85%

Execution vs. Parse-Based Language Servers: Tradeoffs and Opportunities for Language-Agnostic Tooling for Dynamic Languages

Marr

Burchell

Niephaus

2022

Proceedings of the 18th ACM SIGPLAN International Symposium on Dynamic Languages

View full text Add to dashboard Cite

With the wide adoption of the language server protocol, the desire to have IDE-style tooling even for niche and research languages has exploded. The Truffle language framework facilitates this desire by offering an almost zero-effort approach to language implementers to providing IDE features. However, this existing approach needs to execute the code being worked on to capture much of the information needed for an IDE, ideally with full unit-test coverage.To capture information more reliably and avoid the need to execute the code being worked on, we propose a new parse-based design for language servers. Our solution provides a language-agnostic interface for structural information, with which we can support most common IDE features for dynamic languages.Comparing the two approaches, we find that our new parse-based approach requires only a modest development effort for each language and has only minor tradeoffs for precision, for instance for code completion, compared to Truffle's execution-based approach.Further, we show that less than 1,000 lines of code capture enough details to provide much of the typical IDE functionality, with an order of magnitude less code than ad hoc language servers. We tested our approach for the custom parsers of Newspeak and SOM, as well as SimpleLanguage's ANTLR grammar without any changes to it. Combining both parse and execution-based approaches has the potential to provide good and precise IDE tooling for a wide range of languages with only small development effort. By itself, our approach would be a good addition to the many libraries implementing the language server protocol to enable low-effort implementations of IDE features.

show abstract

Section: Informational Featuresmentioning

confidence: 85%

Execution vs. Parse-Based Language Servers: Tradeoffs and Opportunities for Language-Agnostic Tooling for Dynamic Languages

Marr

Burchell

Niephaus

2022

Proceedings of the 18th ACM SIGPLAN International Symposium on Dynamic Languages

View full text Add to dashboard Cite

show abstract

“…Marr et al presented the Kómpos protocol [7], which is a concurrency-agnostic debugger protocol. Its goal is to decouple the debugger from the concurrency models such as threads, locks, communication event loops, and others.…”

Section: Recent Work On Idesmentioning

confidence: 99%

Distributed Architecture for an Integrated Development Environment, Large Trace Analysis, and Visualization

Piao

Ezzati‐Jivan

Dagenais

2021

Sensors

View full text Add to dashboard Cite

Integrated development environments (IDEs) provide many useful tools such as a code editor, a compiler, and a debugger for creating software. These tools are highly sophisticated, and their development requires a significant effort. Traditionally, an IDE supports different programming languages via plugins that are not usually reusable in other IDEs. Given the high complexity and constant evolution of popular programming languages, such as C++ and even Java, the effort to update those plugins has become unbearable. Thus, recent work aims to modularize IDEs and reuse the existing parser implementation directly in compilers. However, when IDE debugging tools are insufficient at detecting performance defects in large and multithreaded systems, developers must use tracing and trace visualization tools in their software development process. Those tools are often standalone applications and do not interoperate with the new modular IDEs, thus losing the power and the benefits of many features provided by the IDE. The structure and use cases of tracing tools, with the potentially massive execution traces, significantly differ from the other tools in IDEs. Thus, it is a considerable challenge, one which has not been addressed previously, to integrate them into the new modular IDEs. In this paper, we propose an efficient modular client–server architecture for trace analysis and visualization that solves those problems. The proposed architecture is well suited for performance analysis on Internet of Things (IoT) devices, where resource limitations often prohibit data collection, processing, and visualization all on the same device. The experimental evaluation demonstrated that our proposed flexible and reusable solution is scalable and has a small acceptable performance overhead compared to the standalone approach.

show abstract

“…Kómpos [40] is an online debugger for SOMns. For debugging actor-based programs, Kómpos provides a wide set of message-oriented breakpoints and stepping operations.…”

Section: Debuggersmentioning

confidence: 99%

A Study of Concurrency Bugs and Advanced Development Support for Actor-based Programs

Lopez

Marr

Boix

et al. 2018

Lecture Notes in Computer Science

Self Cite

View full text Add to dashboard Cite

The actor model is an attractive foundation for developing concurrent applications because actors are isolated concurrent entities that communicate through asynchronous messages and do not share state. Thereby, they avoid concurrency bugs such as data races, but are not immune to concurrency bugs in general. This study taxonomizes concurrency bugs in actor-based programs reported in literature. Furthermore, it analyzes the bugs to identify the patterns causing them as well as their observable behavior. Based on this taxonomy, we further analyze the literature and find that current approaches to static analysis and testing focus on communication deadlocks and message protocol violations. However, they do not provide solutions to identify livelocks and behavioral deadlocks. The insights obtained in this study can be used to improve debugging support for actor-based programs with new debugging techniques to identify the root cause of complex concurrency bugs. 1 play() -> 2 Ping = spawn(fun ping/0), 3 spawn(fun() -> pong(Ping) end). 4 5 ping() -> 6 receive 7 pong_msg -> ok 8 end. 9 10 pong(Ping) -> 11 Ping ! pong_msg, 12 receive 13 ping_msg -> ok 14 end.Listing 1.1. Communication deadlock example in Erlang (from [15]). Line 12 has a blocking receive causing the pong process to deadlock because the expected message is never sent.

show abstract

A concurrency-agnostic protocol for multi-paradigm concurrent debugging tools

Cited by 4 publications

References 18 publications

Execution vs. Parse-Based Language Servers: Tradeoffs and Opportunities for Language-Agnostic Tooling for Dynamic Languages

Execution vs. Parse-Based Language Servers: Tradeoffs and Opportunities for Language-Agnostic Tooling for Dynamic Languages

Distributed Architecture for an Integrated Development Environment, Large Trace Analysis, and Visualization

A Study of Concurrency Bugs and Advanced Development Support for Actor-based Programs

Contact Info

Product

Resources

About