27 research outputs found
A Concurrency-Agnostic Protocol for Multi-Paradigm Concurrent Debugging Tools
Today's complex software systems combine high-level concurrency models. Each
model is used to solve a specific set of problems. Unfortunately, debuggers
support only the low-level notions of threads and shared memory, forcing
developers to reason about these notions instead of the high-level concurrency
models they chose.
This paper proposes a concurrency-agnostic debugger protocol that decouples
the debugger from the concurrency models employed by the target application. As
a result, the underlying language runtime can define custom breakpoints,
stepping operations, and execution events for each concurrency model it
supports, and a debugger can expose them without having to be specifically
adapted.
We evaluated the generality of the protocol by applying it to SOMns, a
Newspeak implementation, which supports a diversity of concurrency models
including communicating sequential processes, communicating event loops,
threads and locks, fork/join parallelism, and software transactional memory. We
implemented 21 breakpoints and 20 stepping operations for these concurrency
models. For none of these, the debugger needed to be changed. Furthermore, we
visualize all concurrent interactions independently of a specific concurrency
model. To show that tooling for a specific concurrency model is possible, we
visualize actor turns and message sends separately.Comment: International Symposium on Dynamic Language
Toward a modularization of Pharo: Analysis of the design space for a new module system.
International audienceSmalltalk is a fully reflexive object-oriented programming language created in the early 70's. Over the years, it has been influencing many other programming languages and evolved into many variants. However, it has no notion of visibility, providing a single namespace. Because all classes and global variables were visible from every point of the system, numerous dependencies appeared and it turned into a monolithic system. As a descendant of Smalltalk, Pharo should provide a programming construct to make the platform more modular. Designing such a construct is a challenge because of two migration constraints: it must support circular dependencies and local class extensions. In this context, this article present an analysis of the design space for a module system through three design axis: encapsulation, dependency resolution, and module combination
A Study of Concurrency Bugs and Advanced Development Support for Actor-based Programs
The actor model is an attractive foundation for developing concurrent
applications because actors are isolated concurrent entities that communicate
through asynchronous messages and do not share state. Thereby, they avoid
concurrency bugs such as data races, but are not immune to concurrency bugs in
general. This study taxonomizes concurrency bugs in actor-based programs
reported in literature. Furthermore, it analyzes the bugs to identify the
patterns causing them as well as their observable behavior. Based on this
taxonomy, we further analyze the literature and find that current approaches to
static analysis and testing focus on communication deadlocks and message
protocol violations. However, they do not provide solutions to identify
livelocks and behavioral deadlocks. The insights obtained in this study can be
used to improve debugging support for actor-based programs with new debugging
techniques to identify the root cause of complex concurrency bugs.Comment: - Submitted for review - Removed section 6 "Research Roadmap for
Debuggers", its content was summarized in the Future Work section - Added
references for section 1, section 3, section 4.3 and section 5.1 - Updated
citation
Toward Virtual Machine Adaption Rather than Reimplementation: Adapting SOMns for Grace
We adapt SOMns, a Truffle-based interpreter for Newspeak, to the Grace programming language. We highlight differences between the semantics of these languages and offer preliminary results showing that adaption is possible while retaining performance. The similarities between the languages promote the potential for adaption and code sharing between implementations. Through experimentation we intend to explore how the design of the tailored implementation; the flexibility of the underlying framework; and similarities between languages affect adaptability, and by doing so hope to realize a set of mechanisms that can be easily extended to create optimized virtual machines for object-orientated languages
Towards easy program migration using language virtualization
International audienceMigrating programs between language versions is a daunting task. A developer writes a program in a particular version of a language and cannot foresee future language changes. In this article, we explore a solution to gradual program migration based on virtualization at the programming language level. Our language virtualization approach adds a backwards-compatibility layer on top of a recent language version, allowing developers to load and run old programs on the more recent infrastructure. Developers are then able to migrate the program to the new language version or are able to run it as it is. Our virtualization technique is based on a dynamic module implementation and code intercession techniques. Migrated and non-migrated parts co-exist in the meantime allowing an incremental migration procedure. We validate it by migrating legacy Pharo programs, MuTalk and Fuel
The Grace Programming Language Draft Specification Version 0.3.1261
This is a specification of the Grace Programming Language. This specification is notably incomplete, and everything is subject to change
Object Inheritance Without Classes
Which comes first: the object or the class? Language designers enjoy
the conceptual simplicity of object-based languages (such as Emerald
or Self) while many programmers prefer the pragmatic utility of
classical inheritance (as in Simula and Java). Programmers in
object-based languages have a tendency to build libraries to support
traditional inheritance, and language implementations are often
contorted to the same end. In this paper, we revisit the relationship
between classes and objects. We model various kinds of inheritance in
the context of an object-oriented language whose objects are not
defined by classes, and explain why class inheritance and
initialisation cannot be easily modelled purely by delegation
A Capability-Based Module System for Authority Control
The principle of least authority states that each component of the system should be given authority to access only the information and resources that it needs for its operation. This principle is fundamental to the secure design of software systems, as it helps to limit an application\u27s attack surface and to isolate vulnerabilities and faults. Unfortunately, current programming languages do not provide adequate help in controlling the authority of application modules, an issue that is particularly acute in the case of untrusted third-party extensions.
In this paper, we present a language design that facilitates controlling the authority granted to each application module. The key technical novelty of our approach is that modules are first-class, statically typed capabilities. First-class modules are essentially objects, and so we formalize our module system by translation into an object calculus and prove that the core calculus is type-safe and authority-safe. Unlike prior formalizations, our work defines authority non-transitively, allowing engineers to reason about software designs that use wrappers to provide an attenuated version of a more powerful capability.
Our approach allows developers to determine a module\u27s authority by examining the capabilities passed as module arguments when the module is created, or delegated to the module later during execution. The type system facilitates this by identifying which objects provide capabilities to sensitive resources, and by enabling security architects to examine the capabilities passed into and out of a module based only on the module\u27s interface, without needing to examine the module\u27s implementation code. An implementation of the module system and illustrative examples in the Wyvern programming language suggest that our approach can be a practical way to control module authority
Towards easy program migration using language virtualization
International audienceMigrating programs between language versions is a daunting task. A developer writes a program in a particular version of a language and cannot foresee future language changes. In this article, we explore a solution to gradual program migration based on virtualization at the programming language level. Our language virtualization approach adds a backwards-compatibility layer on top of a recent language version, allowing developers to load and run old programs on the more recent infrastructure. Developers are then able to migrate the program to the new language version or are able to run it as it is. Our virtualization technique is based on a dynamic module implementation and code intercession techniques. Migrated and non-migrated parts co-exist in the meantime allowing an incremental migration procedure. We validate it by migrating legacy Pharo programs, MuTalk and Fuel