Modularity and conventions for maintainable concurrent language implementations: a review of our experiences and practices
---
paper_title: Harnessing emergence for manycore programming: early experience integrating ensembles, adverbs, and object-based inheritance

paper_content:

We believe that embracing nondeterminism and harnessing emergence have great potential to simplify the task of programming manycore processors. To that end, we have designed and implemented Ly, pronounced "Lee", a new parallel programming language built around two new concepts: (i) ensembles which provide for parallel execution and replace all collections and (ii) iterators, and adverbs, which modify the parallel behavior of messages sent to ensembles. The broad issues around programming in this fashion still need investigation, but, after our initial Ly programming experience, we have identified some specific issues that must be addressed in integrating these concepts into an object-based language, including empty ensembles, partial message understanding, non-local returns from ensemble members, and unintended ensembles.
---
paper_title: AmbientTalk: Object-oriented Event-driven Programming in Mobile Ad hoc Networks

paper_content:

In this paper, we describe AmbientTalk: a domain- specific language for orchestrating service discovery and composition in mobile ad hoc networks. AmbientTalk is a distributed object-oriented language whose actor-based, event-driven concurrency model makes it highly suitable for composing service objects across a mobile network. The language is a so-called ambient-oriented programming language which treats network partitions as a normal mode of operation. We describe AmbientTalk's object model, concurrency model and distributed communication model in detail. We also highlight influences from other languages and middleware that have shaped AmbientTalk's design.
---
paper_title: Hosting an object heap on manycore hardware: an exploration

paper_content:

In order to construct a test-bed for investigating new programming paradigms for future "manycore" systems (i.e. those with at least a thousand cores), we are building a Smalltalk virtual machine that attempts to efficiently use a collection of 56-on-chip caches of 64KB each to host a multi-megabyte object heap. In addition to the cost of inter-core communication, two hardware characteristics influenced our design: the absence of hardware-provided cache-coherence, and the inability to move a single object from one core's cache to another's without changing its address. Our design relies on an object table, and the exploitation of a user-managed caching regime for read-mostly objects. At almost every stage of our process, we obtained measurements in order to guide the evolution of our system. The architecture and performance characteristics of a manycore platform confound old intuitions by deviating from both traditional multicore systems and from distributed systems. The implementor confronts a wide variety of design choices, such as when to share address space, when to share memory as opposed to sending a message, and how to eke out the most performance from a memory system that is far more tightly integrated than a distributed system yet far less centralized than in a several-core system. Our system is far from complete, let alone optimal, but our experiences have helped us develop new intuitions needed to rise to the manycore software challenge.
---
paper_title: Cilk: an efficient multithreaded runtime system

paper_content:

Cilk (pronounced “silk”) is a C-based runtime system for multi-threaded parallel programming. In this paper, we document the efficiency of the Cilk work-stealing scheduler, both empirically and analytically. We show that on real and synthetic applications, the “work” and “critical path” of a Cilk computation can be used to accurately model performance. Consequently, a Cilk programmer can focus on reducing the work and critical path of his computation, insulated from load balancing and other runtime scheduling issues. We also prove that for the class of “fully strict” (well-structured) programs, the Cilk scheduler achieves space, time and communication bounds all within a constant factor of optimal. The Cilk runtime system currently runs on the Connection Machine CM5 MPP, the Intel Paragon MPP, the Silicon Graphics Power Challenge SMP, and the MIT Phish network of workstations. Applications written in Cilk include protein folding, graphic rendering, backtrack search, and the *Socrates chess program, which won third prize in the 1994 ACM International Computer Chess Championship.
---
paper_title: Ownership types for flexible alias protection

paper_content:

Object-oriented programming languages allow inter-object aliasing. Although necessary to construct linked data structures and networks of interacting objects, aliasing is problematic in that an aggregate object's state can change via an alias to one of its components, without the aggregate being aware of any aliasing.Ownership types form a static type system that indicates object ownership. This provides a flexible mechanism to limit the visibility of object references and restrict access paths to objects, thus controlling a system's dynamic topology. The type system is shown to be sound, and the specific aliasing properties that a system's object graph satisfies are formulated and proven invariant for well-typed programs.
---
paper_title: Real-world concurrency

paper_content:

In this look at how concurrency affects practitioners in the real world, Cantrill and Bonwick argue that much of the anxiety over concurrency is unwarranted.
---
paper_title: Disentangling Virtual Machine Architecture

paper_content:

Virtual machine (VM) implementations are made of intricately intertwined subsystems, interacting largely through implicit dependencies. As the degree of crosscutting present in VMs is very high, VM implementations exhibit significant internal complexity. This study proposes an architecture approach for VMs that regards a VM as a composite of service modules coordinated through explicit bidirectional interfaces. Aspect-oriented programming techniques are used to establish these interfaces, to coordinate module interaction, and to declaratively express concrete VM architectures. A VM architecture description language is presented in a case study, illustrating the application of the proposed architectural principles.
---
paper_title: PyPy's approach to virtual machine construction

paper_content:

The PyPy project seeks to prove both on a research and a practical level the feasibility of constructing a virtual machine (VM) for a dynamic language in a dynamic language - in this case, Python. The aim is to translate (i.e. compile) the VM to arbitrary target environments, ranging in level from C/Posix to Smalltalk/Squeak via Java and CLI/.NET, while still being of reasonable efficiency within these environments.A key tool to achieve this goal is the systematic reuse of the Python language as a system programming language at various levels of our architecture and translation process. For each level, we design a corresponding type system and apply a generic type inference engine - for example, the garbage collector is written in a style that manipulates simulated pointer and address objects, and when translated to C these operations become C-level pointer and address instructions.
---
paper_title: Co-evolving Annotations and Source Code through Smart Annotations

paper_content:

Annotations are a means to attach additional meta data to the source code of a system. Nowadays, more and more technologies rely on the presence of such annotations in the source code: beyond their use for documentation purposes, annotations impact the behaviour of the system. Since there exists little or no support to make sure that upon evolution of the system, the source code remains correctly annotated, source code can become miss-annotated. This in turn, can result in erroneous behaviour. In this paper we present Smart Annotations, an approach for co-evolving source code and annotations. Our approach enables developers to constrain the use of annotations in the source code and offers tool support to identify conflicts between source code and annotations. To illustrate the use of our approach, we demonstrate its applicability using examples from the domain of aspect-oriented programming and Enterprise Java Beans.
---

Title: Modularity and Conventions for Maintainable Concurrent Language Implementations: A Review of Our Experiences and Practices

Section 1: Context and Contributions
Description 1: This section discusses the background, motivation, and aims of reviewing experiences with the implementation of interpreter-based concurrent and parallel languages and how modularity plays a role in maintainability.

Section 2: Case Study Design
Description 2: This section outlines the design of the case study, including the approach for reviewing general practices applied in language implementations and specific experiments conducted.

Section 3: General Review
Description 3: This section focuses on reviewing the informal implementation aspects such as coding conventions and the influence of parallelism and concurrency on modularization decisions.

Section 4: Experiment Review
Description 4: This section delves into specific experiments to provide deeper insights into how concurrency aspects and parallel execution affect modularization.

Section 5: Case Study Subjects
Description 5: This section provides an overview of the subjects of the case study: AmbientTalk, RoarVM, and SLIP, including specific experiments undertaken with each.

Section 6: Case Study Reviews
Description 6: This section discusses the results of the case study for each language implementation.

Section 7: AmbientTalk
Description 7: This section examines AmbientTalk's implementation, principles guiding its concurrency structure, event loop concurrency design, and overall conclusions.

Section 8: RoarVM
Description 8: This section reviews the RoarVM implementation, focusing on the use of on-demand shared memory, asynchronous message passing, global synchronization, and specific experiments like threads vs. processes and work-stealing scheduler.

Section 9: SLIP
Description 9: This section discusses SLIP's implementation, particularly its modularization approach, memory management, and the experiment on multi-threading.

Section 10: Related Work
Description 10: This section reviews literature related to the modularization of virtual machines and concurrency aspects in system software.

Section 11: Conclusion
Description 11: This section summarizes the findings of the case study, emphasizing that concurrency drives modularization and outlining the techniques that support modular designs for complex systems.