Refine Search

New Search

Results: 12

(searched for: doi:10.1145/3297858.3304069)
Save to Scifeed
Page of 1
Articles per Page
by
Show export options
  Select all
Roman Elizarov, Mikhail Belyaev, Marat Akhin, Ilmir Usmanov
Proceedings of the 2021 ACM SIGPLAN International Symposium on New Ideas, New Paradigms, and Reflections on Programming and Software; https://doi.org/10.1145/3486607.3486751

Abstract:
Asynchronous programming is having its “renaissance” moment in recent years. Created in the 1980s, it was in use for quite some time, but with the advent of multi-core processors, it has been sidestepped by multi-threaded programming, which was (for a long time) the de facto standard of performing concurrent computations. However, since the 2000s, more and more programming languages have begun to include the support for asynchronous programming, some built around asynchronicity from the start, others including it later in their evolution. In this paper, we explore the design and implementation of asynchronous programming in Kotlin, a multiplatform programming language from JetBrains, which uses coroutines for asynchronicity. Kotlin provides a compact built-in API for coroutine support, thus giving a lot of implementation freedom to the developer; this flexibility allows to transparently support different flavours of asynchronous programming within the same language. We overview existing approaches to asynchronous programming, zoom in and talk about coroutines in detail, and describe how they are used in Kotlin as the basis for asynchronous computations. Along the way, we show the flexibility of Kotlin coroutines, highlight several existing problems with asynchronicity, how they are fixed or worked-around in Kotlin, and also mention future directions asynchronous programming might explore.
Alexandre Kirszenberg, Antoine Martin, Hugo Moreau,
Published: 3 August 2021
Hybrid Learning and Education pp 140-156; https://doi.org/10.1007/978-3-030-84629-9_8

The publisher has not yet granted permission to display this abstract.
Ziheng Liu, Shuofei Zhu, Boqin Qin, Hao Chen, Linhai Song
Proceedings of the 26th ACM International Conference on Architectural Support for Programming Languages and Operating Systems; https://doi.org/10.1145/3445814.3446756

Abstract:
Go is a statically typed programming language designed for efficient and reliable concurrent programming. For this purpose, Go provides lightweight goroutines and recommends passing messages using channels as a less error-prone means of thread communication. Go has become increasingly popular in recent years and has been adopted to build many important infrastructure software systems. However, a recent empirical study shows that concurrency bugs, especially those due to misuse of channels, exist widely in Go. These bugs severely hurt the reliability of Go concurrent systems. To fight Go concurrency bugs caused by misuse of channels, this paper proposes a static concurrency bug detection system, GCatch, and an automated concurrency bug fixing system, GFix. After disentangling an input Go program, GCatch models the complex channel operations in Go using a novel constraint system and applies a constraint solver to identify blocking bugs. GFix automatically patches blocking bugs detected by GCatch using Go’s channel-related language features. We apply GCatch and GFix to 21 popular Go applications, including Docker, Kubernetes, and gRPC. In total, GCatch finds 149 previously unknown blocking bugs due to misuse of channels and GFix successfully fixes 124 of them. We have reported all detected bugs and generated patches to developers. So far, developers have fixed 125 blocking misuse-of-channel bugs based on our reporting. Among them, 87 bugs are fixed by applying GFix’s patches directly.
Ralf Jung, Jacques-Henri Jourdan, Robbert Krebbers, Derek Dreyer
Communications of the ACM, Volume 64, pp 144-152; https://doi.org/10.1145/3418295

Abstract:
The promise and the challenges of the first industry-supported language to master the trade-off between safety and control.
, Nicholas Fireman, Anas Shawesh, Raffi Khatchadourian
Proceedings of the ACM on Programming Languages, Volume 4, pp 1-32; https://doi.org/10.1145/3428282

Abstract:
Actor concurrency is becoming increasingly important in the development of real-world software systems. Although actor concurrency may be less susceptible to some multithreaded concurrency bugs, such as low-level data races and deadlocks, it comes with its own bugs that may be different. However, the fundamental characteristics of actor concurrency bugs, including their symptoms, root causes, API usages, examples, and differences when they come from different sources are still largely unknown. Actor software development can significantly benefit from a comprehensive qualitative and quantitative understanding of these characteristics, which is the focus of this work, to foster better API documentation, development practices, testing, debugging, repairing, and verification frameworks. To conduct this study, we take the following major steps. First, we construct a set of 186 real-world Akka actor bugs from Stack Overflow and GitHub via manual analysis of 3,924 Stack Overflow questions, answers, and comments and 3,315 GitHub commits, messages, original and modified code snippets, issues, and pull requests. Second, we manually study these actor bugs and their fixes to understand and classify their symptoms, root causes, and API usages. Third, we study the differences between the commonalities and distributions of symptoms, root causes, and API usages of our Stack Overflow and GitHub actor bugs. Fourth, we discuss real-world examples of our actor bugs with these symptoms and root causes. Finally, we investigate the relation of our findings with those of previous work and discuss their implications. A few findings of our study are: (1) symptoms of our actor bugs can be classified into five categories, with Error as the most common symptom and Incorrect Exceptions as the least common, (2) root causes of our actor bugs can be classified into ten categories, with Logic as the most common root cause and Untyped Communication as the least common, (3) a small number of Akka API packages are responsible for most of API usages by our actor bugs, and (4) our Stack Overflow and GitHub actor bugs can differ significantly in commonalities and distributions of their symptoms, root causes, and API usages. While some of our findings agree with those of previous work, others sharply contrast.
Boqin Qin, Yilun Chen, Zeming Yu, Linhai Song, Yiying Zhang
Proceedings of the 41st ACM SIGPLAN Conference on Programming Language Design and Implementation; https://doi.org/10.1145/3385412.3386036

Abstract:
Rust is a young programming language designed for systems software development. It aims to provide safety guarantees like high-level languages and performance efficiency like low-level languages. The core design of Rust is a set of strict safety rules enforced by compile-time checking. To support more low-level controls, Rust allows programmers to bypass these compiler checks to write unsafe code. It is important to understand what safety issues exist in real Rust programs and how Rust safety mechanisms impact programming practices. We performed the first empirical study of Rust by close, manual inspection of 850 unsafe code usages and 170 bugs in five open-source Rust projects, five widely-used Rust libraries, two online security databases, and the Rust standard library. Our study answers three important questions: how and why do programmers write unsafe code, what memory-safety issues real Rust programs have, and what concurrency bugs Rust programmers make. Our study reveals interesting real-world Rust program behaviors and new issues Rust programmers make. Based on our study results, we propose several directions of building Rust bug detectors and built two static bug detectors, both of which revealed previously unknown bugs.
Noussair Fikri, Mohamed Rida, Noureddine Abghour, Khalid Moussaid, Amina El Omri
Proceedings of the 2020 5th International Conference on Big Data and Computing; https://doi.org/10.1145/3404687.3404692

Abstract:
In this paper we present a new Golang based framework for distributed intensive data processing and also micro batching. It uses a novel approach, the persistent distributed channels, based on the concept of Share memory by communicating, and inspired from Resilient distributed datasets of Apache Spark. The architecture of our proposed system is considered as near-metal platform for Big Data operations in order to enhance the speed of massive data processing.
Ruben Hamers,
Published: 17 April 2020
Hybrid Learning and Education, Volume 12078, pp 266-284; https://doi.org/10.1007/978-3-030-45190-5_15

Abstract:
This paper presents Discourje: a runtime verification framework for communication protocols in Clojure. Discourje guarantees safety of protocol implementations relative to specifications, based on an expressive new version of multiparty session types. The framework has a formal foundation and is itself implemented in Clojure to offer a seamless specification–implementation experience. Benchmarks show Discourje’s overhead can be less than 5% for real/existing concurrent programs.
, Markosz Maliosz, Csaba Simon, Daniel Gehberger
Published: 19 January 2020
Hybrid Learning and Education pp 250-266; https://doi.org/10.1007/978-3-030-38651-1_21

The publisher has not yet granted permission to display this abstract.
Page of 1
Articles per Page
by
Show export options
  Select all
Back to Top Top