diff --git a/OpenTOC/dls23.html b/OpenTOC/dls23.html new file mode 100644 index 0000000..015e341 --- /dev/null +++ b/OpenTOC/dls23.html @@ -0,0 +1,155 @@ +DLS 2023: Proceedings of the 19th ACM SIGPLAN International Symposium on Dynamic Languages

DLS 2023: Proceedings of the 19th ACM SIGPLAN International Symposium on Dynamic Languages

+ Full Citation in the ACM Digital Library +

SESSION: Papers

+

All Languages Are Dynamic (Invited Talk)

+

Virtual Machines, Dynamic Compllers, and Implementation Frameworks make dynamic langauges easier and more efficient to optimize. Meanwhile, IDEs, provers, dependent types, type inferencers, and (so-called) “generative AI” mean programmers can express - statically - more information about the dynamic behaviour of their programs. Component libraries in these languages will come with assertions and proofs of their behaviour, and their advocates fantasise about transforming programming into the composition of dependently-typed higher-order yoneda morphisms, ensuring programs are correct-by-construction (where that construction is carried out by yet more generative AI). +In this talk, I’ll speculate about what the resulting world will be like for programmers. Rather than a static world of platonic mathematical abstractions, I argue that the opposite will be true: that all languages will be dynamic.

+
+ + +

Are We Heading towards a Dynamic Language Winter? (Invited Talk)

+

Though the 2010s saw many research publications about languages such as JavaScript and Python, there currently appears to be a general loss of interest in dynamic languages, with popular new languages such as Rust and Zig being statically typed, and AOT compilation often being viewed as a preferable option to JIT compilation. There is a legitimate question as to whether we are headed towards, or already in, a dynamic language “winter”, with reduced interest from industry and reduced access to funding for dynamic language research. However, despite this, many of the most popular languages (Python, JS, Julia, etc.) are still dynamically typed. In this talk, we discuss questions such as potential causes for a dynamic language winter, what makes statically typed languages so attractive at this time, the major strengths of dynamic languages that could help turn the tide, and what may come after.

+
+ + +

Is Polyglot Programming Really a Thing? (Invited Talk)

+

Polyglot programming is the practice of writing an application with multiple languages to capture additional functionality and efficiency not available to a single language. This happens more often than people think. Some reasons are: to support different platforms (e.g., Android, iOS), to be more efficient on some parts, to take advantage of features unique to a different ecosystem (e.g., dedicated APIs). But are we ready for polyglot programming? This talk will try to explore the open issues from the point of view of both the multiple programming language integration and from the software engineering development for polyglot programming.

+
+ + +

JITs Are Nice, but Why Aren’t We Using Them? (Invited Talk)

+

Dynamic languages have evolved quite a bit over the past few decades. While there’s always room for improvement, the current generation of languages have rich semantics and expressive syntax, making for a pleasant developer experience. Developers can clearly represent ideas, decreasing the maintenance burden while supporting rapid development. Dynamic languages such as Python, Ruby, JavaScript, PHP, and Lua power a substantial portion of web applications and services today. However, diminishing returns in terms of single-core performance and memory bandwidth improvements combined with the limited computational resources available in budget-minded cloud computing have +highlighted the inefficiencies of language interpreters. To remain relevant in the decades to come, dynamic language VMs must make a concerted effort to reduce overhead and make effective use of performance features made available by the underlying platform. Dynamic optimization through JIT compilation has proven to be an effective mechanism for improving dynamic language performance, but building and maintaining a JIT compiler is an expensive undertaking. Meta-compilation promises to reduce those costs, but incurs other costs that hamper adoption in industry. Through the lens of a company deploying thousands of Ruby projects into production, we assess the limitations of current VMs, highlight the most impactful advancements, and consider what’s most important for the coming decades.

+
+ + +

Keeping the asm in Wasm: Running High-Level Languages on a Low-Level VM (Invited Talk)

+

WebAssembly (Wasm) is a virtual machine whose defining characteristic is that it is low-level: Wasm is designed to abstract the hardware below, not language concepts above. This is a prerequisite for providing predictable performance and for avoiding language bias without feature creep. At the same time, it is a hard requirement that Wasm is safe and portable, which sometimes necessitates raising its abstraction level above the raw metal. Yet ultimately, the intention is that language runtimes are largely implemented _on top_ of Wasm, in Wasm itself. +

+

+Dynamic languages pose a challenge for this model, because achieving acceptable performance for them often requires every dirty trick from the books. Not all of these techniques are easily ported to Wasm with some of its abstractions, or they incur higher cost because a Wasm engine cannot know or trust invariants in the higher-level runtime and may need to perform redundant checks to maintain its own safety. In particular, Wasm will need to supply additional mechanisms to efficiently support techniques like jit compilation or inline caches.

+
+ + +

Language Runtimes for the New Cloud Era (Invited Talk)

+

Programming languages offer a number of abstractions such as dynamic typing, sandboxing, and automatic garbage collection which, however, come at a performance cost. Looking back, the most influential programming languages were proposed at a time when Moore’s Law was still in place. +Nowadays, post-Moore’s law, scalability, and elasticity become crucial requirements, leading to an increasing tension between programming language design and implementation, and performance. It is now time to discuss the impact of programming languages and language runtimes in the context of scalable and elastic cloud computing platforms with the goal of forecasting their role in the new cloud era.

+
+ + +

Programming Languages for AI Programing Agents (Invited Talk)

+

Over the past decade software development has shifted from a process centered around writing code to a process that increasingly involves composition of external packages and managing the integration of code from other team members. The next decade-plus will be defined by the shift from a process where humans are the central developers of code into one where AI agents, likely Large Language Model (LLM) based, will be the major creators of code and humans will shift to a supervisory role as curators, integrating rich framework-functionality and code developed by AI programming agents. +

+

+In this new world we must ask ourselves – are programming languages as they exist today fit for purpose and how do they evolve to meet the needs of this future programming model. This talk represents an opinionated take on the question and attempts to outline specific areas of investigation that need to be addressed by the PL community as part of this journey including: +

+

+What programming language features help/hinder AI agents when understanding and generating code? +

+

+What programming language features help/hinder human agents when working with an AI Copilot? +

+

+What programming language tools are needed to empower AI agents in creating grounded and reliable outputs? +

+

+How can intents be expressed as part of the program representation – examples, constraints, natural language, external documents? +

+

+How do we empower end-users as part of this transformation? +

+

+What programming language features are needed to support new AI driven workflows – live coding, interactive requirement gathering, AI TDD? +

+

+Effectively answering these questions plays a key role in determining if AI driven programming represents a revolution in how software is developed or is limited to being a programming productivity aid for existing development workflows. As such our community should play a central role in understanding this space and leading in the development of this technological transformation!

+
+ + +

The Bright Future of Debuggers: Challenges and Opportunities (Invited Talk)

+

Since the first bug was discovered in the Mark Harvard II electromechanical computer it was clear that finding bugs and debugging of computer systems would be an extremely challenging task. Today, various reports indicated that programmers spend approximately 50% of their time on debugging related tasks resulting in an annual cost of $312 billion. Given these astronomical amounts of resources being put into debugging, any technique that improves debugging efficiency is tremendously valuable. +

+

+In the last decades various new debugging techniques have been put forward to ease debugging and finding the root cause of a failures. Techniques like record-replay, deltadebugging, model checking, tracing, visualisation, fuzzing, automated debugging, and many more help programmers to be more effective while debugging. Recently, we have seen that some of techniques are slowly finding their way into mainstream debugging practices. In this talk we first give an overview of recent exiting debugging techniques, show their advantages and limitations to then reflect on the challenges and opportunities for further research.

+
+ +
\ No newline at end of file diff --git a/OpenTOC/ftscs23.html b/OpenTOC/ftscs23.html new file mode 100644 index 0000000..6454972 --- /dev/null +++ b/OpenTOC/ftscs23.html @@ -0,0 +1,115 @@ +FTSCS 2023: Proceedings of the 9th ACM SIGPLAN International Workshop on Formal Techniques for Safety-Critical Systems

FTSCS 2023: Proceedings of the 9th ACM SIGPLAN International Workshop on Formal Techniques for Safety-Critical Systems

+ Full Citation in the ACM Digital Library +

SESSION: Invited Talk

+

Bounded STL Model Checking for Hybrid Systems (Invited Talk)

+

Signal temporal logic (STL) is a temporal logic formalism for specifying properties of continuous signals. STL has been widely used for specifying, monitoring, and testing properties of hybrid systems that exhibit both discrete and continuous behavior. However, model checking techniques for hybrid systems have been primarily limited to invariant and reachability properties. This is mainly due to the intrinsic nature of hybrid systems, which involve uncountably many signals that continuously change over time. For hybrid systems, checking whether all possible behaviors satisfy an STL formula requires a certain form of abstraction and discretization, which has not been developed for general STL properties. +

+

+In this talk, I introduce bounded model checking algorithms and tools for general STL properties of hybrid systems. Central to our technique is a novel logical foundation for STL: (i) a syntactic separation of STL, which decomposes an STL formula into components, with each component relying exclusively on separate segments of a signal, and (ii) a signal discretization, which ensures a complete abstraction of a signal, given by a set of discrete elements. With this new foundation, the STL model checking problem can be reduced to the satisfiability of a first-order logic formula. This allows us to develop the first model checking algorithm for STL that can guarantee the correctness of STL up to given bound parameters, and a pioneering bounded model checker for hybrid systems, called STLmc.

+
+ +

SESSION: Papers

+

Formal Verification of a Mechanical Ventilator using UPPAAL

+

Mechanical ventilators are increasingly used for life support of critically ill patients. In this sense, despite recent technological advances, the accurate specification of their properties remains challenging, and the use of formal tools is limited. This work focuses on verifying the properties of the architecture of a mechanical ventilator using UPPAAL as a modeling tool. As a result, the system requirements and specification of a functional prototype were verified and improved using the formal model of a mechanical ventilator. This approach provides a valuable means of ensuring the correctness and reliability of mechanical ventilator systems.

+
+ + +

Symbolic Analysis by Using Folding Narrowing with Irreducibility and SMT Constraints

+

Symbolic reachability analysis using rewriting with Satisfiability Modulo Theories (SMT) has been used to model different systems, including a variety of security protocols. Recently, it has also been used to analyze systems modeled using Parametric Timed Automata (PTAs). These techniques are based on reachability in a finite state graph generated from symbolic initial states where each generated state is constrained by an SMT expression checked for satisfiability. In this work, by rewriting with SMT but by narrowing with SMT. we use narrowing with SMT instead of rewriting with SMT. Narrowing with SMT allows a greater generalization, since (i) an infinite number of initial states may be represented by a finite number of states with variables, not only SMT variables, and (ii) an infinite state graph from an initial state may be represented by a finite state graph from another initial state with variables, not only SMT variables. We use graph search pruning techniques via irreducible terms and SMT constraints on conditional rules. This is supported by a novel folding SMT narrowing technique to represent infinite computations in a finite way. Additionally, we present a new textual user interface that allows the use of the algorithm in a simpler and more readable way.

+
+ + +

Probabilistic Risk Assessment of an Obstacle Detection System for GoA 4 Freight Trains

+

We propose a quantitative risk assessment approach for the design of an obstacle detection function for low-speed freight trains with grade of automation 4. In this five-step approach, starting with single detection channels and ending with a three-out-of-three model comprised of three independent dual-channel modules and a voter, we exemplify a probabilistic assessment, using a combination of statistical methods and parametric stochastic model checking. We illustrate that, under certain not unreasonable assumptions, the resulting hazard rate becomes acceptable for the discussed application setting. The statistical approach for assessing the residual risk of misclassifications in convolutional neural networks and conventional image processing software suggests that high confidence can be placed into the safety-critical obstacle detection function, even though its implementation involves realistic machine learning uncertainties.

+
+ + +

Does Rust SPARK Joy? Safe Bindings from Rust to SPARK, Applied to the BBQueue Library

+

Both Rust and SPARK are memory-safe programming languages and feature stronger safety guarantees than other popular programming languages for embedded software. However, modern systems often combine software written in multiple programming languages using the Foreign Function Interface (FFI). When using safety-oriented programming languages such as Rust and SPARK, maintaining compile-time safety guarantees across a language boundary is a challenge. The objective of this study is to explore if/how the inherent safety guarantees of these languages are preserved, and their potential benefits when establishing a library interface between them. In particular, we apply our method to the BBQueue circular buffer library that features complex ownership hand-over patterns when using FFI. Results reveal that most of the inherent consistency and safety features of these languages can be maintained. Yet, special caution is required at the FFI boundary to prevent potential vulnerabilities.

+
+ + +

Solving Queries for Boolean Fault Tree Logic via Quantified SAT

+

Fault trees (FTs) are hierarchical diagrams used to model the propagation of faults in a system. Fault tree analysis (FTA) is a widespread technique that allows to identify the key factors that contribute to system failure. In recent work we introduced BFL, a Boolean Logic for Fault trees. BFL can be used to formally define simple yet expressive properties for FTA, e.g.: 1) we can set evidence to analyse what-if scenarios; 2) check whether two elements are independent or if they share a child that can influence their status; 3) and set upper/lower boundaries for failed elements. Furthermore, we provided algorithms based on binary decision diagrams (BDDs) to check BFL properties on FTs. In this work, we evaluate usability of a different approach by employing quantified Boolean formulae (QBFs) instead of BDDs. We present a translation from BFL to QBF and provide an implementation—making it the first tool for checking BFL properties—that builds on top of the Z3 solver. We further demonstrate its usability on a case study FT and investigate runtime, memory consumption and scalability on a number of benchmark FTs. Lastly, qualitative differences from a BDD-based approach are discussed.

+
+ +
\ No newline at end of file diff --git a/OpenTOC/gpce23.html b/OpenTOC/gpce23.html new file mode 100644 index 0000000..e606084 --- /dev/null +++ b/OpenTOC/gpce23.html @@ -0,0 +1,180 @@ +GPCE 2023: Proceedings of the 22nd ACM SIGPLAN International Conference on Generative Programming: Concepts and Experiences

GPCE 2023: Proceedings of the 22nd ACM SIGPLAN International Conference on Generative Programming: Concepts and Experiences

+ Full Citation in the ACM Digital Library +

SESSION: Papers

+

Automatically Generated Supernodes for AST Interpreters Improve Virtual-Machine Performance

+

Abstract syntax tree (AST) interpreters allow implementing programming languages in a straight-forward way. However, AST interpreters implemented in object-oriented languages, such as e.g. in Java, often suffer from two serious performance issues. First, these interpreters commonly implement AST nodes by leveraging class inheritance and polymorphism, leading to many polymorphic call sites in the interpreter implementation and hence lowering interpreter performance. Second, widely used implementations of these interpreters throw costly runtime exceptions to model the control flow. Even though Just-in-Time (JIT) compilation mitigates these issues, performance in the first stages of the program execution remains poor. +

+

+In this paper, we propose a novel technique to improve both interpreter performance and steady-state performance, lowering also the pressure on the JIT compiler. Our technique automatically generates AST supernodes ahead-of-time, i.e., we automatically generate compound AST-node classes that encode the behavior of several other primitive AST nodes before the execution of the application. Our technique extracts common control-flow structures from an arbitrary, given set of ASTs, such as e.g. the functions of popular packages. It is based on matchmaking of AST structures, instantiation of matching supernodes, and replacement of the corresponding AST subtrees with the instantiated supernodes at load-time. We implement our technique in the GraalVM JavaScript engine, showing that our supernodes lead to an average interpreter speedup of 1.24x, an average steady-state speedup of 1.14x, and an average just-in-time compilation speedup of 1.33x on the web-tooling benchmark suite.

+
+ + +

A Monadic Framework for Name Resolution in Multi-phased Type Checkers

+

An important aspect of type checking is name resolution --- i.e., determining the types of names by resolving them to a matching declaration. + For most languages, we can give typing rules that define name resolution in a way that abstracts from what order different units of code should be checked in. + However, implementations of type checkers in practice typically use multiple phases to ensure that declarations of resolvable names are available before names are resolved. + This gives rise to a gap between typing rules that abstract from order of type checking and multi-phased type checkers that rely on explicit ordering. +

+

+ This paper introduces techniques that reduce this gap. + First, we introduce a monadic interface for phased name resolution which detects and rejects type checking runs with name resolution phasing errors where names were wrongly resolved because some declarations were not available when they were supposed to be. + Second, building on recent work by Gibbons et al., we use applicative functors to compositionally map abstract syntax trees onto (phased) monadic computations that represent typing constraints. + These techniques reduce the gap between type checker implementations and typing rules in the sense that (1) both are given by compositional mappings over abstract syntax trees, and (2) type checker cases consist of computations that roughly correspond to typing rule premises, except these are composed using monadic combinators. + We demonstrate our approach by implementing type checkers for Mini-ML with Damas-Hindley-Milner type inference, and LM, a toy module language with a challenging import resolution policy.

+
+ + +

A pred-LL(*) Parsable Typed Higher-Order Macro System for Architecture Description Languages

+

Macro systems are powerful language extension tools for +Architecture Description Languages (ADLs). +Their generative power in combination with +the simplicity of specification languages allows for a substantial +reduction of repetitive specification sections. +This paper explores how +the introduction of function- and record types +in a template-based macro system impacts the specification of ADLs. +We present design and implementation of a pattern-based syntax macro system for +the Vienna Architecture Description Language (VADL). +The macro system is directly integrated into the language and +is analyzed at parse time using a context-sensitive pred-LL(*) parser. +The usefulness of the macro system is illustrated by some typical macro +application design patterns. +The effectiveness is shown by a detailed evaluation of the Instruction Set +Architecture (ISA) specification of five different processor architectures. +The observed specification reduction can be up to 90 times, leading to improved +maintainability, readability and runtime performance of the specifications.

+
+ + +

C2TACO: Lifting Tensor Code to TACO

+

Domain-specific languages (DSLs) promise a significant performance and portability advantage over traditional languages. DSLs are designed to be high-level and platform-independent, allowing an optimizing compiler significant leeway when targeting a particular device. Such languages are particularly popular with emerging tensor algebra workloads. However, DSLs present their own challenge: they require programmers to learn new programming languages and put in significant effort to migrate legacy code. +

+

+We present C2TACO, a synthesis tool for synthesizing TACO, a well-known tensor DSL, from C code. We develop a smart, enumerative synthesizer that uses automatically generated IO examples and source-code analysis to efficiently generate code. C2TACO is able to synthesize 95% bench marks from a tensor benchmark suite, out-performing an alternative neural machine translation technique, and demonstrates substantially higher levels of accuracy when evaluated against two state-of-the-art existing schemes, TF-Coder and ChatGPT. Our synthesized TACO programs are, by design, portable achieving significant performance improvement when evaluated on a multi-core and GPU platform.

+
+ + +

Partial Evaluation of Automatic Differentiation for Differential-Algebraic Equations Solvers

+

Differential-Algebraic Equations (DAEs) are the foundation of high-level equation-based languages for modeling physical dynamical systems. Simulating models in such languages requires a transformation known as index reduction that involves differentiating individual equations before numerical integration. Commercial and open-source implementations typically perform index reduction by symbolic differentiation (SD) and produce a Jacobian callback function with forward-mode automatic differentiation (AD). The former results in efficient runtime code, and the latter is asymptotically efficient in both runtime and code size. However, AD introduces runtime overhead caused by a non-standard representation of real numbers, and SD is not always applicable in models with general recursion. This work proposes a new approach that uses partial evaluation of AD in the context of numerical DAE solving to combine the strengths of the two differentiation methods while mitigating their weaknesses. Moreover, our approach selectively specializes partial derivatives of the Jacobian by exploiting structural knowledge while respecting a user-defined bound on the code size. Our evaluation shows that the new method both enables expressive modeling from AD and retains the efficiency of SD for many practical applications.

+
+ + +

Crossover: Towards Compiler-Enabled COBOL-C Interoperability

+

Interoperability across software languages is an important practical topic. In this paper, we take a deep dive into investigating and tackling the challenges involved with achieving interoperability between C and BabyCobol. The latter is a domain-specific language condensing challenges found in compiling legacy languages — borrowing directly from COBOL's data philosophy. Crossover, a compiler designed specifically to showcase the interoperability, exposes details of connecting a COBOL-like language with PICTURE clauses and re-entrant procedures, to C with primitive types and struct composites. Crossover features a C library for overcoming the differences between the data representations native to the respective languages. We illustrate the design process of Crossover and demonstrate its usage to provide a strategy to achieve interoperability between legacy and modern languages. The described process is aimed to be a blueprint for achievable interoperability between full-fledged COBOL and modern C-like programming languages.

+
+ + +

Generating Conforming Programs with Xsmith

+

Fuzz testing is an effective tool for finding bugs in software, including programming language compilers and interpreters. +Advanced fuzz testers can find deep semantic bugs in language implementations through differential testing. +However, input programs used for differential testing must not only be syntactically and semantically valid, but also be free from nondeterminism and undefined behaviors. +Developing a fuzzer that produces such programs can require tens of thousands of lines of code and hundreds of person-hours. +Despite this significant investment, fuzzers designed for differential testing of different languages include many of the same features and analyses in their implementations. +To make the implementation of language fuzz testers for differential testing easier, we introduce Xsmith. +

+

+Xsmith is a Racket library and domain-specific language that provides mechanisms for implementing a fuzz tester in only a few hundred lines of code. +By sharing infrastructure, allowing declarative language specification, and by allowing procedural extensions, Xsmith allows developers to write correct fuzzers for differential testing with little effort. +We have developed fuzzers for several languages, and found bugs in implementations of Racket, Dafny, Standard ML, and WebAssembly.

+
+ + +

Multi-Stage Vertex-Centric Programming for Agent-Based Simulations

+

In vertex-centric programming, users express a graph algorithm as a vertex program and specify the iterative behavior of a vertex in a compute function, which is executed by all vertices in a graph in parallel, synchronously in a sequence of supersteps. While this programming model is straightforward for simple algorithms where vertices behave the same in each superstep, for complex vertex programs where vertices have different behavior across supersteps, a vertex needs to frequently dispatch on the value of supersteps in compute, which suffers from unnecessary interpretation overhead and complicates the control flow.

We address this using meta-programming: instead of branching on the value of a superstep, users separate instructions that should be executed in different supersteps via a staging-time wait() instruction. When a superstep starts, computations in a vertex program resume from the last execution point, and continue executing until the next wait(). We implement this in the programming model of an agent-based simulation framework CloudCity and show that avoiding the interpretation overhead caused by dispatching on the value of a superstep can improve the performance by up to 25% and lead to more robust performance.

+
+ + +

Unleashing the Power of Implicit Feedback in Software Product Lines: Benefits Ahead

+

Software Product Lines (SPLs) facilitate the development of a complete range of software products through systematic reuse. Reuse involves not only code but also the transfer of knowledge gained from one product to others within the SPL. This transfer includes bug fixing, which, when encountered in one product, affects the entire SPL portfolio. Similarly, feedback obtained from the usage of a single product can inform beyond that product to impact the entire SPL portfolio. Specifically, implicit feedback refers to the automated collection of data on software usage or execution, which allows for the inference of customer preferences and trends. While implicit feedback is commonly used in single-product development, its application in SPLs has not received the same level of attention. This paper promotes the investigation of implicit feedback in SPLs by identifying a set of SPL activities that can benefit the most from it. We validate this usefulness with practitioners using a questionnaire-based approach (n=8). The results provide positive insights into the advantages and practical implications of adopting implicit feedback at the SPL level.

+
+ + +

Virtual Domain Specific Languages via Embedded Projectional Editing

+

Domain Specific Languages (DSLs) can be implemented as either internal DSL, i.e. essentially a library in a host general-purpose programming language (GPL), or as external DSL which is a stand-alone language unconstrained in its syntax. This choice implies an inherent trade-off between a limited syntactic and representational flexibility (internal DSLs), or an involved integration with GPLs and the need for a full stack of tools from a parser to a code generator (external DSLs).

We propose a solution which addresses this problem by representing a subset of a GPL - from simple code patterns to complex API calls - as GUI widgets in a hybrid editor. Our approach relies on matching parametrized patterns against the GPL program, and displaying the matched parts as dynamically rendered widgets. Such widgets can be interpreted as components of an external DSL. Since the source code is serialized as GPL text without annotations, there is no DSL outside the editor - hence the term ‘virtual’ DSL.

This solution has several advantages. The underlying GPL and the virtual DSL can be mixed in a compositional way, with zero cost of their integration. The project infrastructure does not need to be adapted. Furthermore, our approach works with mainstream GPLs like Python or JavaScript.

To lower the development effort of such virtual DSLs, we also propose an approach to generate patterns and the corresponding text-only GUI widgets from pairs of examples.

We evaluate our approach and its implementation on use cases from several domains. A live demo of the system can be accessed at https://puredit.korz.dev/ and the source code with examples at https://github.com/niklaskorz/puredit/.

+
+ + +

Generating Constraint Programs for Variability Model Reasoning: A DSL and Solver-Agnostic Approach

+

Verifying and configuring large Software Product Lines (SPL) requires automation tools. Current state-of-the-art approaches involve translating variability models into a formalism accepted as input by a constraint solver. There are currently no standards for variability modeling languages (VML). There is also a variety of constraint solver input languages. This has resulted in a multiplication of ad-hoc architectures and tools specialized for a single pair of VML and solver, fragmenting the SPL community. To overcome this limitation, we propose a novel architecture based on model-driven code generation, where the syntax and semantics of VMLs can be declaratively specified as data, and a standard, human-readable, formal pivot language is used between the VML and the solver input language. This architecture is the first to be fully generic by being agnostic to both VML and the solver paradigm. To validate the genericity of the approach, we have implemented a prototype tool together with declarative specifications for the syntax and semantics of two different VMLs and two different solver families. One VML is for classic, static SPL, and the other for run-time reconfigurable dynamic SPL with soft constraints to be optimized during configuration. The two solver families are Constraint Satisfaction Programs (CSP) and Constraint Logic Programs (CLP).

+
+ +
\ No newline at end of file diff --git a/OpenTOC/mplr23.html b/OpenTOC/mplr23.html new file mode 100644 index 0000000..1bb21aa --- /dev/null +++ b/OpenTOC/mplr23.html @@ -0,0 +1,361 @@ +MPLR 2023: Proceedings of the 20th ACM SIGPLAN International Conference on Managed Programming Languages and Runtimes

MPLR 2023: Proceedings of the 20th ACM SIGPLAN International Conference on Managed Programming Languages and Runtimes

+ Full Citation in the ACM Digital Library +

SESSION: Session 1

+

Is Wasm Becoming Garbage? (Keynote)

+

WebAssembly (a.k.a. Wasm) is a low-level virtual machine that is designed to be lightweight, close to the metal and agnostic to any source languages' opinions about how to construct programs. This is the defining characteristic of Wasm that distinguishes it from other popular virtual machines. Yet we recently finalised a new feature addition bringing direct support for garbage collection to Wasm. In this talk, I explain why we did that and how the GC extension is designed to preserve the low-level spirit of Wasm to the extent possible. I will show how it can be targeted by compilers for typical object-oriented and functional languages and where we left room for future improvements.

+
+ + +

On the Applicability of Annotation-Based Source Code Modification in Kotlin (Work in Progress)

+

Annotations add metadata to source code entities such as classes or functions, which later can be processed by so-called annotation processors to, for example, modify the annotated program’s source code. While annotation processing has been well-explored in Java, the Kotlin community still lacks a comprehensive summary. Thus, in this paper, we summarize the main approaches available in Kotlin: (1) ‍Compile-time annotation processing using (a) ‍Kotlin Annotation Processing Tool (KAPT), (b) ‍Kotlin Symbolic Processing (KSP), or (c) ‍writing a custom Kotlin Compiler plugin; as well as (2) ‍load-time code modification using an agent or a custom class loader. We provide proof-of-concept implementations, discuss advantages and disadvantages, and specifically focus on how well each approach supports modifying the annotated source code. This should help developers and researchers to better decide when to use which approach.

+
+ + +

CloudJIT: A Just-in-Time FaaS Optimizer (Work in Progress)

+

Function-as-a-Service has emerged as a trending paradigm that provides attractive solutions to execute fine-grained and short-lived workloads referred to as functions. Functions are typically developed in a managed language such as Java and execute atop a language runtime. However, traditional language runtimes such as the HotSpot JVM are designed for peak performance as considerable time is spent profiling and Just-in-Time compiling code. As a consequence, warmup time and memory footprint are impacted. We observe that FaaS workloads, which are short-lived, do not fit this profile. +

+

+We propose CloudJIT, a self-optimizing FaaS platform that takes advantage of Ahead-of-Time compilation to achieve reduced startup latency and instantaneous peak performance with a smaller memory footprint. While AOT compilation is an expensive operation, the platform automatically detects which functions will benefit from it the most, performs all prerequisite preparation procedures, and compiles selected functions into native binaries. Our preliminary analysis, based on a public FaaS invocations trace, shows that optimizing a small fraction of all functions positively affects a vast majority of all cold starts.

+
+ +

SESSION: Session 2

+

Evaluating YJIT’s Performance in a Production Context: A Pragmatic Approach

+

Ruby is a dynamically-typed programming language with a large breadth of features which +has grown in popularity with the rise of the modern web, and remains at the core of the +implementation of widely-used online platforms such as Shopify, GitHub, Discourse, +and Mastodon. +

+

+There have been many attempts to integrate JIT compilation into Ruby implementations, but until recently, despite impressive +performance on benchmarks, none had seen widespread adoption. +This has changed with the arrival of YJIT, a new JIT compiler based on a Lazy Basic Block Versioning (LBBV) architecture which has recently been upstreamed into CRuby, +and has since seen multiple large-scale production deployments. +

+

+This paper extends on previous work on YJIT and takes a pragmatic approach towards evaluating YJIT's performance in a production context. We evaluate and compare its performance on benchmarks as well as a large-scale real-world production deployment, and we look not only at peak performance, but also at memory usage and warm-up time. +

+

+On all of our benchmarks, YJIT is able to consistently outperform the CRuby interpreter by a wide +margin. It offers consistent speedups, full compatibility with existing Ruby code, much less memory overhead and faster warm-up compared to JRuby and TruffleRuby. +We also show that YJIT is able to deliver significant speedups on a real-world deployment on Shopify's worldwide StoreFront Renderer infrastructure, an application for which it is currently the only viable JIT compiler.

+
+ + +

CacheIR: The Benefits of a Structured Representation for Inline Caches

+

Inline Caching is an important technique used to accelerate operations in dynamically typed language implementations by creating fast paths based on observed program behaviour. +Most software stacks that support inline caching use low-level, often ad-hoc, Inline-Cache (ICs) data structures for code generation. +This work presents CacheIR, a design for inline caching built entirely around an intermediate representation (IR) which: (i) simplifies the development of ICs by raising the abstraction level; and (ii) enables reusing compiled native code through IR matching techniques. +Moreover, this work describes WarpBuilder, a novel design for a Just-In-Time (JIT) compiler front-end that directly generates type-specialized code by lowering the CacheIR contained in ICs; and Trial Inlining, an extension to the inline-caching system that allows for context-sensitive inlining of context-sensitive ICs. +The combination of CacheIR and WarpBuilder have been powerful performance tools for the SpiderMonkey team, and have been key in providing improved performance with less security risk.

+
+ + +

Diagnosing Compiler Performance by Comparing Optimization Decisions

+

Modern compilers apply a set of optimization passes aiming to speed up the generated code. The combined effect of individual optimizations is difficult to predict. Thus, changes to a compiler's code may hinder the performance of generated code as an unintended consequence. +

+

+Performance regressions in compiled code are often related to misapplied optimizations. The regressions are hard to investigate, considering the vast number of compilation units and applied optimizations. A compilation unit consists of a root method and inlined methods. Thus, a method may be part of several compilation units and may be optimized differently in each. Moreover, inlining decisions are not invariant across runs of the virtual machine (VM). +

+

+We propose to solve the problem of diagnosing performance regressions by capturing the compiler's optimization decisions. We do so by representing the applied optimization phases, optimization decisions, and inlining decisions in the form of trees. This paper introduces an approach utilizing tree edit distance (TED) to detect optimization differences in a semi-automated way. We present an approach to compare optimization decisions in differently inlined methods. We employ these techniques to pinpoint the causes of performance problems in various benchmarks of the Graal compiler.

+
+ + +

Morello MicroPython: A Python Interpreter for CHERI

+

Arm Morello is a prototype system that supports CHERI +hardware capabilities for improving runtime security. As +Morello becomes more widely available, there is a growing effort to port open source code projects to this novel +platform. Although high-level applications generally need +minimal code refactoring for CHERI compatibility, low-level +systems code bases require significant modification to comply with the stringent memory safety constraints that are +dynamically enforced by Morello. In this paper, we describe +our work on porting the MicroPython interpreter to Morello +with the CheriBSD OS. Our key contribution is to present a +set of generic lessons for adapting managed runtime execution environments to CHERI, including (1) a characterization +of necessary source code changes, (2) an evaluation of runtime performance of the interpreter on Morello, and (3) a +demonstration of pragmatic memory safety bug detection. +Although MicroPython is a lightweight interpreter, mostly +written in C, we believe that the changes we have implemented and the lessons we have learned are more widely +applicable. To the best of our knowledge, this is the first +published description of meaningful experience for scripting +language runtime engineering with CHERI and Morello.

+
+ +

SESSION: Session 3

+

A Multifaceted Memory Analysis of Java Benchmarks

+

Java benchmarking suites like Dacapo and Renaissance are employed by the research community to evaluate the performance of novel features in managed runtime systems. +These suites encompass various applications with diverse behaviors in order to stress test different subsystems of a managed runtime. +Therefore, understanding and characterizing the behavior of these benchmarks is important when trying to interpret experimental results. +

+

+This paper presents an in-depth study of the memory behavior of 30 Dacapo and Renaissance applications. +To realize the study, a characterization methodology based on a two-faceted profiling process of the Java applications is employed. +The two-faceted profiling offers comprehensive insights into the memory behavior of Java applications, as it is composed of high-level and low-level metrics obtained through a Java object profiler (NUMAProfiler) and a microarchitectural event profiler (PerfUtil) of MaxineVM, respectively. +By using this profiling methodology we classify the Dacapo and Renaissance applications regarding their intensity in object allocations, object accesses, LLC, and main memory pressure. +In addition, several other aspects such as the JVM impact on the memory behavior of the application are discussed.

+
+ + +

Improving Garbage Collection Observability with Performance Tracing

+

+Debugging garbage collectors for performance and correctness is notoriously difficult. +Among the arsenal of tools available to systems engineers, support for one of the most +powerful, tracing, is lacking in most garbage collectors. Instead, engineers must rely on +counting, sampling, and logging. Counting and sampling are limited to statistical analyses while logging is limited to hard-wired metrics. +This results in cognitive friction, +curtailing innovation and optimization. +

+

+We demonstrate that tracing is well suited to GC performance debugging. +We leverage the modular design of MMTk to deliver a powerful VM and collector-neutral tool. +We find that tracing allows: + cheap insertion of tracepoints—just 14 lines of code and no measurable run-time overhead, + decoupling of the declaration of tracepoints from tracing logic, + high fidelity measurement able to detect subtle performance regressions, while also allowing + interrogation of a running binary. +

+

+Our tools crisply highlight several classes of +performance bug, such as poor scalability in multi-threaded GCs, and +lock contention in the allocation sequence. +These observations uncover optimization opportunities in collectors, +and even reveal bugs in application programs. +

+

+We showcase tracing as a powerful tool for GC designers and +practitioners. +Tracing can uncover missed opportunities and lead to novel +algorithms and new engineering practices. +

+
+ + +

Don’t Trust Your Profiler: An Empirical Study on the Precision and Accuracy of Java Profilers

+

To identify optimisation opportunities, +Java developers often use +sampling profilers +that attribute +a percentage of run time +to the methods of a program. +Even so these profilers use sampling, +are probabilistic in nature, +and may suffer for instance from safepoint bias, +they are normally considered to be relatively reliable. +However, unreliable or inaccurate profiles +may misdirect developers +in their quest to resolve performance issues +by not correctly identifying +the program parts +that would benefit most +from optimisations. +

+

+With the wider adoption of profilers +such as async-profiler and Honest Profiler, +which are designed to avoid the safepoint bias, +we wanted to investigate how precise and accurate Java +sampling profilers are today. +We investigate the precision, reliability, accuracy, and overhead +of async-profiler, Honest Profiler, Java Flight Recorder, +JProfiler, perf, and YourKit, +which are all actively maintained. +We assess them on the fully deterministic +Are We Fast Yet benchmarks to have a stable foundation for the probabilistic +profilers. +

+

+We find that profilers are relatively reliable +over 30 runs and normally report the same hottest method. +Unfortunately, this is not true for all benchmarks, +which suggests their reliability may be application-specific. +Different profilers also report +different methods as hottest and cannot reliably +agree on the set of top 5 hottest methods. +On the positive side, +the average run time overhead is in the range of 1% to 5.4% +for the different profilers. +

+

+Future work should investigate how results +can become more reliable, +perhaps by reducing the observer effect of profilers +by using optimisation decisions of unprofiled runs +or by developing a principled approach +of combining multiple profiles that +explore different dynamic optimisations.

+
+ + +

Heap Size Adjustment with CPU Control

+

This paper explores automatic heap sizing where developers let the frequency of GC expressed as a target overhead of the application's CPU utilisation, control the size of the heap, as opposed to the other way around. Given enough headroom and spare CPU, a concurrent garbage collector should be able to keep up with the application's allocation rate, and neither the frequency nor duration of GC should impact throughput and latency. Because of the inverse relationship between time spent performing garbage collection and the minimal size of the heap, this enables trading memory for computation and conversely, neutral to an application's performance. +

+

+We describe our proposal for automatically adjusting the size of a program's heap based on the CPU overhead of GC. We show how our idea can be relatively easily integrated into ZGC, a concurrent collector in OpenJDK, and study the impact of our approach on memory requirements, throughput, latency, and energy.

+
+ +

SESSION: Session 4

+

Comparing Rapid Type Analysis with Points-To Analysis in GraalVM Native Image

+

Whole-program analysis is an essential technique that enables advanced compiler optimizations. An important example of such a method is points-to analysis used by ahead-of-time (AOT) compilers to discover program elements (classes, methods, fields) used on at least one program path. GraalVM Native Image uses a points-to analysis to optimize Java applications, which is a time-consuming step of the build. We explore how much the analysis time can be improved by replacing the points-to analysis with a rapid type analysis (RTA), which computes reachable elements faster by allowing more imprecision. We propose several extensions of previous approaches to RTA: making it parallel, incremental, and supporting heap snapshotting. We present an extensive experimental evaluation of the effects of using RTA instead of points-to analysis, in which RTA allowed us to reduce the analysis time for Spring Petclinic (a popular demo application of the Spring framework) by 64% and the overall build time by 35% at the cost of increasing the image size due to the imprecision by 15%.

+
+ + +

Unified Shared Memory: Friend or Foe? Understanding the Implications of Unified Memory on Managed Heaps

+

Adopting heterogeneous execution on GPUs and FPGAs in managed runtime systems, such as Java, is a challenging task due to the complexities of the underlying virtual machine. The majority of the current work has been focusing on compiler toolchains to solve the challenge of transparent just-in-time compilation of different code segments onto the accelerators. However, apart from providing automatic code generation, another paramount challenge is the seamless interoperability between the host memory manager and the Garbage Collector (GC). Currently, heterogeneous programming models that run on top of managed runtime systems, such as Aparapi and TornadoVM, need to block the GC when running native code (e.g, JNI code) in order to prevent the GC from moving data while the native code is still running on the hardware accelerator. +

+

+To tackle the inefficacy of locking the GC while the GPU operates, this paper proposes a novel Unified Memory (UM) memory allocator for heterogeneous programming frameworks for managed runtime systems. In this paper, we show how, by providing small changes to a Java runtime system, automatic memory management can be enhanced to perform object reclamation not only on the host, but also on the device. This is done by allocating the Java Virtual Machine's object heap in unified memory which is visible to all hardware accelerators. In this manner -although explicit data synchronization between the host and the device is still required to ensure data consistency- we enable transparent page migration of Java heap-allocated objects between the host and the accelerator, since our UM system is aware of pointers and object migration due to GC collections. This technique has been implemented in the context of MaxineVM, an open source research VM for Java written in Java. We evaluated our approach on a discrete and an integrated GPU, showcasing under which conditions UM can benefit execution across different benchmarks and configurations.We concluded that when hardware acceleration is not employed, UM does not pose significant overheads unless memory intensive workloads are encountered which can exhibit up to 12% (worst case) and 2% (average) slowdowns. In addition, if hardware acceleration is used, UM can achieve up to 9.3x speedup compared to the non-UM baseline implementation for integrated GPUs.

+
+ + +

Beyond RSS: Towards Intelligent Dynamic Memory Management (Work in Progress)

+

The main goal of dynamic memory allocators is to minimize memory fragmentation. Fragmentation stems from the interaction between workload behavior and allocator policy. There are, however, no works systematically capturing said interaction. We view this gap as responsible for the absence of a standardized, quantitative fragmentation metric, the lack of workload dynamic memory behavior characterization techniques, and the absence of a standardized benchmark suite targeting dynamic memory allocation. Such shortcomings are profoundly asymmetric to the operation’s ubiquity.

This paper presents a trace-based simulation methodology for constructing representations of workload-allocator interaction. We use two-dimensional rectangular bin packing (2DBP) as our foundation. 2DBP algorithms minimize their products’ makespan, but virtual memory systems employing demand paging deem such a criterion inappropriate. We see an allocator’s placement decisions as a solution to a 2DBP instance, optimizing some unknown criterion particular to that allocator’s policy. Our end product is a data structure by design concerned with events residing entirely in virtual memory; no information on memory accesses, indexing costs or any other factor is kept.

We bootstrap our contribution’s utility by exploring its relationship to maximum resident set size (RSS). Our baseline is the assumption that less fragmentation amounts to smaller peak RSS. We thus define a fragmentation metric in the 2DBP substrate and compute it for both single- and multi-threaded workloads linked to 7 modern allocators. We also measure peak RSS for the resulting pairs. Our metric exhibits a monotonic relationship with memory footprint 94% of the time, as inferred via two-tailed statistical hypothesis testing with at least 99% confidence.

+
+ + +

Towards Safe HPC: Productivity and Performance via Rust Interfaces for a Distributed C++ Actors Library (Work in Progress)

+

In this work-in-progress research paper, we make the case for using Rust to develop applications in the High Performance Computing (HPC) domain which is critically dependent on native C/C++ libraries. This work explores one example of Safe HPC via the design of a Rust interface to an existing distributed C++ Actors library. This existing library has been shown to deliver high performance to C++ developers of irregular Partitioned Global Address Space (PGAS) applications. +

+

+Our key contribution is a proof-of-concept framework to express parallel programs safe-ly in Rust (and potentially other languages/systems), along with a corresponding study of the problems solved by our runtime, the implementation challenges faced, and user productivity. We also conducted an early evaluation of our approach by converting C++ actor implementations of four applications taken from the Bale kernels to Rust Actors using our framework. Our results show that the productivity benefits of our approach are significant since our Rust-based approach helped catch bugs statically during application development, without degrading performance relative to the original C++ actor versions.

+
+ + +

Generating Java Interfaces for Accessing Foreign Objects in GraalVM (Work in Progress)

+

Language interoperability (e.g., calling Python methods from Java programs) is a critical challenge in software development, often leading to code inconsistencies, human errors, and reduced readability. +

+

+This paper presents a work-in-progress project aimed at addressing this issue by providing a tool that automates the generation of Java interfaces for accessing data and methods written in other languages. +

+

+Using existing code analysis techniques the tool aims to produce easy to use abstractions for interop, intended to reduce human error and to improve code clarity. Although the tool is not yet finished, it has already shown promising results. Initial evaluations demonstrate its ability to identify language-specific features and automatically generate equivalent Java interfaces. This allows developers to efficiently integrate code written in foreign languages into Java projects while maintaining code readability and minimizing errors.

+
+ +

SESSION: Posters

+

Diagnosing Compiler Performance by Comparing Optimization Decisions (Poster Abstract)

+

This is an abstract accompanying a poster and a full paper. We introduce an approach to diagnose performance issues in dynamic compilers by logging and comparing optimization decisions.

+
+ + +

CloudJIT: A Just-in-Time FaaS Optimizer (Poster Abstract)

+

Function-as-a-Service provides attractive solutions to execute fine-grained and short-lived functions. Functions are typically developed in a managed language and execute atop a language runtime. However, traditional runtimes are designed for peak performance as considerable time is spent profiling and Just-in-Time compiling code. We observe that short-lived FaaS workloads do not fit this profile. +

+

+We propose CloudJIT, a self-optimizing FaaS platform that takes advantage of Ahead-of-Time compilation to achieve reduced startup latency and instantaneous peak performance with a smaller memory footprint. Our preliminary analysis shows that optimizing a small fraction of functions positively affects a majority of cold starts in a realistic environment.

+
+ + +

Don’t Trust Your Profiler: An Empirical Study on the Precision and Accuracy of Java Profilers (Poster Abstract)

+

To identify optimisation opportunities, Java developers often +use sampling profilers that attribute a percentage of run +time to the methods of a program. Even so these profilers +use sampling, are probabilistic in nature, and may suffer for +instance from safepoint bias, they are normally considered +to be relatively reliable. However, unreliable or inaccurate +profiles may misdirect developers in their quest to resolve +performance issues by not correctly identifying the program +parts that would benefit most from optimisations. +With the wider adoption of profilers such as async-profiler +and Honest Profiler, which are designed to avoid the safepoint bias, we wanted to investigate how precise and accurate Java sampling profilers are today. In this Poster, we investigate +the precision, reliability, accuracy, and overhead of async-profiler, Honest Profiler, Java Flight Recorder, JProfiler, perf, +and YourKit, which are all actively maintained. We assess +them on the fully deterministic Are We Fast Yet benchmarks +to have a stable foundation for the probabilistic profilers. +We find that profilers are relatively reliable over 30 runs +and normally report the same hottest method. Unfortunately, +this is not true for all benchmarks, which suggests their +reliability may be application-specific. Different profilers +also report different methods as hottest and cannot reliably +agree on the set of top 5 hottest methods. On the positive +side, the average run time overhead is in the range of 1% to +5.4% for the different profilers. +Future work should investigate how results can become +more reliable, perhaps by reducing the observer effect of profilers by using optimisation decisions of unprofiled runs or by developing a principled approach of combining multiple +profiles that explore different dynamic optimisations.

+
+ + +

Capable VMs Project Overview (Poster Abstract)

+

In this poster, we will outline the scope and contributions of the Capable +VMs project, in the framework of the UKRI Digital Security by Design programme.

+
+ +
\ No newline at end of file diff --git a/OpenTOC/onward23.html b/OpenTOC/onward23.html new file mode 100644 index 0000000..5911986 --- /dev/null +++ b/OpenTOC/onward23.html @@ -0,0 +1,232 @@ +Onward! 2023: Proceedings of the 2023 ACM SIGPLAN International Symposium on New Ideas, New Paradigms, and Reflections on Programming and Software

Onward! 2023: Proceedings of the 2023 ACM SIGPLAN International Symposium on New Ideas, New Paradigms, and Reflections on Programming and Software

+ Full Citation in the ACM Digital Library +

SESSION: Papers

+

Scalable Spreadsheet-Driven End-User Applications with Incremental Computation

+

Spreadsheets are a popular programming model among both novice and advanced users. +It allows for quick development of computational tasks over the user's data set. +It has also been suggested as a model for lightweight, low-code development of small-scale personal and collaborative applications for managing data. +A barrier is hit when trying to scale up these applications: as the volume of the data grows, performance of spreadsheet computations degrades noticeably, making their maintenance more difficult and frustrating. +This paper explores one aspect in which spreadsheets can be boosted significantly - by making computations more incremental, such that small changes to the data would incur a respectively small cost of update. +This is particularly interesting in the context of aggregate operations - applied to sets of data elements, producing a single value, such as their sum or average. +We propose a compilation phase in which a compiler transforms a spreadsheet table into a program that accepts a stream of changes and produces a stream of updates. +We show how to adapt classical results from finite differencing to this interesting modern scenario, and demonstrate that it yields asymptotic improvements to resource usage.

+
+ + +

Towards an Industrial Stateful Software Rejuvenation Toolchain using Model Learning

+

We present our vision for creating an industrial legacy software rejuvenation toolchain. The goal is to semi automatically remove code smells from stateful software used in Cyber Physical Systems (CPS). Compared to existing tools that remove code smells, our toolchain can remove more than one type of code smell. Additionally, our approach supports multiple programming languages because we use abstract models obtained by means of model learning. Supporting more than one programming language is often lacking in state of art refactoring tools.

+
+ + +

Cloning and Beyond: A Quantum Solution to Duplicate Code

+

Quantum computers are becoming a reality. The advantage of quantum computing is that it has the potential to solve computationally complex problems in a fixed amount time, independent of the size of the problem. However, the kinds of problems for which these computers are a good fit, and the ways to express those problems, are substantially different from the kinds of problems and expressions used in classical computing. Quantum annealers, in particular, are currently the most promising and available quantum computing devices in the short term. However, they are also the most foreign compared to classical programs, as they require a different kind of computational thinking. +In order to ease the transition into this new world of quantum computing, we present a novel quantum approach to a well-known software problem: code clone detection. We express code clone detection as a subgraph isomorphism problem that is mapped into a quadratic optimization problem, and solve it using a DWave quantum annealing computer. We developed a quantum annealing algorithm that compares Abstract Syntax Trees (AST) and reports an energy value that indicates how similar they are. +

+

+The motivation behind this research goes well beyond code duplicate detection: our approach paves the way into how to express software engineering problems as optimization problems that can be solved by quantum annealers.

+
+ + +

Trustworthy Formal Natural Language Specifications

+

Interactive proof assistants are computer programs carefully constructed to check a human-designed proof of a mathematical claim with high confidence in the implementation. However, this only validates truth of a formal claim, which may have been mistranslated from a claim made in natural language. This is especially problematic when using proof assistants to formally verify the correctness of software with respect to a natural language specification. The translation from informal to formal remains a challenging, time-consuming process that is difficult to audit for correctness. +

+

+This paper shows that it is possible to build support for specifications written in expressive subsets of natural language, within existing proof assistants, consistent with the principles used to establish trust and auditability in proof assistants themselves. We implement a means to provide specifications in a modularly extensible formal subset of English, and have them automatically translated into formal claims, entirely within the Lean proof assistant. Our approach is extensible (placing no permanent restrictions on grammatical structure), modular (allowing information about new words to be distributed alongside libraries), and produces proof certificates explaining how each word was interpreted and how the sentence's structure was used to compute the meaning. +

+

+We apply our prototype to the translation of various English descriptions of formal specifications from a popular textbook into Lean formalizations; all can be translated correctly with a modest lexicon with only minor modifications related to lexicon size.

+
+ + +

Code Merging using Transformations and Member Identity

+

Conventionally, merging code files is performed using generic line-based merging algorithms (e.g., diff3) that are unaware of the syntax and semantics of the programming language, outputting conflicts that could be avoided. Structured and semistructured merging techniques are capable of reducing conflicts, but they still suffer from false positives (conflicts that could be avoided) and false negatives (conflicts that go undetected). We propose a merging technique that combines semistructured and transformation-based strategies, where conflict detection is aware of semantic aspects of the programming language. We extract transformations of two branches and apply a merging process that analyzes incompatible transformations, avoiding false positives and false negatives that occur in existing approaches. We developed Jaid, a prototype merging tool for Java based on the assumption that structural code elements evolve with attached UUIDs (representing identity). We performed an early experiment with 63 merge scenarios from two open-source projects to test the technique and assess its feasibility.

+
+ + +

Time-Awareness in Object Exploration Tools: Toward In Situ Omniscient Debugging

+

Exploration of state and behavior is essential for understanding and debugging object-oriented programs. Many time-related questions about object communication – an object’s history – only arise in the context of a specific error in the here and now. At such a specific point in time, however, it is often distracting to involve omniscient debugging tools such as program tracers, because they do not integrate well with the programmer’s current focus on space-related questions and the informational cues at hand. In this paper, we present a novel way to provide a tangible, consolidated notion of both space and time in object exploration tools to make it more likely that programmers will use the available means to explore the evolution of particular objects. With programmers remaining informed about and in control of a program’s space and time, we promote the scientific method for debugging and leverage exploratory programming practices. We evaluate our model with hands-on experiences in the Squeak/Smalltalk programming system, using a program tracer that we have integrated into existing exploration tools to promote both spatial and temporal views. We believe that a clear, tangible notion of spacetime can help tool designers provide a better programming experience for those constantly recurring “What happened to this object?” situations.

+
+ + +

Could No-Code Be Code? Toward a No-Code Programming Language for Citizen Developers

+

By 2030 for each filled position in Software Engineering, +two positions would remain unfilled. This already +apparent loss of productivity has the software +industry scrambling to fill the missing positions with +citizen developers---technical people with little or no +programming skills---who would be using No-Code platforms +to program various software solutions in specific domains. +However, currently available platforms have fairly limited +abstractions, lacking the flexibility of a general purpose +programming language. +

+

+To break the No-Code abstraction barrier, a very simple yet +expressive general purpose No-Code programming language +might provide citizen developers with an alternative to +domain-specific No-Code platforms. Unfortunately, these +requirements seem contradictory. Making a language very +simple and specific might render it crippled, thus limited +to a certain domain of problems. Conversely, making a +language very expressive and general, might render it too +complicated for citizen developers. +

+

+In this work we argue that a multi-paradigm minimalist +approach can bridge the gap between simplicity and +expressiveness by including only abstractions considered +intuitive to citizens. As a concrete proof-of-concept, we +present a general purpose programming language designed +for citizen developers that is on the one hand very +powerful and on the other hand very simple. In fact, +this language is so simple that the entire development +is accomplished by flowcharts using mouse actions only, +without typing a single line of code, thus demonstrating +a general purpose No-Code programming language candidate +for citizen developers.

+
+ + +

Concept-Centric Software Development: An Experience Report

+

Developers have long recognized the importance of the concepts underlying the systems they build, and the primary role that concepts play in shaping user experience. To date, however, concepts have tended to be only implicit in software design with development being organized instead around more concrete artifacts (such as wireframes and code modules). +

+

+Palantir, a software company whose data analytics products are widely used by major corporations, recently reworked the internal representation of its software development process to bring concepts to the fore, making explicit the concepts underlying its products, including how they are clustered together, used in applications, and governed by teams. With a centralized repository of concepts, Palantir engineers are able to align products more closely based on shared concepts, evolve concepts in response to user needs, and communicate more effectively with non-engineering groups within the company. +

+

+This paper reports on Palantir's experiences to date, analyzing both successes and challenges, and offers advice to other organizations considering adopting a concept-centric approach to software development.

+
+ + +

Toward Programming Languages for Reasoning: Humans, Symbolic Systems, and AI Agents

+

Integration, composition, mechanization, and AI assisted development are the driving themes in the future of software development. At their core these concepts are rooted in the increasingly important role of computing in our world, the desire to deliver functionality faster, with higher quality, and to empower more people to benefit from programmatic automation. These themes, and how they impact the human developers driving them, are the foundations for the next generation of programming languages. At first glance the needs of mechanization tools, AI agents, and human developers along with the various goals around development velocity, software quality, and software democratization are a broad and seemingly diverse set of needs. However, at their core is a single challenge that, once resolved, enables us to make radical progress in all of these areas.

Our hypothesis is that, fundamentally, software development is a problem of reasoning about code and semantics. This is true for human developers implementing a feature, symbolic tools building models of application behaviour, and even for language based AI agents as they perform tasks. While the particular aspects of reasoning that each agent struggles with varies to some degree, they share many common themes and, surprisingly, most mainstream languages extensively employ (anti)features that make this task harder or infeasible! This paper proposes a novel approach to this challenge – instead of new language features or logical constructs, that add more complexity to what is already a problem of complexity, we propose radical simplification in the form of the Bosque platform and language.

+
+ +

SESSION: Essays

+

Will Code Remain a Relevant User Interface for End-User Programming with Generative AI Models?

+

The research field of end-user programming has largely been concerned with helping non-experts learn to code sufficiently well in order to achieve their tasks. Generative AI stands to obviate this entirely by allowing users to generate code from naturalistic language prompts. In this essay, we explore the extent to which "traditional" programming languages remain relevant for non-expert end-user programmers in a world with generative AI. We posit the "generative shift hypothesis": that generative AI will create qualitative and quantitative expansions in the traditional scope of end-user programming. We outline some reasons that traditional programming languages may still be relevant and useful for end-user programmers. We speculate whether each of these reasons might be fundamental and enduring, or whether they may disappear with further improvements and innovations in generative AI. Finally, we articulate a set of implications for end-user programming research, including the possibility of needing to revisit many well-established core concepts, such as Ko's learning barriers and Blackwell's attention investment model.

+
+ + +

Whither Problem-Solving Environments?

+

During the 1990s and first decade of the 2000s, problem-solving environments (PSEs) were a topic of research among a community with the vision to create software systems “with all of the computational facilities necessary to solve a target class of problems.” Use of the term has since declined, with fewer papers focused on core PSE research topics. What happened? Did we achieve the design vision for PSEs through other means – namely computational notebooks – or is there more to do? In this essay, we explore the history and objectives of PSE research, the rise of computational notebooks, whether they achieve these objectives, and why the time is right to renew our PSE research efforts.

+
+ + +

Sharing a Perspective on the 𝜆-Calculus

+

The λ-calculus models the core of functional programming languages. This essay discusses a gap between the theory of the λ-calculus and functional languages, namely the fact that the former does not give a status to sharing, the essential ingredient for efficiency in the lattter.

The essay provides an overview of the perspective of the author, who has been and still is studying sharing from various angles. In particular, it explains how sharing impacts the equational and denotational semantics of the λ-calculus, breaking some expected properties, and demanding the development of new, richer semantics of the λ-calculus.

+
+ + +

programmingLanguage as Language;

+

Programming languages are languages --- “unnatural” languages because +they are constructed explicitly; “formal” languages because they rely +on mathematical notations and are described mathematically; “machine” +languages because they are used to communicate with machines. Above +all, programming languages are “human” languages. Programs in +programming languages are spoken and read and written and designed and +debugged and debated by humans, supported by human communities and +forming those communities in turn. Langauge implementations, +being programs themselves, are likewise designed and +debugged and debated by humans. +

+

+ +Programming languages adopt structural elements from natural language, +including syntax, grammar, vocabulary, and even some sentence +structure. +Other aspects of language have received less attention, +including noun declension, verb tense, and situation-appropriate +register. Semiotics +shows how language use can connote and imply, and will lead to +interpretation. Language involves larger level structure too: +conversations, stories, and documents of all kinds. Language supports +both cognitive and affective processes, and is involved in building +mental models that we use to recall, reason, and respond. +

+

+Programming is a complex activity, uncertain yet precise, individual +and social, involving intent and interpretation. +Language is not the accident of programming --- it is the essence.

+
+ +
\ No newline at end of file diff --git a/OpenTOC/paint23.html b/OpenTOC/paint23.html new file mode 100644 index 0000000..4e05f9a --- /dev/null +++ b/OpenTOC/paint23.html @@ -0,0 +1,149 @@ +PAINT 2023: Proceedings of the 2nd ACM SIGPLAN International Workshop on Programming Abstractions and Interactive Notations, Tools, and Environments

PAINT 2023: Proceedings of the 2nd ACM SIGPLAN International Workshop on Programming Abstractions and Interactive Notations, Tools, and Environments

+ Full Citation in the ACM Digital Library +

SESSION: Papers

+

A Penny a Function: Towards Cost Transparent Cloud Programming

+

Understanding and managing monetary cost factors is crucial when developing cloud applications. +However, the diverse range of factors influencing costs for computation, storage, and networking in cloud applications poses a challenge for developers who want to manage and minimize costs proactively. +Existing tools for understanding cost factors are often detached from source code, causing opaqueness regarding the origin of costs. +Moreover, existing cost models for cloud applications focus on specific factors such as compute resources and necessitate manual effort to create the models. +This paper presents initial work toward a cost model based on a directed graph that allows deriving monetary cost estimations directly from code using static analysis. +Leveraging the cost model, we explore visualizations embedded in a code editor that display costs close to the code causing them. +This makes cost exploration an integrated part of the developer experience, thereby removing the overhead of external tooling for cost estimation of cloud applications at development time.

+
+ + +

Branching Compositional Data Transformations in jq, Visually

+

jq is a widely-used command-line tool for filtering and transforming JSON +data, in the vein of sed and awk, including a bespoke programming language +for writing the filters. +The paradigm of that language is unusual: +while its appearance is somewhere between a shell pipeline and JavaScript, +the language is pure-functional and essentially concatenative, +the pipelines branch and interleave data invisibly, +implicit output flattening obscures all these effects, +and most users are unaware of any of its +semantics, +leading to confusion when encountering any of these latent +elements and difficulty in constructing appropriate non-trivial filters, +all the while common debugging techniques are also obstructed by +the paradigm. +These confusions can be eliminated by visually demonstrating the recursively +forking nature of evaluation on actual data, +and allowing manipulations of the program or data to be reflected live, +but no such tool exists for jq or any similar approaches. +We present a visualisation of jq's execution model that makes the branching +nature manifest, illustrating its effects on concrete values provided by the +user, and editing affordances that allow manipulating the program with +reference to real data.

+
+ + +

Toward Studying Example-Based Live Programming in CS/SE Education

+

Source code is inherently abstract. While this is necessary to capture the generality of a program, it poses a barrier to understanding and learning to use the underlying concepts. In education, especially in abstract subjects like maths, the use of concrete examples is considered instrumental to the acquisition of knowledge and a frequently explored direction for teaching computational concepts. Besides concreteness, the importance of examples being close to their abstract descriptions as well as the immediacy of feedback has been highlighted. + + Babylonian Programming (BP) is a type of example-based live programming that fulfills all three criteria by introducing concrete values, moving them as close as possible to the code, and updating them immediately in response to changes of either the example or the code. This makes BP a promising tool in education, yet no studies on the suitability of BP in a learning context have been conducted. Hence, we propose to (1.) investigate usability of state-of-the-art BP to minimize the friction of introducing BP in education, and (2.) measure the learning effectiveness and quality of experience of a BP environment in undergraduate software engineering education. For these studies, we will use the Smalltalk-based Babylonian/S as our environment. + + Besides clearer guidelines on the design of BP and example-based systems in general, we expect to shed light on the qualities that teacher-provided examples need to exhibit and the opportunities for learners to create their own examples during experimentation with unknown concepts.

+
+ + +

Visual Replacements: Cross-Language Domain-Specific Representations in Structured Editors

+

To help developers work at the level of abstraction of their choice, some editors offer to replace parts of source code with domain-specific representations (DSRs). Typically, such replacements are language-specific and optimized to limited use-cases. In this paper, we extend a general-purpose structured editor with visual replacements, a mechanism to replace code of any programming language with DSRs. A visual replacement consists of language-dependent queries to map arbitrary syntax trees and a language-independent DSR of differing abstraction and interactivity, ranging from simple images to graphical user interfaces that modify source code. Our extension synchronizes source code and DSR automatically, while ensuring that language support such as autocompletion and error checking work even inside a replacement. We demonstrate the use and applicability of the replacement mechanism in three case studies.

+
+ + +

Game Engine Wizardry for Programming Mischief

+

Programming grants individuals the capability to design, create, and bring ideas to life. To improve their skills, programmers require powerful languages and programming environments for understanding the impact of gradual code changes. We investigate how modern game engine technology can be leveraged for creating visual input and feedback mechanisms that drive exploratory and live programming. +In this paper, we report experiences on creating a visual programming environment for Machinations, a domain-specific language for game design. We share initial findings on how to automate the development of graph- and tree- based editors in Godot, an open source game engine. Our results show that today’s game engine technology provides a solid foundation for future programming language research.

+
+ + +

PescaJ: A Projectional Editor for Java Featuring Scattered Code Aggregation

+

Conventionally, source code (and its documentation) is simultaneously a storage and editing representation, through files and editors to manipulate them as text. Over the years, IDEs have become increasingly sophisticated, providing features to augment the visible text content with helpful information (e.g., overlay documentation popups, inlay type hints), or on the opposite, to decrease it to reduce clutter (e.g., code folds on imports, documentation, methods, etc). This is a sign that the developers seek more convenient code editing forms than the direct manipulation of text files. We present PescaJ, a prototype projectional editor for Java projects that breaks away from file-oriented source code editing, providing the possibility of forming views that aggregate methods that belong to different classes, where single methods may be simultaneously present and edited in multiple views. Furthermore, we provide documentation editors, also aggregating scattered Javadoc comments, that can be used in parallel with source code editing.

+
+ + +

Transforming an Internal Textual DSL into a Blended Modelling Environment

+

Blended Modelling seamlessly integrates textual and visual representations of models, overcoming the limitations of either individually. This approach allows for greater complexity in coding while also lowering the entry barrier for less-technical users. While existing literature primarily focuses on external Domain Specific Languages (DSLs), there is a gap in the literature when it comes to incorporating internal DSLs into a Blended Modelling Environment, since migrating an internal DSL to an external DSL may not be feasible due to the internal DSL utilising many features of its host language. We focus on leveraging the Axini Modelling Language (AML), an industry-established internal DSL that is based on Ruby. By leveraging Ruby’s meta-language features, we transform AML into a Blended Modelling Environment, enabling real-time synchronization between the textual and visual representations of the model and ensuring instant reflection of updates across both models. To validate the usability of the solution, we conduct two case studies, demonstrating the seamless integration of the textual and visual models. Additionally, we develop a prototype Ruby API, facilitating the transformation of models into a parseable notation and ensuring synchronization of all nodes within the models. We also developed a web application as a platform for the textual and visual models, serving as a foundation for blended modelling environments. This work contributes to the field of blended modelling, providing practical demonstrations and laying the groundwork for further research and development in interactive modelling environments specifically based on internal DSLs.

+
+ +
\ No newline at end of file diff --git a/OpenTOC/rebls23.html b/OpenTOC/rebls23.html new file mode 100644 index 0000000..102040d --- /dev/null +++ b/OpenTOC/rebls23.html @@ -0,0 +1,116 @@ +REBLS 2023: Proceedings of the 10th ACM SIGPLAN International Workshop on Reactive and Event-Based Languages and Systems

REBLS 2023: Proceedings of the 10th ACM SIGPLAN International Workshop on Reactive and Event-Based Languages and Systems

+ Full Citation in the ACM Digital Library +

SESSION: Papers

+

Thorium: A Language for Bounded Verification of Dynamic Reactive Objects

+

Developing reliable reactive software is notoriously difficult – particularly when that software reacts by changing its behavior. Some of this difficulty is inherent; software that must respond to external events as they arrive tends to end up in states that are dependent on the value of that input and its order of arrival. This results in complicated corner cases that can be challenging to recognize. However, we find that some of the complexity is an accident of the features of the programming languages widely used in industry. The loops and subroutines of structured programming are well-suited to data transformation, but poorly capture – and sometimes obscure – the flow of data through reactive programs developed using the inversion-of-control paradigm; an event handler that modifies the data flow tends to be declared closer to the definition of the event that activates it than to the initial definition of the data flow that it modifies. This paper approaches both challenges with a language inspired by the declarative modules of languages SIGNAL and Lustre and the semantics of the SodiumFRP Functional Reactive Programming library with a declarative mechanism for self modification through module substitution. These language features lead to software with a code structure that closely matches the flow of data through the running program and thus makes software easier to understand. Further, we demonstrate how those language features enable a bounded model checking approach that can verify that a reactor meets its requirements or present a counterexample trace, a series of states and inputs that lead to a violation. We analyze the runtime performance of the verifier as a function of model size and trace length.

+
+ + +

Actix-Telepathy

+

The actor programming model supports the development of concurrent applications by encapsulating state and behavior into independent actors. Each actor is a computational entity with strictly private state and behavior. Actors communicate via asynchronous messaging and, in this way, require neither shared memory nor locking. This makes the actor model suitable not only for parallel programming but also for distributed applications engineering. +

+

+The Rust programming language is a statically-typed language that gained a lot of attention in the past years due to its efficient, economical and safe memory management. To ease the development of parallel applications, several actor model frameworks have been built for Rust. However, no actively +maintained Rust actor framework provides the necessary features to write distributed applications. For this reason, we propose an extension for Rust’s Actix library, called Actix-Telepathy, that enables remote messaging and offers clustering support. It allows developers to setup remote actors that can communicate across a computer network with the help of a straight forward and easy to understand interface. Our evaluation demonstrates that Actix-Telepathy competes well in remote messaging performance and memory consumption with other actor libraries, such as Scala’s popular Akka library.

+
+ + +

Realizing Persistent Signals in JavaScript

+

Reactive programming enables declarative descriptions of dependencies between and computations throughout signals, an abstraction of time-varying values. Signals have been extended to persistent signals (an abstraction of time-varying values with their execution histories) to enable them to go back in time with any given time. Currently, this feature is only supported by SignalJ, an extension to Java with signals. This limits the use of persistent signals only within the Java-based applications. This is an undesirable restriction, because mechanisms used in realizing persistent signals are actually language-independent. To tackle this problem, we propose an implementation of persistent signals in JavaScript, which makes application areas of persistent signals broader, including Web-frontend. To realize persistent signals in JavaScript, seamless connections between JavaScript programs that run on restricted environments such as browsers and time-series databases that serve histories of persistent signals are required. It is also desirable to reuse existing JavaScript ecosystem. To address these problems, we design a relay-server-based architecture and realize persistent signals in JavaScript as a DSL library.

+
+ + +

ComPOS: A DSL for Composing IoT Systems with Weak Connectivity

+

Future Internet-of-Things (IoT) systems need to combine heterogeneous IoT components and support weak connectivity. This paper introduces ComPOS, a domain-specific language for composing IoT services into systems. ComPOS is a small language but supports powerful message mediation, using stateful reactions with nested and parallel message sequences and anonymous futures. To deal with weak connectivity, we introduce the notion of abort semantics, i.e., aborting old reactions when a newer message arrives. Alternatives to the abort semantics can be obtained by adding strategy services. We evaluated our approach by implementing seven home automation scenarios.

+
+ + +

Periodic and Aperiodic Task Description Mechanisms in an FRP Language for Small-Scale Embedded Systems

+

This paper presents mechanisms for describing real-time tasks in functional reactive programming (FRP) languages for small-scale embedded systems. +We have designed and implemented Emfrp, an FRP language for resource-constrained systems, and demonstrated its usefulness with several applications. +However, the language requires using external clocks as time-varying values when describing time-dependent behaviors. +In this work, we extend the types of time-varying values that express their update timings to describe periodic and aperiodic tasks. +The extensions enable concise and precise descriptions of various timed behaviors. +We evaluate prototype implementations of the extended language concerning program size, execution time, and power consumption.

+
+ +
\ No newline at end of file diff --git a/OpenTOC/sle23.html b/OpenTOC/sle23.html new file mode 100644 index 0000000..66ff077 --- /dev/null +++ b/OpenTOC/sle23.html @@ -0,0 +1,202 @@ +SLE 2023: Proceedings of the 16th ACM SIGPLAN International Conference on Software Language Engineering

SLE 2023: Proceedings of the 16th ACM SIGPLAN International Conference on Software Language Engineering

+ Full Citation in the ACM Digital Library +

SESSION: Papers

+

Exceptions all Over the Shop: Modular, Customizable, Language-Independent Exception Handling Layer

+

The introduction of better abstractions is at the forefront of research and practice. Among many approaches, domain-specific languages are subject to an increase in popularity due to the need for easier, faster and more reliable application development that involves programmers and domain experts alike. To smooth the adoption of such a language-driven development process, researchers must create new engineering techniques for the development of programming languages and their ecosystems. Traditionally, programming languages are implemented from scratch and in a monolithic way. Conversely, modular and reusable language development solutions would improve maintainability, reusability and extensibility. Many programming languages share similarities that can be leveraged to reuse the same language feature implementations across several programming languages; recent language workbenches strive to achieve this goal by solving the language composition and language extension problems. Yet, some features are inherently complex and affect the behavior of several language features. Most notably, the exception handling mechanism involves varied aspects, such as the memory layout, variables, their scope, up to the execution of each statement that may cause an exceptional event—e.g., a division by zero. In this paper, we propose an approach to untangle the exception handling mechanism dubbed the exception handling layer: its components are modular and fully independent from one another, as well as from other language features. The exception handling layer is language-independent, customizable with regards to the memory layout and supports unconventional exception handling language features. To avoid any assumptions with regards to the host language, the exception handling layer is a stand-alone framework, decoupled from the exception handling mechanism offered by the back-end. Then, we present a full-fledged, generic Java implementation of the exception handling layer. The applicability of this approach is presented through a language evolution scenario based on a Neverlang implementation of JavaScript and LogLang, that we extend with conventional and unconventional exception handling language features using the exception handling layer, with limited impact on their original implementation.

+
+ + +

An Executable Semantics for Faster Development of Optimizing Python Compilers

+

Python is a popular programming language whose performance is known to be uncompetitive in comparison to static languages such as C. Although significant efforts have already accelerated implementations of the language, more efficient ones are still required. The development of such optimized implementations is nevertheless hampered by its complex semantics and the lack of an official formal semantics. We address this issue by presenting an approach to define an executable semantics targeting the development of optimizing compilers. This executable semantics is written in a format that highlights type checks, primitive values boxing and unboxing, and function calls, which are all known sources of overhead. We also present semPy, a partial evaluator of our executable semantics that can be used to remove redundant operations when evaluating arithmetic operators. Finally, we present Zipi, a Python optimizing compiler prototype developed with the aid of semPy. On some tasks, Zipi displays performance competitive with that of state-of-the-art Python implementations.

+
+ + +

Adaptive Structural Operational Semantics

+

Software systems evolve more and more in complex and changing environments, often requiring runtime adaptation +to best deliver their services. When self-adaptation is the main concern of the system, a manual implementation of the underlying feedback loop and trade-off analysis may be desirable. However, the required expertise and substantial development effort make such implementations prohibitively difficult when it is only a secondary concern for the given domain. In this paper, we present ASOS, a metalanguage abstracting the runtime adaptation concern of a given domain in the behavioral semantics of a domain-specific language (DSL), freeing the language user from implementing it from scratch for each system in the domain. We demonstrate our approach on RobLANG, a procedural DSL for robotics, where we abstract a recurrent energy-saving behavior depending on the context. We provide formal semantics for ASOS and pave the way for checking properties such as determinism, completeness, and termination of the resulting self-adaptable language. We provide first results on the performance of our approach compared to a manual implementation of this self-adaptable behavior. We demonstrate, for RobLANG, that our approach provides suitable abstractions for specifying sound adaptive operational semantics while being more efficient.

+
+ + +

A Reference GLL Implementation

+

The Generalised-LL (GLL) context-free parsing algorithm was introduced at the 2009 LDTA workshop, and since then a series of variant algorithms and implementations have been described. There is a wide variety of optimisations that may be applied to GLL, some of which were already present in the originally published form. +

+

+This paper presents a reference GLL implementation shorn of all optimisations as a common baseline for the real-world comparison of performance across GLL variants. This baseline version has particular value for non-specialists, since its simple form may be straightforwardly encoded in the implementer's preferred programming language. +

+

+We also describe our approach to low level memory management of GLL internal data structures. Our evaluation on large inputs shows a factor 3--4 speedup over a naïve implementation using the standard Java APIs and a factor 4--5 reduction in heap requirements. We conclude with notes on some algorithm-level optimisations that may be applied independently of the internal data representation.

+
+ + +

Sharing Trees and Contextual Information: Re-imagining Forwarding in Attribute Grammars

+

It is not uncommon to design a programming language as a core language with additional features that define some semantic analyses, but delegate others to their translation to the core. Many analyses require contextual information, such as a typing environment. When this is the same for a term under a new feature and under that feature's core translation, then the term (and computations over it) can be shared, with context provided by the translation. This avoids redundant, and sometimes exponential computations. This paper brings sharing of terms and specification of context to forwarding, a language extensibility mechanism in attribute grammars. Here context is defined by equations for inherited attributes that provide (the same) values to shared trees. Applying these techniques to the ableC extensible C compiler replaced around 80% of the cases in which tree sharing was achieved by a crude mechanism that prevented sharing context specifications and limited language extensibility. It also replaced all cases in which this mechanism was used to avoid exponential computations and allowed the removal of many, now unneeded, inherited attribute equations.

+
+ + +

Nanopass Attribute Grammars

+

Compilers for feature-rich languages are complex; they perform many analyses and optimizations, and often lower complex language constructs into simpler ones. The nanopass compiler architecture manages this complexity by specifying the compiler as a sequence of many small transformations, over slightly different, but clearly defined, versions of the language that each perform a single straightforward action. This avoids errors that arise from attempting to solve multiple problems at once and allows for testing at each step. +

+

+Attribute grammars are ill-suited for this architecture, primarily because they cannot identify the many versions of the language in a non-repetitive and type-safe way. We present a formulation of attribute grammars that addresses these concerns, called nanopass attribute grammars, that (i) identifies a collection of all language constructs and analyses (attributes), (ii) concisely constructs specific (sub) languages from this set and transformations between them, and (iii) specifies compositions of transformations to form nanopass compilers. The collection of all features can be statically typed and individual languages can be checked for well-definedness and circularity. We evaluate the approach by implementing a significant subset of the Go programming language in a prototype nanopass attribute grammar system.

+
+ + +

Automated Extraction of Grammar Optimization Rule Configurations for Metamodel-Grammar Co-evolution

+

When a language evolves, meta-models and associated gram- mars need to be co-evolved to stay mutually consistent. Previous work has supported the automated migration of a grammar after changes of the meta-model to retain manual optimizations of the grammar, related to syntax aspects such as keywords, brackets, and component order. Yet, doing so required the manual specification of optimization rule con- figurations, which was laborious and error-prone. In this work, to significantly reduce the manual effort during meta-model and grammar co-evolution, we present an automated approach for extracting optimization rule configurations. The inferred configurations can be used to automatically replay optimizations on later versions of the grammar, thus leading to a fully automated migration process for the supported types of changes. We evaluated our approach on six real cases. Full automation was possible for three of them, with agreement rates between ground truth and inferred grammar between 88% and 67% for the remaining ones.

+
+ + +

Reuse and Automated Integration of Recommenders for Modelling Languages

+

Many recommenders for modelling tasks have recently appeared. They use a variety of recommendation methods,tailored to concrete modelling languages. Typically, recommenders are created as independent programs, and subsequently need to be integrated within a modelling tool, incurring in high development effort. Moreover, it is currently not possible to reuse a recommender created for a modelling language with a different notation, even if they are similar. +To attack these problems, we propose a methodology to reuse and integrate recommenders into modelling tools. It considers four orthogonal dimensions: the target modelling language, the tool, the recommendation source, and the recommended items. To make homogeneous the access to arbitrary recommenders, we propose a reference recommendation service that enables indexing recommenders, investigating their properties, and obtaining recommendations likely coming from several sources. Our methodology is supported by IronMan, an Eclipse plugin that automates the integration of recommenders within Sirius and tree-based editors, and can bridge recommenders created for a modelling language for their reuse with a different one. We evaluate the power of the tool by reusing 2 recommenders for 4 different languages, and integrating them into 6 modelling tools.

+
+ + +

GPT-3-Powered Type Error Debugging: Investigating the Use of Large Language Models for Code Repair

+

Type systems are responsible for assigning types to terms in programs. That way, they enforce the actions that can be taken and can, consequently, detect type errors during compilation. However, while they are able to flag the existence of an error, they often fail to pinpoint its cause or provide a helpful error message. Thus, without adequate support, debugging this kind of errors can take a considerable amount of effort. Recently, neural network models have been developed that are able to understand programming languages and perform several downstream tasks. We argue that type error debugging can be enhanced by taking advantage of this deeper understanding of the language’s structure. In this paper, we present a technique that leverages GPT-3’s capabilities to automatically fix type errors in OCaml programs. We perform multiple source code analysis tasks to produce useful prompts that are then provided to GPT-3 to generate potential patches. Our publicly available tool, Mentat, supports multiple modes and was validated on an existing public dataset with thousands of OCaml programs. We automatically validate successful repairs by using Quickcheck to verify which generated patches produce the same output as the user-intended fixed version, achieving a 39% repair rate. In a comparative study, Mentat outperformed two other techniques in automatically fixing ill-typed OCaml programs.

+
+ + +

Temporal Breakpoints for Multiverse Debugging

+

Multiverse debugging extends classical and omniscient debugging to allow the exhaustive exploration of non-deterministic and concurrent systems during debug sessions. +The introduction of user-defined reductions significantly improves the scalability of the approach. +However, the literature fails to recognize the importance of using more expressive logics, besides local-state predicates, to express breakpoints. +In this article, we address this problem by introducing temporal breakpoints for multiverse debugging. +Temporal breakpoints greatly enhance the expressivity of conditional breakpoints, allowing users to reason about the past and future of computations in the multiverse. +Moreover, we show that it is relatively straightforward to extend a language-agnostic multiverse debugger semantics with temporal breakpoints, while preserving its generality. +To show the elegance and practicability of our approach, we have implemented a multiverse debugger for the AnimUML modeling environment that supports 3 different temporal breakpoint formalisms: regular-expressions, statecharts, and statechart-based Büchi automata.

+
+ + +

Cross-Level Debugging for Static Analysers

+

Static analyses provide the foundation for several tools that help developers find problems before executing the program under analysis. Common applications include warning about unused code, deprecated API calls, or about potential security vulnerabilities within an IDE. A static analysis distinguishes itself from a dynamic analysis in that it is supposed to terminate even if the program under analysis does not. In many cases it is also desired for the analysis to be sound, meaning that its answers account for all possible program behavior. Unfortunately, analysis developers may make mistakes that violate these properties resulting in hard-to-find bugs in the analysis code itself. Finding these bugs can be a difficult task, especially since analysis developers have to reason about two separate code-bases: the analyzed code and the analysis implementation. The former is usually where the bug manifests itself, while the latter contains the faulty implementation. A recent survey has found that analysis developers prefer to reason about the analyzed program, indicating that debugging would be easier if debugging features such as (conditional) breakpoints and stepping were also available in the analyzed program. In this paper, we therefore propose cross-level debugging for static analysis. This novel technique moves debugging features such as stepping and breakpoints to the base-layer (i.e., analyzed program), while still making interactions with the meta-layer (i.e., analysis implementation) possible. To this end, we introduce novel conditional breakpoints that express conditions, which we call meta-predicates, about the current analysis’ state. We integrated this debugging technique in a framework for implementing modular abstract interpretation-based static analyses called MAF. Through a detailed case study on 4 real-world bugs taken from the repository of MAF, we demonstrate how cross-level debugging helps analysis developers in locating and solving bugs.

+
+ + +

Cascade: A Meta-language for Change, Cause and Effect

+

Live programming brings code to life with immediate and continuous feedback. To enjoy its benefits, programmers need powerful languages and live programming environments for understanding the effects of code modifications on running programs. Unfortunately, the enabling technology that powers these languages, is missing. Change, a crucial enabler for explorative coding, omniscient debugging and version control, is a potential solution. +We aim to deliver generic solutions for creating these languages, in particular Domain-Specific Languages (DSLs). We present Cascade, a meta-language for expressing DSLs with interface- and feedback-mechanisms that drive live programming. We demonstrate run-time migrations, ripple effects and live desugaring of three existing DSLs. Our results show that an explicit representation of change is instrumental for how these languages are built, and that cause-and-effect relationships are vital for delivering precise feedback.

+
+ + +

Seamless Code Generator Synchronization in the Composition of Heterogeneous Modeling Languages

+

In Software Language Engineering, the composition of heterogeneous languages has become an increasingly relevant research area in recent years. Despite considerable advances in different composition techniques, they mainly focus on composing concrete and abstract syntax, while a thorough yet general concept for synchronizing code generators and their produced artifacts is still missing. Current solutions are either highly generic, typically increasing the complexity beyond their actual value, or strictly limited to specific applications. In this paper, we present a concept for lightweight generator composition, using the symbol tables of heterogeneous modeling languages to exchange generator-specific accessor and mutator information. The information is attached to the symbols of model elements via templates allowing code generators to communicate access routines at the code level without a further contract. Providing suitable synchronization techniques for code generation is essential to enable language composition in all aspects.

+
+ + +

Enabling Blended Modelling of Timing and Variability in EAST-ADL

+

EAST-ADL is a domain-specific modelling language for the design and analysis of vehicular embedded systems. Seamless modelling through multiple concrete syntaxes for the same language, known as blended modelling, offers enhanced modelling flexibility to boost collaboration, lower modelling time, and maximise the productivity of multiple diverse stakeholders involved in the development of complex systems, such as those in the automotive domain. Together with our industrial partner, which is one of the leading contributors to the definition of EAST-ADL and one of its main end-users, we provided prototypical blended modelling features for EAST-ADL. +In this article, we report on our language engineering work towards the provision of blended modelling for EAST-ADL to support seamless graphical and textual notations. Notably, for selected portions of the EAST-ADL language (i.e., timing and variability packages), we introduce ad-hoc textual concrete syntaxes to represent the language's abstract syntax in alternative textual notations, preserving the language's semantics. Furthermore, we propose a full-fledged runtime synchronisation mechanism, based on the standard EAXML schema format, to achieve seamless change propagation across the two notations. As EAXML serves as a central synchronisation point, the proposed blended modelling approach is workable with most existing EAST-ADL tools. The feasibility of the proposed approach is demonstrated through a car wiper use case from our industrial partner - Volvo. Results indicate that the proposed blended modelling approach is effective and can be applied to other EAST-ADL packages and supporting tools.

+
+ + +

Towards Efficient Model Comparison using Automated Program Rewriting

+

Model comparison is a prerequisite task for several other model management tasks such as model merging, model differencing etc. We present a novel approach to efficiently compare models using programs written in a rule-based model comparison language. As the comparison is done at the model element level, and each element needs to be traversed and compared with its corresponding elements, the execution of these comparison algorithms can be computationally expensive for larger models. In this paper, we present an efficient comparison approach which provides an automated rewriting facility to compare (both homogeneous and heterogeneous) models, based on static program analysis. Using this analysis, we reduce the search space by pre-filtering/indexing model elements, before actually comparing them. Moreover, we reorder the comparison match rules according to the dependencies between these rules to +reduce the cost of jumping between rules. Our experiments demonstrate that the proposed model comparison approach delivers significant performance benefits in terms of execution time compared to the default ECL execution engine.

+
+ + +

Deriving Integrated Multi-Viewpoint Modeling Languages from Heterogeneous Modeling Languages: An Experience Report

+

In modern systems engineering, domain experts increasingly utilize models to define domain-specific viewpoints in a highly interdisciplinary context. Despite considerable advances in developing model composition techniques, their integration in a largely heterogeneous language landscape still poses a challenge. Until now, composition in practice mainly focuses on developing foundational language components or applying language composition in smaller scenarios, while the application to extensive, heterogeneous languages is still missing. In this paper, we report on our experiences of composing sophisticated modeling languages using different techniques simultaneously in the context of heterogeneous application areas such as assistive systems and cyber-physical systems in the Internet of Things. We apply state-of-the-art practices, show their realization, and discuss which techniques are suitable for particular modeling scenarios. Pushing model composition to the next level by integrating complex, heterogeneous languages is essential for establishing modeling languages for highly interdisciplinary development teams.

+
+ + +

A Low-Code Platform for Systematic Component-Oriented Language Composition

+

Low-code platforms have gained popularity for accelerating complex software engineering tasks through visual interfaces and pre-built components. Software language engineering, specifically language composition, is such a complex task requiring expertise in composition mechanisms and language workbenches multi-dimensional language constituents (syntax and semantics). This paper presents an extensible low-code platform with a graphical web-based interface for language composition. It enables composition using language components, facilitating systematic composition within language families promoting reuse and streamlining the management, composition, and derivation of domain-specific languages.

+
+ + +

A Tool for the Definition and Deployment of Platform-Independent Bots on Open Source Projects

+

The development of Open Source Software (OSS) projects is a collaborative process that heavily relies on active contributions by passionate developers. Creating, retaining and nurturing an active community of developers is a challenging task; and finding the appropriate expertise to drive the development process is not always easy. To alleviate this situation, many OSS projects try to use bots to automate some development tasks, thus helping community developers to cope with the daily workload of their projects. However, the techniques and support for developing bots is specific to the code hosting platform where the project is being developed (e.g., GitHub or GitLab). Furthermore, there is no support for orchestrating bots deployed in different platforms nor for building bots that go beyond pure development activities. In this paper, we propose a tool to define and deploy bots for OSS projects, which besides automation tasks they offer a more social facet, improving community interactions. The tool includes a Domain-Specific Language (DSL) which allows defining bots that can be deployed on top of several platforms and that can be triggered by different events (e.g., creation of a new issue or a pull request). We describe the design and the implementation of the tool, and illustrate its use with examples.

+
+ + +

Online Name-Based Navigation for Software Meta-languages

+

Software language design and implementation often involve specifications written in various esoteric meta-languages. Language workbenches generally include support for precise name-based navigation when browsing language specifications locally, but such support is lacking when browsing the same specifications online in code repositories.

This paper presents a technique to support precise name-based navigation of language specifications in online repositories using ordinary web browsers. The idea is to generate hyperlinked twins: websites where verbatim copies of specification text are enhanced with hyperlinks between name references and declarations. By generating hyperlinks directly from the name binding analysis used internally in a language workbench, online navigation in hyperlinked twins is automatically consistent with local navigation.

The presented technique has been implemented for the Spoofax language workbench, and used to generate hyperlinked twin websites from various language specifications in Spoofax meta-languages. However, the applicability of the technique is not limited to Spoofax, and developers of other language workbenches could presumably implement similar tooling, to make their language specifications more accessible to those who do not have the workbench installed.

+
+ + +

Practical Runtime Instrumentation of Software Languages: The Case of SciHook

+

Software languages have pros and cons, and are usually chosen accordingly. In this context, it is common to involve different languages in the development of complex systems, each one specifically tailored for a given concern. However, these languages create de facto silos, and offer little support for interoperability with other languages, be it statically or at runtime. In this paper, we report on our experiment on extracting a relevant behavioral interface from an existing language, and using it to enable interoperability at runtime. In particular, we present a systematic approach to define the behavioral interface and we discuss the expertise required to define it. We illustrate our work on the case study of SciHook, a C++ library enabling the runtime instrumentation of scientific software in Python. We present how the proposed approach, combined with SciHook, enables interoperability between Python and a domain-specific language dedicated to numerical analysis, namely NabLab, and discuss overhead at runtime.

+
+ +
\ No newline at end of file diff --git a/OpenTOC/splash-e23.html b/OpenTOC/splash-e23.html new file mode 100644 index 0000000..2a9d394 --- /dev/null +++ b/OpenTOC/splash-e23.html @@ -0,0 +1,138 @@ +SPLASH-E 2023: Proceedings of the 2023 ACM SIGPLAN International Symposium on SPLASH-E

SPLASH-E 2023: Proceedings of the 2023 ACM SIGPLAN International Symposium on SPLASH-E

+ Full Citation in the ACM Digital Library +

SESSION: Papers

+

Teaching Programming with Graphics: Pitfalls and a Solution

+

Many introductory programming courses employ graphics +libraries that promote engagement and enable fun visuals. +However, student excitement over graphical outputs is not a +guarantee of conceptual understanding of programming, and +graphics may even distract from intended learning outcomes. +Our contribution is twofold. First, we analyze a selection of +existing graphics libraries designed for novice programmers. +We consider how these libraries foster clean decomposition, +direct students’ attention to key content, and manage complexity; we find shortcomings in these respects. These shortcomings involve the libraries’ support for global coordinates +and external graphics, as well as their rich APIs; we argue +that these features, although powerful, are also potential +pitfalls in student learning. Second, we present the design of +a new graphics library, PyTamaro, which avoids the pitfalls +with a minimalist design that eschews coordinates; we also +outline a pedagogical approach that builds on PyTamaro’s +strengths and deliberate limitations. We briefly discuss PyTamaro’s trade-offs in comparison to coordinate-based libraries. +The work reported here paves the way for future empirical +evaluations of PyTamaro and associated teaching practices.

+
+ + +

A Framework for the Localization of Programming Languages

+

Most programming languages are only available in English, which means that speakers of other languages need to learn at least some English before they can learn to program. This creates well-documented barriers to entry into programming. While many educational programming languages are localized in some way (e.g. keywords), they often miss important other aspects (e.g. numerals or word order). This paper describes a framework of 12 aspects of programming languages that can be localized, helping tool designers localize their languages better and educators to make more informed decisions about introductory languages in non-English contexts.

+
+ + +

Centering Humans in the Programming Languages Classroom: Building a Text for the Next Generation

+

This paper is a companion to the author's open-access textbook, "Human-Centered Programming Languages." Beyond the contributions of the textbook itself, this paper contributes a set of textbook design principles for overcoming those limitations and an analysis of students' stated needs and preferences drawn from anonymous course report data for three courses, the last of which was based on notes that became the basis of the textbook. The textbook is intended to be multi-purpose, with its primary audiences being undergraduate and master's-level elective courses on programming languages within computer science, but significant opportunity for cross-use in disciplines ranging from human-computer interaction and software engineering to gender studies and disability studies. The book is intended to be language-agnostic, but the course in which it will be used first is Rust-based.

+
+ + +

Composing Turing Machines in FSM

+

For Computer Science students, designing Turing machines is a Herculean task. Formal Languages and Automata Theory textbooks aid students by introducing a graphical notation for Turing machine composition. The difficulty of the task remains unchanged, because design principles are not emphasized and students rarely have the opportunity to program their designs in a textual programming language which allows them to write unit tests. To aid students that are trained as programmers, FSM--a domain-specific language for the Automata Theory classroom--has been developed. Using FSM, students design, program, validate, and establish the correctness of their Turing machines. Once they are familiar with Turing machines, students are introduced to Turing machine composition much like they are introduced to function composition when they learn to design programs. To compose Turing machines in FSM, there is an embedded domain-specific language that students may use. In this manner, students' training in programming is made relevant in the course. This article discusses how students are taught to design, program, validate, and establish the correctness of composed Turing machines.

+
+ + +

KOGI: A Seamless Integration of ChatGPT into Jupyter Environments for Programming Education

+

The impact of ChatGPT has brought both anxiety and anticipation to schools and universities. Exploring a positive method to improve programming skills with ChatGPT is a new and pressing challenge. +In pursuit of this goal, we have developed KOGI, a learning support system that integrates ChatGPT into the Jupyter environment. This paper demonstrates how KOGI enables students to receive timely advice from ChatGPT in response to errors and other questions they encounter. +

+

+We immediately introduced KOGI in our two introductory courses: Algorithms and Data Science. The introduction of KOGI resulted in a significant decrease in the number of unresolved student errors. In addition, we report on student trends observed in the classroom regarding the type and frequency of help requested. Although our findings are preliminary, they are informative for programming instructors interested in using ChatGPT.

+
+ + +

Exploring Engagement and Self-Efficacy in an Introductory Computer Science Course

+

Introductory computer science courses often pose unique challenges for non-computer science majoring students, and understanding the factors that contribute to these struggles is crucial for enhancing students' learning experiences. This research delves into the engagement and self-efficacy of 14 international undergraduate students enrolled in an introductory computer science course tailored for non-CS majors. We use a combination of an initial online survey and the Experience Sampling Method (ESM) to gather data on students' experiences and perceptions throughout the course. The ESM interviews conducted during students' tutorials offer real-time insight into the fluctuations of their engagement and self-efficacy. Findings reveal a positive correlation between aspects of engagement and self-efficacy, indicating that students' higher levels of engagement coincide with stronger beliefs in their capabilities to succeed in the course. Moreover, we identified course topics with which students were disengaged and that corresponded to lower self-efficacy. By recognizing the challenges faced by non-CS majoring students and the impact of specific course topics and teaching styles on their engagement and self-efficacy, we provide advice for designing tailored interventions and instructional strategies.

+
+ + +

Witter: A Library for White-Box Testing of Introductory Programming Algorithms

+

Software testing is mostly performed in a black-box manner, that is, without incorporating any knowledge of the internal workings of programs into the tests. This practice usually suffices for enterprises and general practitioners, where the focus lies on producing reliable results while most algorithmic tasks are provided by third-party libraries. However, for computer science students and the like, it might not be straightforward to discern the underlying causes of an incorrect test result or to understand why certain algorithmic goals are not met. We present Witter, a software testing library that allows programming educators to define white-box tests for Java source code. Our tests analyze the execution of a method against a reference solution, to verify that the code not only produces correct results but is also in accordance with a desired algorithm behavior.

+
+ +
\ No newline at end of file diff --git a/OpenTOC/splash23.html b/OpenTOC/splash23.html new file mode 100644 index 0000000..bb5f40d --- /dev/null +++ b/OpenTOC/splash23.html @@ -0,0 +1,267 @@ +SPLASH 2023: Companion Proceedings of the 2023 ACM SIGPLAN International Conference on Systems, Programming, Languages, and Applications: Software for Humanity

SPLASH 2023: Companion Proceedings of the 2023 ACM SIGPLAN International Conference on Systems, Programming, Languages, and Applications: Software for Humanity

+ Full Citation in the ACM Digital Library +

SESSION: Doctoral Symposium

+

Remote Just-in-Time Compilation for Dynamic Languages

+

Cloud platforms allow applications to meet fluctuating levels of demand through automatic horizontal scaling. These deployment models are characterized by short-lived applications running in resource-constrained environments. This amplifies the overhead of dynamic languages with just-in-time (JIT) compilation. Dynamic-language runtimes suffer from a warmup phase and resource-usage peaks caused by JIT compilation. Offloading compilation jobs to a dedicated server is a possible mitigation for these problems. We propose leveraging remote JIT compilation as a means to enable coordination between the independent instances. By sharing compilation results, aggregating profiles, and adapting the compiler and compilation policy, we strive to improve the peak performance and further reduce the warmup time of these applications. Additionally, an implementation on top of the Truffle framework enables us to bring these benefits to many popular languages.

+
+ + +

Scaling up Program Synthesis to Efficient Algorithms

+

The automatic synthesis of algorithms can effectively reduce the difficulty of algorithm design. However, multiple challenges exist for synthesizing algorithms. Among them, scalability of the synthesizer is the most prominent one because of the significant complexity of efficient algorithms. To address this scalability challenge, we propose several approaches from two aspects, improving the efficiency of existing program synthesizers and reducing the difficulty of algorithm synthesis by properly using algorithmic knowledge, respectively.

+
+ + +

Large Language Models for Automated Program Repair

+

This paper introduces two methods for automated program repair (APR) utilizing pre-trained language models. The first method demonstrates program repair as a code completion task and is validated on a dataset of Java programs. The second method, Mentat, leverages OCaml’s parser and type system as fault localization techniques to generate prompts for GPT-3, producing candidate patches. Evaluation results show promising repair rates, with 27% and 39.2% effectiveness, respectively. For OCaml, a comparative study employing an automated validation strategy is presented in which the technique outperforms other tools. Language models are effective at APR, enhancing bug fixing and freeing developers to focus on other critical aspects of software engineering.

+
+ + +

Transforming Ideas into Code: Visual Sketching for ML Development

+

We propose a novel code assistant and generation paradigm aimed at closing the gap between visual sketching and code creation for Machine Learning (ML) development. This approach empowers developers and ML practitioners to translate hand-drawn sketches into functional code with enhanced accuracy and usability. Developers are recruited to assess the tool's performance. This research contributes to the future of low-code approaches, facilitating ML application development, and promoting an intuitive and accessible programming environment.

+
+ + +

Semantic Versioning for Python Programs

+

We propose a language-based approach to software + versioning. Unlike the traditional approach of mainstream version control systems, + where each evolution step is represented by a textual diff, we treat + versions as programming elements. Each evolution step, merge operation, + and version relationship, is represented explicitly in the program. + This provides compile time guarantees for safety code reuse from previous versions, as + well as forward and backwards compatibility between versions, allowing clients to use newly introduced code without needing to refactor their program. + By lifting the versioning to the language level, we pave the way for tools that interact with + software repositories to have more insight regarding the evolution of the software semantics.

+
+ + +

Reusing Single-Language Analyses for Static Analysis of Multi-language Programs

+

State-of-the-art software is crafted in multiple programming languages. +Such multi-language software challenges static analyses: +Since many static analyses are focused on analyzing single-language programs, they are inherently unsound or imprecise in analyzing cross-language interaction. +Existing approaches that perform multi-language analysis are not analysis- or language independent and thus lack in extensibility for new analyses and languages. +We will develop an extensible, language-, framework-, and analysis-independent architecture to reuse existing static analyses for analyzing multi-language software. +Our hypotheses are that, our architecture allows reusing existing single-language analyses and improves precision and soundness compared to the state of the art. +We will evaluate our architecture with a points-to and data flow analysis for Java, JavaScript, and C/C++ code and compare it against the state of the art.

+
+ + +

A Pragmatic Approach to Syntax Repair

+

Programming languages share a social and formal heritage. These families were historically divided, but share deep roots, and we argue their destined matrimony heralds important consequences for language design and generative language modeling. In our work, we develop a sociotechnical framework for understanding the dynamics of programming and argue it captures many of the social and formal properties of language acquisition and evolution.

+
+ +

SESSION: SRC

+

Partial Gradual Dependent Type Theory

+

Gradual typing supports imprecise types in the type system, allowing incremental migration from untyped code to typed in the same language. Through the gradual typing approach, our ongoing work proposes a new theory based on the Martin-Löf type theory called Partial Gradual Dependent Type Theory. PGTT supports a gradual step from non-dependently typed code to dependently typed, enhancing the functionality of code reasoning while preserving the usability of widely used non-dependent type systems. PGTT restricts entirely unknown types and only permits dynamic terms on the type indices, making it naturally maintain better properties than existing gradual dependent type theories. It allows us to simplify runtime type checks into type parameter checks and elaborate the surface language into a static, dependently typed language, thereby reducing the performance overhead associated with gradual typing.

+
+ + +

Synthesizing Recursive Programs through Dataflow Constraints

+

Despite great progress in algorithms for synthesizing recursive programs, state of the art approaches continue to have several limitations. Principal among these is their inability to “invent” auxiliary functions. This makes them sensitive to the available set of primitive components. In this paper, we present an alternative approach to recover recursive programs. We develop a system of constraints that characterizes patterns of data flow in the unrollings of a recursive program. Combined with a generator of seed nonrecursive circuits and a constraint solver, these constraints naturally form the basis of a general algorithm to synthesize recursive circuits.

+
+ + +

Modular Educational Languages

+

Teaching novices to program is an unsolved problem. +One part of the problem lies in the fact that industrial languages are used for teaching novices, while they were not made for this purpose. +I am designing a Programming Education Runtime System to easily create modular languages for education. +This system utilizes object algebras, trampolining and algebraic effects and handlers. +It has been used to implement an interpreter for the Hedy programming language. +This implementation has several important advantages over the existing one, such as better debugging support and better integration with the Hedy platform.

+
+ + +

Historiographer: Strongly-Consistent Distributed Reactive Programming with Minimal Locking

+

We propose a novel distributed reactive propagation semantics that provides strong consistency guarantees with minimal locking. This is achieved by decoupling reactive propagation from transaction execution, utilizing reactive histories to avoid propagating in-progress or inconsistent results. We formally define soundness properties in terms of histories, and sketch how our semantics upholds them. We implement Historiographer, a runtime incorporating our methods, and conduct a preliminary evaluation demonstrating performance improvements of up to 38% on select benchmarks.

+
+ + +

Clearing the Trail: Motivations for Maintenance Work in Open Source

+

Introducing new maintainers to established projects is critical to the long-term sustainability of open-source projects. Yet, we have little understanding of what motivates developers to join and maintain already established projects. Previous research on volunteering motivations emphasizes that individuals are motivated by a unique set of factors to volunteer in a specific area, suggesting that the motivations behind open-source contributions also depend on the nature of the work. We aim to determine correlations between types of open-source contributions and their specific motivators through surveys of open-source contributors.

+
+ + +

Design and Implementation of Facets of Dynamic Policies

+

Information Flow Control (IFC) in dynamic contexts is challenging due to different interpretations of security that arise. This paper introduces a modular framework to address this challenge. We present a dynamic floating-label enforcement mechanism that can be instantiated based on the intended security. Our approach formalizes a simply typed λ-calculus, extended with IFC operations, and adopts an epistemic perspective on security definition.

+
+ + +

Towards the Formal Verification of Wigderson’s Algorithm

+

We present progress towards the formal verification of Wigderson’s graph coloring algorithm in Coq. We have created a library of formalized graph theory that aims to bridge the literature gap between introductory material on Coq and large-scale formal developments, while providing a motivating case study. Our library contains over 180 proven theorems. The development is available at https://github.com/siraben/coq-wigderson.

+
+ + +

An Optimal Structure-Aware Code Difference Framework with MaxSAT-Solver

+

The Abstract Syntax Tree (AST) serves as a pivotal representation of program codes, offering a structured and hierarchical view of the program’s syntax. When developers modify code, the underlying AST also evolves to reflect these changes. Tree-diff algorithms, such as truediff and Gumtreediff, are developed to compare different versions of the AST and identify the modifications made between them. However, these heuristics are based on certain vertex matching methods that do not ensure optimality and preciseness. In this study, I propose a novel tree-diff approach that utilizes a MaxSAT (Maximum satisfiability) solver to address this issue. By encoding potential vertex matches and edges with associated costs as a tree-diff SAT problem, the MaxSAT solver effectively minimizes the edit distance and reveals the optimal vertex matching plan.

+
+ + +

Rose: Extensible Autodiff on the Web

+

Automatic differentiation (AD) has become the backbone for a new wave of optimization-driven domains such as computer graphics and machine learning over the past decade. However, existing AD systems face limitations, either lacking support for in-browser development or failing to harness more recent, compiler-based approaches to achieve both expressiveness and size-preserving differentiation. This work introduces Rose, a portable, extensible AD library that runs on the web. Through Rose, we aim to increase accessibility to AD and empower end-user programming in optimization-driven domains. We plan to evaluate Rose by replacing the AD engines of real-world, client-side optimization systems and assess the improvements on the computation power and expressiveness of such systems.

+
+ +

SESSION: Posters

+

Involving Users in Design of a Widely Used Language: A Case of ECMAScript (JavaScript) Standardization

+

We present an overview of primary feedback mechanisms used by Ecma International Technical Committee 39 (TC39), the standardizing body of JavaScript programming language.

+
+ + +

Dynamic Library Compartmentalization

+

Software is composed of different parts with different goals, each with different needs. Security-wise, this means not all necessarily need the same permissions: it can be beneficial to isolate some code such that it has limited control over the process, following the principle of least privilege. Without any sort of compartmentalization, a vulnerability found in a sensitive part of an application means the entire process can get corrupted, as its entire memory is now open to be read and modified by the attacker. +

+

+One notable example of dangerous code is the use of external libraries: using a library implies that it is trusted, as it is run within the program's context and can therefore read and modify any program state. This means malicious or vulnerable code can be introduced to the system this way, which can compromise sensitive information that is present in the process' memory. This begs the question: if parts of the software cannot necessarily be trusted, what can we do to limit their capabilities over the process? +

+

+We propose a new library sandboxing approach, focusing on isolating dynamically loaded libraries. While existing approaches usually leverage static analysis to perform instrumentation at the source level and during build time, we instead strive to work entirely during the program's run time.

+
+ + +

Sui Move: Modern Blockchain Programming with Objects

+

This paper presents Sui Move, a new smart contract language for programming blockchains using objects as an abstraction.

+
+ + +

JaMaBuild: Mass Building of Java Projects

+

Many large-scale Java empirical studies require not only source code but also resulting binaries such as JAR files. Pre-compiled datasets quickly become obsolete, and the creation of a custom corpus for every study is tedious. We present a prototype of JaMaBuild, a tool and a framework for mass building of Java projects from source. Given a list of projects and optional settings, it downloads the projects, filters them by user-definable criteria, builds them using Maven or Gradle, and collects outputs such as JAR files and build logs. Our tool can also be used for local build breakage studies.

+
+ + +

Extensible Testing for Infrastructure as Code

+

Developers automate deployments with +Programming Languages Infrastructure as Code (PL-IaC) +by implementing IaC programs in popular languages +like TypeScript and Python. +Yet, systematic testing---well established for high-velocity software development---is rarely applied to IaC programs +because IaC testing techniques +are either slow or require extensive development effort. +To solve this dilemma, +we develop ProTI, a novel IaC unit testing approach, +and implement it for Pulumi TypeScript. +Our preliminary experiments +with simple type-based test case generators and oracles show +that ProTI can find bugs reliably in a short time, +often without writing any additional testing code. +ProTI's extensible plugin architecture allows +combining, adopting, and experimenting with new approaches, +opening the discussion about novel generators and oracles +for efficient IaC testing.

+
+ + +

A Functional Reactive Programming Language for Wirelessly Connected Shape-Changeable Chiplet-Based Computers

+

This work presents the concept of MorphLang, a functional reactive programming language +tailored for shape-changeable computers, which are built using wirelessly +interconnected chiplets. MorphLang simplifies the programming process for these systems +by concentrating on the basic behaviors of individual nodes and their asynchronous +communication. The language allows for compilation into binary or Arduino formats, and +programs can be transmitted to each node either wirelessly or through physical +connections.

+
+ + +

ReactCOP: Modular and Scalable Web Development with Context-Oriented Programming

+

We present a library named ReactCOP that extends React's +capabilities with support for Context-Oriented Programming. +The library lets developers manage behavioral variations +in React applications through layers, and adapt the +application's behavior dynamically based on different +contexts.

+
+ + +

Safe Combination of Data-Centric and Operation-Centric Consistency

+

Programming distributed systems requires maintaining consistency among data replicas. In recent years, various frameworks have proposed language-level abstractions for this, falling into two fundamental approaches: data-centric and operation-centric solutions. The former allow developers to explicitly assign consistency levels to data, the latter enable attaching consistency constraints to operations. In practice, developers may benefit from both in the same application: data-centric consistency harmonizes well with object-oriented programming, yet one may need the flexibility to access the same data with a different consistency level depending on the operation. Currently, there is no solution that integrates both: it is a conceptual challenge to unify these two models and design a type system capable of ensuring +their correct interaction. +We present ConOpY, a programming language that integrates both data-centric and operation-centric consistency into the same design. The ConOpY type system guarantees the proper usage of consistency levels, preventing consistency violations resulting from an improper mix of consistency models. ConOpY is implemented as a Java extension based on annotations.

+
+ + +

Towards Reusable GUI Structures

+

Graphical user interfaces present data as structures (lists, trees, grids). Convenient features to manipulate these structures are tedious to implement. We are working towards a GUI programming approach, where concise specifications of structures give rise to full-fledged GUIs with a complete set of structure manipulation features.

+
+ + +

Generating Domain-Specific Programs for Diagram Authoring with Large Language Models

+

Large language models (LLMs) can generate programs in general-purpose languages from prose descriptions, but are not trained on many domain-specific languages (DSLs). Diagram authoring with Penrose, a diagramming system using three DSLs, exemplifies the utility of DSL program generation with LLMs, which enables diagram creation from prose. We provide methods to conceptualize and evaluate the structures of one-shot LLM prompts to generate error-free DSL programs and implement Penrose diagram creation from prose using LLMs. We will evaluate our LLM prompt structures by testing prompt variations across different diagramming domains and plan to run a user study to assess the ease of LLM-augmented Penrose diagramming over other tools.

+
+ +
\ No newline at end of file diff --git a/OpenTOC/vmil23.html b/OpenTOC/vmil23.html new file mode 100644 index 0000000..a9e1687 --- /dev/null +++ b/OpenTOC/vmil23.html @@ -0,0 +1,203 @@ +VMIL 2023: Proceedings of the 15th ACM SIGPLAN International Workshop on Virtual Machines and Intermediate Languages

VMIL 2023: Proceedings of the 15th ACM SIGPLAN International Workshop on Virtual Machines and Intermediate Languages

+ Full Citation in the ACM Digital Library +

SESSION: Papers

+

CHERI Performance Enhancement for a Bytecode Interpreter

+

During our port of the MicroPython bytecode interpreter to the CHERI-based Arm Morello platform, we encountered a number of serious performance degradations. This paper explores several of these performance issues in detail, in each case +we characterize the cause of the problem, the fix, and the corresponding interpreter performance improvement over a set of standard Python benchmarks. +

+

+While we recognize that Morello is a prototypical physical instantiation of the CHERI concept, we show that it is possible to eliminate certain kinds of software-induced runtime overhead that occur due to the larger size of CHERI capabilities (128 bits) relative to native pointers (generally 64 bits). +In our case, we reduce a geometric mean benchmark slowdown from 5x (before optimization) to 1.7x (after optimization) relative to AArch64, non-capability, execution. The worst-case slowdowns are greatly improved, from 100x (before optimization) to 2x (after optimization). +

+

+The key insight is that implicit pointer size presuppositions pervade systems code; whereas previous CHERI porting projects highlighted compile-time and execution-time errors exposed by pointer size assumptions, we instead focus on the performance implications of such assumptions.

+
+ + +

Revisiting Dynamic Dispatch for Modern Architectures

+

Since the 1980s, Deutsch-Schiffman dispatch has been the standard method dispatch mechanism for languages like Smalltalk, Ruby, and Python. + While it is a huge improvement over the simple, semantic execution model, it has some significant drawbacks for modern hardware and applications. +

+

+ + This paper proposes an alternative dispatch mechanism that addresses these concerns, with only memory space as a trade-off, that should demonstrate dynamic performance only slightly worse than the best possible with full type information for the program.

+
+ + +

Debugging Dynamic Language Features in a Multi-tier Virtual Machine

+

Multi-tiered virtual-machine (VM) environments with Just-In-Time (JIT) compilers are essential for optimizing dynamic language program performance, but comprehending and debugging them is challenging. +In this paper, we introduce Derir; a novel tool for tackling this issue in the context of Ř, a JIT compiler for R. +Derir demystifies Ř, catering to both beginners and experts. +It allows users to inspect the system's runtime state, make modifications, and visualize contextual specializations. +With a user-friendly interface and visualization features, Derir empowers developers to explore, experiment, and gain insights into the inner workings of a specializing JIT system. +We evaluate the effectiveness and usability of our tool through real-world use cases, demonstrating its benefits in learning as well as debugging scenarios. +We believe that our tool holds promise for enhancing the understanding and debugging of complex VMs.

+
+ + +

Array Bytecode Support in MicroJIT

+

Eclipse OpenJ9 is a Java virtual machine (JVM), which initially interprets Java programs. OpenJ9 uses Just-in-Time (JIT) compilers—like the default Testarossa JIT (TRJIT)—to translate the bytecodes of the Java program into native code, which executes faster than interpreting. TRJIT is an optimizing compiler, which boosts an application’s long-term performance but can increase start-up time due to initial compiling. Despite this overhead, more often than not, start-up time is still improved when compared to an interpreter-only solution. MicroJIT aims to reduce this initial slowdown, making start-up time even quicker. MicroJIT is a non-optim­izing, template-based compiler, which aims to reduce compilation overhead and start-up time. Array bytecodes were not supported in the initial implementation of MicroJIT, forcing them to either be interpreted or compiled using TRJIT. This work implements array bytecodes such as, newarray, aaload, aastore, in MicroJIT and measures their impact on execution of the programs. The implementation is tested with a regression test suite and the experiments are performed on the DaCapo benchmark suite. The results show that TRJIT along with MicroJIT including array bytecodes support is approximately 4.36x faster than the interpreter and 1.02x faster than the MicroJIT without array bytecodes support. These findings highlight the potential of MicroJIT in improving the performance of Java programs by efficiently handling array bytecodes.

+
+ + +

Hybrid Execution: Combining Ahead-of-Time and Just-in-Time Compilation

+

Ahead-of-time (AOT) compilation is a well-known approach to statically compile programs to native code before they are executed. +In contrast, just-in-time (JIT) compilation typically starts with executing a slower, less optimized version of the code and compiles frequently executed methods at run time. +In doing so, information from static and dynamic analysis is utilized to speculate and help generate highly efficient code. +However, generating such an efficient JIT-compiled code is challenging, and this introduces a trade-off between warm-up performance and peak performance. +

+

+In this paper, we present a novel way to execute programs by bringing together the divergence that existed between AOT and JIT compilation. +Instead of having the JIT compiler analyze the program during interpretation to produce optimal code, critical functions are initially executed natively with code produced by the AOT compiler in order to gain a head start. +Thus, we avoid the overhead of JIT compilation for natively executed methods and increase the warm-up performance. +We implemented our approach in GraalVM, which is a multi-language virtual machine based on the Java HotSpot VM. +Improvements in warm-up performance show a speed-up of up to 1.7x.

+
+ + +

Collecting Garbage on the Blockchain

+

We present a garbage collector that is specifically designed for a WebAssembly-based blockchain, such as the Internet Computer. Applications on the blockchain implement smart contracts that may have indefinitely long lifetime and may hold substantial monetary value. This imposes a different set of requirements for garbage collection compared to traditional platforms. In this paper, we explain the differences and show how our garbage collector optimizes towards these goals.

+
+ + +

Beehive SPIR-V Toolkit: A Composable and Functional API for Runtime SPIR-V Code Generation

+

The Standard Portable Intermediate Representation (SPIR-V) is a low-level binary format designed for representing shaders and compute kernels that can be consumed by OpenCL for computing kernels, and Vulkan for graphics rendering. As a binary representation, SPIR-V is meant to be used by compilers and runtime systems, and is usually performed by C/C++ programs and the LLVM software and compiler ecosystem. However, not all programming environments, runtime systems, and language implementations are C/C++ or based on LLVM. +

+

+This paper presents the Beehive SPIR-V Toolkit; a framework that can automatically generate a Java composable and functional library for dynamically building SPIR-V binary modules. The Beehive SPIR-V Toolkit can be used by optimizing compilers and runtime systems to generate and validate SPIR-V binary modules from managed runtime systems. Furthermore, our framework is architected to accommodate new SPIR-V releases in an easy-to-maintain manner, and it facilitates the automatic generation of Java libraries for other standards, besides SPIR-V. The Beehive SPIR-V Toolkit also includes an assembler that emits SPIR-V binary modules from disassembled SPIR-V text files, and a disassembler that converts the SPIR-V binary code into a text file. To the best of our knowledge, the Beehive SPIR-V Toolkit is the first Java programming framework that can dynamically generate SPIR-V binary modules. +

+

+To demonstrate the use of our framework, we showcase the integration of the SPIR-V Beehive Toolkit in the context of the TornadoVM, a Java framework for automatically offloading and running Java programs on heterogeneous hardware. We show that, via the SPIR-V Beehive Toolkit, TornadoVM is able to compile code 3x faster than its existing OpenCL C JIT compiler, and it performs up to 1.52x faster than the existing OpenCL C backend in TornadoVM.

+
+ + +

Gigue: A JIT Code Binary Generator for Hardware Testing

+

Just-in-time compilers are the main virtual machine components responsible for performance. They recompile frequently used source code to machine code directly, avoiding the slower interpretation path. Hardware acceleration and performant security primitives would benefit the generated JIT code directly and increase the adoption of hardware-enforced primitives in a high-level execution component. +

+

+The RISC-V instruction set architecture presents extension capabilities to design and integrate custom instructions. It is available as open-source and several capable open-source cores coexist, usable for prototyping. Testing JIT-compiler-specific instruction extensions would require extending the JIT compiler itself, other VM components, the underlying operating system, and the hardware implementation. As the cost of hardware prototyping is already high, a lightweight representation of the JIT compiler code region in memory would ease prototyping and implementation of new solutions. +

+

+In this work, we present Gigue, a binary generator that outputs bare-metal executable code, representing a JIT code region snapshot composed of randomly filled methods. Its main goal is to speed up hardware extension prototyping by defining JIT-centered workloads over the newly defined instructions. It is modular and heavily configurable to qualify different JIT code regions' implementations from VMs and different running applications. We show how the generated binaries can be extended with three custom extensions, whose execution is guaranteed by Gigue's testing framework. We also present different application case generation and execution on top of a fully-featured RISC-V core.

+
+ + +

Approximating Type Stability in the Julia JIT (Work in Progress)

+

Julia is a dynamic language for scientific computing. For a dynamic language, +Julia is surprisingly typeful. Types are used not only to structure data but +also to guide dynamic dispatch – the main design tool in the language. No +matter the dynamism, Julia is performant: flexibility is compiled away at the +run time using a simple but smart type-specialization based optimization +technique called type stability. Based on a model of a JIT mimicking Julia +from previous works, we present the first algorithm to approximate type +stability of Julia code. Implementation and evaluation of the algorithm is +still a work in progress.

+
+ + +

Transpiling Slang Methods to C Functions: An Example of Static Polymorphism for Smalltalk VM Objects

+

The OpenSmalltalk-VM is written in a subset of Smalltalk +which gets transpiled to C. Developing the VM in Smalltalk +allows to use the Smalltalk developer tooling and brings +a fast feedback cycle. However, transpiling to C requires +mapping Smalltalk constructs, i.e., object-oriented concepts, +to C, which sometimes requires developers to use a different +design than they would use when developing purely in +Smalltalk. +We describe a pragmatic extension for static polymorphism +in Slang, our experience using it as well as the shortcomings +of the new approach. While our solution extends the +concepts developers can express in Slang, which reduces the +burden of finding alternatives to well-known design patterns +and by enabling the use of such patterns the modularity, it +further complicates a fragile, already complicated system. +While our extension solves the task it was designed for, it +needs further enhancements, as does Slang itself in terms +of understandability in the field.

+
+ + +

Extraction of Virtual Machine Execution Traces

+

Debugging virtual machines can be challenging. Advanced debugging techniques using execution trace analysis can simplify debugging, but they often show only the execution of the virtual machine (in terms of machine instructions) and not the execution of the guest program (in terms of VM instructions). Ideally, the virtual machine as well as the guest program should be inspectable simultaneously to quickly locate the bug.

Our approach provides a debugging environment which uses an execution trace of a virtual machine and derives the execution trace of the guest program running on it. The transformation is performed by transformation rules which inspect events from the virtual machine’s execution trace, collect necessary information, and then emit the events of the guest program’s execution trace. By linking both traces, navigation in the virtual machine’s execution trace is greatly simplified. When analyzing a simple virtual machine, our approach causes a 9.6% slowdown and an increase of 22% in memory consumption of the underlying execution trace analysis tool.

+
+ +
\ No newline at end of file diff --git a/_data/OpenTOC.yaml b/_data/OpenTOC.yaml index bc3b4b8..101abd0 100644 --- a/_data/OpenTOC.yaml +++ b/_data/OpenTOC.yaml @@ -1305,3 +1305,47 @@ event: TyDe year: 2023 title: "Proceedings of the 8th ACM SIGPLAN International Workshop on Type-Driven Development" +- + event: MPLR + year: 2023 + title: "Proceedings of the 20th ACM SIGPLAN International Conference on Managed Programming Languages and Runtimes" +- + event: FTSCS + year: 2023 + title: "Proceedings of the 9th ACM SIGPLAN International Workshop on Formal Techniques for Safety-Critical Systems" +- + event: SPLASH-E + year: 2023 + title: "Proceedings of the 2023 ACM SIGPLAN International Symposium on SPLASH-E" +- + event: PAINT + year: 2023 + title: "Proceedings of the 2nd ACM SIGPLAN International Workshop on Programming Abstractions and Interactive Notations, Tools, and Environments" +- + event: REBLS + year: 2023 + title: "Proceedings of the 10th ACM SIGPLAN International Workshop on Reactive and Event-Based Languages and Systems" +- + event: VMIL + year: 2023 + title: "Proceedings of the 15th ACM SIGPLAN International Workshop on Virtual Machines and Intermediate Languages" +- + event: Onward! + year: 2023 + title: "Proceedings of the 2023 ACM SIGPLAN International Symposium on New Ideas, New Paradigms, and Reflections on Programming and Software" +- + event: GPCE + year: 2023 + title: "Proceedings of the 22nd ACM SIGPLAN International Conference on Generative Programming: Concepts and Experiences" +- + event: SLE + year: 2023 + title: "Proceedings of the 16th ACM SIGPLAN International Conference on Software Language Engineering" +- + event: DLS + year: 2023 + title: "Proceedings of the 19th ACM SIGPLAN International Symposium on Dynamic Languages" +- + event: SPLASH + year: 2023 + title: "Companion Proceedings of the 2023 ACM SIGPLAN International Conference on Systems, Programming, Languages, and Applications: Software for Humanity"