Second Workshop on Programming Research in
Mainstream Languages (PRiML 2021)
Glasgow, UK, Mon July 12th, 2021 (Online)
PRiML 2021 is proudly sponsored by IOHK
About PRiML
The Second Workshop on Programming Research in Mainstream Languages is co-located with the 48th International Colloquium on Automata, Languages and Programming (ICALP 2021) in Glasgow, UK, in July 2021. The PRiML workshop will consist of invited talks by leading experts involved in programming language (PL) research within mainstream PLs. PL research in mainstream languages entails challenges beyond those encountered within the isolation of the laboratory. Mainstream PLs are supported by their many users, who expect stability, but so too innovation – whether within the language itself, or its standard libraries. A mainstream PL needs to support the initial concept critique, subsequent implementations, political calculations, and, ultimate bureaucracy involved in the execution of full support for novel features – often across multiple implementations. All that debate is due to real concerns about feature interaction. Performing PL research within a mainstream language can bring a hitherto proven research concept from the laboratory to a wider audience. Moreover, of course, the lack of isolation presents fresh challenges as new concepts must find their own idiomatic expression over the debate on feature interaction. Such contours can be found both within existing PLs; and new PLs: with or without the funding or wherewithal to approach a mainstream audience. On the other hand, the prototype PL crafted for experimenting with a research idea might have features remote from existing mainstream PLs. Choosing a mainstream PL to host the same research entails a fresh examination of the host’s features for their suitability for the research. The implication might be a very different feature set from the host or simulation to those of the prototype in the mainstream PL. Either way, the added benefit is solving the same research problem using a fresh set of features. Last year's PRiML 2020 workshop website is available here.Final Programme
| Time (CEST -- UTC+2) | Talk |
|---|---|
| 13:00 - 13:15 | Welcome and communications check |
| 13:15 - 14:00 | Magnus Morton (University of Edinburgh, UK) DelayRepay: delayed execution for kernel fusion in Python |
| 14:00 - 14:45 | Virgile Prevosto (CEA LIST, France) Lessons learned from verifying actual C code with Frama-C Slides |
| 14:45 - 15:00 | Break |
| 15:00 - 15:45 | Darius Blasband (Raincode, Belgium) C# as a meta-language for target of language translations |
| 15:45 - 16:30 | Yulia Startsev (Mozilla) and Felienne Hermans (Leiden University, The Netherlands) Cognitive Dimensions of JavaScript |
| 16:30 - 16:45 | Break |
| 16:45 - 17:30 | Gavin Bierman (Oracle, UK) The Future of Java |
| 17:30 - 18:15 | Réka Kovács (Eötvös Loránd University, Hungary) Memory errors in C++ : A static analysis point of view |
| 18:15 - 19:00 | Community Building Chat |
| 19:00 - 20:00 | Stephen Wolfram (Wolfram Research, US) Designing a Full-Scale Computational Language: 40 Years of Language Innovation |
Speakers and Abstracts
The Cognitive Dimensions of Notation (CDN) framework is a framework that can help us to understand the effect that a certain notation has on its users. While CDN was originally designed for a broad range of notations, including sheet music and diagrams but it has also been applied to various programming languages. These have often been lab languages, like XLBlocks [1] or generic editors [2]. In this talk Yulia, Mozilla programmer, and as such implementer of JavaScript, and Felienne, academic well-versed in CDN will together evaluate JavaScript with CDN.
[1] https://ieeexplore.ieee.org/abstract/document/8818748
[2] https://ieeexplore.ieee.org/abstract/document/8506483
Python is a popular, dynamic language for data science and scientific computing. To ensure efficiency, significant numerical libraries are implemented in static native languages. However, performance suffers when switching between native and non-native code, especially if data has to be converted between native arrays and Python data structures. As GPU accelerators are increasingly used, this problem becomes particularly acute. Data and control has to be repeatedly transferred between the accelerator and the host.
In this talk, I'll present DelayRepay, a delayed execution framework for numeric Python programs. It avoids excessive switching and data transfer by using lazy evaluation and kernel fusion. Using DelayRepay, operations on NumPy arrays are executed lazily, allowing multiple calls to accelerator kernels to be fused together dynamically. DelayRepay is available as a drop-in replacement for existing Python libraries. This approach enables significant performance improvement over the state-of-the-art and is invisible to the application programmer. I show that our approach provides a maximum 377× speedup over NumPy - a 409% increase over the state of the art.
C# and Java are often presented as being similar languages, separated by commercial concerns and stickiness to independently developed platforms more than intrinsic differences in technical paradigms.
This talk makes the case that there is more to this difference than meets the eye, as C# includes features that would be considered harmful if they were to be used by developers for newly written code, but make a lot of sense in the specific context of language translations, where the syntax and the semantics of the original system must be represented in the target language, minimizing entropy in the process.
The domain of language translation, and the specific challenges of this domain will be presented, to put C#’s specific capabilities in this area in perspective, and to show how Java, while usable as a target language in theory, would fall short and would result in less appealing translated systems.
In this talk I will describe some of the recent developments to the Java Programming Language, and some of the directions we plan to take in the near and less-near future. Along the way, I will discuss some of the research issues that arose, and some of the research results and techniques that we used.
The latest C++ standards have introduced two non-owning, reference-like data structures to the language: span and string_view. These lightweight “view” objects provide efficient access to data, simplify library function calls, and provide various convenience methods. Due to these advantages, their concept has long been present in the C++ world, with many companies implementing their own versions long before their standardization. Some of these versions are still widely used in big industrial projects, where moving to new standards is a slow and laborious process.
On the downside, while being very popular for performance reasons, views can easily lead to serious memory errors. Similarly to a raw pointer, the lifetime of a view is not tied in any way to its respective container’s lifetime, allowing it to “dangle” once the data is deallocated. Dereferencing a “dangling” view is a use-after-free error, very much like all the memory safety errors that take up 70% of the high-impact security bugs addressed each year at Microsoft and in the Chromium project. They are often found by dynamic analysis tools like sanitizers fairly late in the software development lifecycle, at which point the cost of fixing them is high.
When we developed static analysis tools to find dangling std::string_views right in the developer’s inner loop, we overestimated the pace of big open-source projects moving to new standards. Therefore, we have extended our tools to support non-standard implementations of the concept as well. In this talk, we discuss what makes a library class static analysis-friendly and compare the most popular string view implementations from a bug-hunter point of view.
Nearly since its inception more than 15 years ago, the Frama-C C software verification platform has been used on existing code bases, in a wide variety of contexts, ranging from early assessment of a new plug-in over a small open-source library to operational deployment for formally verifying industrial applications. While the reliance on realistic case studies has been fundamental in ensuring that the development of the platform was headed in the right direction, having to cope with typical C code in the wild comes with some challenges, both scientific and technical.
In this talk, we will first briefly present Frama-C itself and its main verification plugins, as well as the ACSL formal specification language, which also aims at letting users write specifications for actual programs, and imposes as few restrictions as possible over the semantics described by the C ISO standard. Then, we will recall the main verification tasks that have been achieved with Frama-C over the years.
Finally, a large part of the talk will be dedicated to explore the various issues that arise when one sets to use Frama-C on an arbitrary piece of C code, at all stages of the process. First, the perimeter of the analysis must somehow be clearly defined (i.e. identifying external dependencies and deciding what to do with them). Then, some information must be extracted from the compilation toolchain (which macros are defined when processing which files). Only after that can we address the intricacies of the C standard, and of its main compiler-specific variants, to establish what the Frama-C's kernel should accept as legitimate C programs. Finally, some parts of C's semantics have an important impact on the design of the analysis plug-ins themselves, notably when the analyzer has to deal with the fact that any C object can also be manipulated as an array of bytes.
As a conclusion, we will propose some hindsights on currently on-going work aiming at enhancing the ability of Frama-C to be incorporated in existing software development toolchains.
Important Dates
Proposal submission deadline: Friday June 4th Author notification: by Friday June 11th Workshop: Monday July 12thSubmission of Proposals
We are looking for talks about PL research within mainstream PLs. Prospective speakers should consider topics which:- briefly report on PL research performed with a mainstream PL; and
- clearly outline the added value of the chosen PL(s) for the reported research.