20 research outputs found
Project-Team RMoD (Analyses and Language Constructs for Object-Oriented Application Evolution) 2017 Activity Report
This is the yearly report of the RMOD team (http://rmod.inria.fr/). A good way to understand what we are doing
Identifying class name inconsistency in hierarchy: a first simple heuristic
International audienceGiving good class names is an important task. Good programmers often report that they take several attempts to find an adequate one. Often programmers do not name consistently classes within a package, project or hierarchy. This is a problem because it hampers understanding the systems. In this article we present a simple heuristic (a distribution) to characterise class naming. We combine such a heuristic with structural information to identify inconsistent class names. In addition, we use this simple heuristic to give packages a shape. We applied such heuristic to 285 packages in Pharo to identify misnamed classes. Some of these misnamed classes are reported and discussed here
Out-Of-Place debugging: a debugging architecture to reduce debugging interference
Context. Recent studies show that developers spend most of their programming
time testing, verifying and debugging software. As applications become more and
more complex, developers demand more advanced debugging support to ease the
software development process.
Inquiry. Since the 70's many debugging solutions were introduced. Amongst
them, online debuggers provide a good insight on the conditions that led to a
bug, allowing inspection and interaction with the variables of the program.
However, most of the online debugging solutions introduce \textit{debugging
interference} to the execution of the program, i.e. pauses, latency, and
evaluation of code containing side-effects.
Approach. This paper investigates a novel debugging technique called
\outofplace debugging. The goal is to minimize the debugging interference
characteristic of online debugging while allowing online remote capabilities.
An \outofplace debugger transfers the program execution and application state
from the debugged application to the debugger application, both running in
different processes.
Knowledge. On the one hand, \outofplace debugging allows developers to debug
applications remotely, overcoming the need of physical access to the machine
where the debugged application is running. On the other hand, debugging happens
locally on the remote machine avoiding latency. That makes it suitable to be
deployed on a distributed system and handle the debugging of several processes
running in parallel.
Grounding. We implemented a concrete out-of-place debugger for the Pharo
Smalltalk programming language. We show that our approach is practical by
performing several benchmarks, comparing our approach with a classic remote
online debugger. We show that our prototype debugger outperforms by a 1000
times a traditional remote debugger in several scenarios. Moreover, we show
that the presence of our debugger does not impact the overall performance of an
application.
Importance. This work combines remote debugging with the debugging experience
of a local online debugger. Out-of-place debugging is the first online
debugging technique that can minimize debugging interference while debugging a
remote application. Yet, it still keeps the benefits of online debugging ( e.g.
step-by-step execution). This makes the technique suitable for modern
applications which are increasingly parallel, distributed and reactive to
streams of data from various sources like sensors, UI, network, etc
First-Class Undefined Classes for Pharo: From Alternative Designs to a Unified Practical Solution
International audienceLoading code inside a Pharo image is a daily concern for a Pharo developer. Nevertheless, several problems may arise at loading time that can prevent the code to load or even worse let the system in an inconsistent state. In this paper, we focus on the problem of loading code that references a class that does not exist in the system. We discuss the different flavors of this problem, the limitations of the existing Undeclared mechanism and the heterogeneity of Pharo tools to solve it. Then, we propose an unified solution for Pharo that reifies Undefined Classes. Our model of Undefined Classes is the result of an objective selection among different alternatives. We then validate our solution through two cases studies: migrating old code and loading code with circular dependencies. This paper also presents the integration of this solution into Pharo regarding the needed Meta-Object Protocol for Undefined Classes and the required modifications of existing tools
Analysis and exploration for new generation debuggers
International audienceLocating and fixing bugs is a well-known time consuming task. Advanced approaches such as object-centric or back-in-time debuggers have been proposed in the literature, still in many scenarios developers are left alone with primitive tools such as manual breakpoints and execution stepping. In this position paper we explore several advanced on-line debugging techniques such as advanced breakpoints and on-line execution comparison, that could help developers solve complex debugging scenarios. We analyse the challenges and underlying mechanisms required by these techniques. We present some early but promising prototypes we built on the Pharo programming language. We finally identify future research paths by analysing existing research and connecting it to the techniques we presented before
A detailed VM profiler for the Cog VM
International audienceCode profiling enables a user to know where in an application or function the execution time is spent. The Pharo ecosystem offers several code profilers. However, most of the publicly available profilers (MessageTally, Spy, GadgetPro-filer) largely ignore the activity carried out by the virtual machine , thus incurring inaccuracy in the gathered information and missing important information, such as the Just-in-time compiler activity. This paper describes the motivations and the latest improvements carried out in VMProfiler, a code execution pro-filer hooked into the virtual machine, that performs its analysis by monitoring the virtual machine execution. These improvements address some limitations related to assessing the activity of native functions (resulting from a Just-in-time compiler operation): as of now, VMProfiler provides more detailed profiling reports, showing for native code functions in which bytecode range the execution time is spent
Sub-method, partial behavioral reflection with Reflectivity: Looking back on 10 years of use
Context. Refining or altering existing behavior is the daily work of every
developer, but that cannot be always anticipated, and software sometimes cannot
be stopped. In such cases, unanticipated adaptation of running systems is of
interest for many scenarios, ranging from functional upgrades to on-the-fly
debugging or monitoring of critical applications.
Inquiry. A way of altering software at run time is using behavioral
reflection, which is particularly well-suited for unanticipated adaptation of
real-world systems. Partial behavioral reflection is not a new idea, and for
years many efforts have been made to propose a practical way of expressing it.
All these efforts resulted in practical solutions, but which introduced a
semantic gap between the code that requires adaptation and the expression of
the partial behavior. For example, in Aspect-Oriented Programming, a pointcut
description is expressed in another language, which introduces a new distance
between the behavior expression (the Advice) and the source code in itself.
Approach. Ten years ago, the idea of closing the gap between the code and the
expression of the partial behavior led to the implementation of the
Reflectivity framework. Using Reflectivity, developers annotate Abstract Syntax
Tree (AST) nodes with meta-behavior which is taken into account by the compiler
to produce behavioral variations. In this paper, we present Reflectivity, its
API, its implementation and its usage in Pharo. We reflect on ten years of use
of Reflectivity, and show how it has been used as a basic building block of
many innovative ideas.
Knowledge. Reflectivity brings a practical way of working at the AST level,
which is a high-level representation of the source code manipulated by software
developers. It enables a powerful way of dynamically add and modify behavior.
Reflectivity is also a flexible mean to bridge the gap between the expression
of the meta-behavior and the source code. This ability to apply unanticipated
adaptation and to provide behavioral reflection led to many experiments and
projects during this last decade by external users. Existing work use
Reflectivity to implement reflective libraries or languages extensions,
featherweight code instrumentation, dynamic software update, debugging tools
and visualization and software analysis tools.
Grounding. Reflectivity is actively used in research projects. During the
past ten years, it served as a support, either for implementation or as a
fundamental base, for many research work including PhD theses, conference,
journal and workshop papers. Reflectivity is now an important library of the
Pharo language, and is integrated at the heart of the platform.
Importance. Reflectivity exposes powerful abstractions to deal with partial
behavioral adaptation, while providing a mature framework for unanticipated,
non-intrusive and partial behavioral reflection based on AST annotation.
Furthermore, even if Reflectivity found its home inside Pharo, it is not a pure
Smalltalk-oriented solution. As validation over the practical use of
Reflectivity in dynamic object-oriented languages, the API has been ported to
Python. Finally, the AST annotation feature of Reflectivity opens new
experimentation opportunities about the control that developers could gain on
the behavior of their own software
Remarkable Challenges of High-Performance Language Virtual Machines
Language Virtual Machines (VMs) are pervasive in every laptop, server, and smartphone, as is the case with Java or Javascript. They allow application portability between different platforms and better usage of resources. They are used in critical applications such as stock exchange, banking, insurance, and health [25]. Virtual machines are an important asset in companies because they allow the efficient execution of high-level programming languages. Nowadays, they even attract investments from large non-system companies, e.g., Netflix 1 , Meta 2 , Shopify 3 and Amazon 4. VMs achieve high-performance thanks to aggressive optimization techniques that observe and adapt the execution dynamically, either by doing just-in-time compilation [5] or by adapting the memory management strategies at runtime [90, 91]. For all these reasons Virtual Machines are highly-complex engineering pieces, often handcrafted by experts, that mix state-of-the-art compilation techniques with complex memory management that collaborate with the underlying operating systems and hardware. However, besides some well-known techniques that are published in research venues, most knowledge and technology around virtual machines are highly concentrated in large companies such as Microsoft, Google, and Oracle, making Virtual Machine construction difficult, and experiments difficult to reproduce and replicate. Language VMs present many multidisciplinary scientific challenges that appear at the intersection of fields such as hardware, system software, compiler, and software language engineering. This document aims to give a brief overview of the current challenges the VM community faces. To keep this document short, we selected remarkable challenges in managed execution, managed memory, performance evaluation, software engineering and security