Alexandre Bergel

RelationalAI

GitHub Actions (GA) is an orchestration platform that streamlines the automatic execution of software engineering tasks such as building, testing, and deployment. Although GA workflows are the primary means for automation, according to our experience and observations, human intervention is necessary to correct defects, update dependencies, or refac...

Adequately selecting variable names is a difficult activity for practitioners. In 2018, Jaffe et al. proposed the use of statistical machine translation (SMT) to suggest descriptive variable names for decompiled code. A large corpus of decompiled C code was used to train the SMT model. Our paper presents the results of a partial replication of Jaff...

The software engineering community has produced numerous tools, techniques, and methodologies for practitioners to analyze and optimize memory usage during software execution. However, little is known about the actual needs of programmers when analyzing memory behavior and how they use tools to address those needs. We conducted an exploratory study...

Recent research has shown the great potential of automatic feedback in education. This paper presents SOBO, a bot we designed to automatically provide feedback on code quality to undergraduate students. SOBO has been deployed in a course at the KTH Royal Institute of Technology in Sweden with 130+ students. Overall, SOBO has analyzed 1687 GitHub re...

Software visualization is a broad research area whose general goal is to enhance and promote the theory, realization, and evaluation of approaches to visually encode and analyze software systems, including software development practices, evolution, structure, and software runtime behavior. Software visualization is inherently interdisciplinary, dra...

Genetic algorithms are commonly employed to generate unit tests. Automatically generated unit tests are known to be an important asset to identify software defects and define oracles. However, configuring the test generation is a tedious activity for a practitioner due to the inherent difficulty to adequately tuning the generation process. Furtherm...

Some test amplification tools extend a manually created test suite with additional test cases to increase the code coverage. The technique is effective, in the sense that it suggests strong and understandable test cases, generally adopted by software engineers. Unfortunately, the current state-of-the-art for test amplification heavily relies on pro...

Understanding and optimizing memory usage of software applications is a difficult task, usually involving the analysis of large amounts of memory-related complex data. Over the years, numerous software visualizations have been proposed to help developers analyze the memory usage information of their programs. This article reports a systematic liter...

The previous chapters presented primitive shapes that are offered by Roassal. An important asset of Roassal is the composition of visual elements. This chapter reviews the mechanism to build composed shapes from primitives shapes.

A visualization in Roassal is presented in a canvas. The canvas acts as a placeholder for graphical shapes, and shapes may be added to and removed from a canvas. The canvas is modeled using the RSCanvas class, and most of the operations related to a canvas are expressed using messages.

Programming is an important skill needed to tell a computer what it has to do. Effective data visualization cannot be properly exercised without programming. This chapter is an introduction to the Pharo programming language. Although I have tried to make this chapter smooth and easy to read, having some basic programming knowledge will help you und...

Reinforcement learning is an area of machine learning that searches for the behavior of an agent when performing actions in a particular environment. The objective of the behavior is to maximize the notion of cumulative reward by identifying the best action to take for a given environment.

Visualization is central to many domains, including data analysis and artificial intelligence. Nowadays, it has never been so easy to write a visualization. Most programming languages come with several libraries dedicated to visualizing data. As such, the technical aspects necessary to implement a visualization engine and to build a visualization a...

When building a visualization, it is common to map numerical values (e.g., the result of some metrics) or properties to visual attributes. This mapping allows you to compare properties of represented elements easily and visually. Normalizers and scales are essential components of Roassal and provide an API to map a metric or a property to a visual...

Roassal offers a number of layouts to locate shapes in the two-dimensional space provided by the canvas. Layouts have been extensively used in the previous chapters without describing how they operate and how they are configured. This chapter lists the different layouts supported by Roassal and details the layout framework.

Shapes are visual elements meant to be added to a canvas. A shape may be configured using various aspects, including color, border, line thickness, and many others. This chapter details a number of shapes supported by Roassal.

An interactive visualization allows additional information to be presented when a user triggers actions through the mouse or keyboard. Roassal proposes a number of pluggable and extensible interactions, presented in this chapter.

This chapter begins the second part of the book, which focuses on the core of Roassal. This chapter includes an overview of Roassal and its main components. This chapter goes one step further than the previous chapters by listing the essential components of Roassal.

This chapter is an overview of Roassal. This chapter acts as a teaser for Roassal by providing a few compelling examples. The chapter does not go into detail since that is the job of the forthcoming chapters. Many short code snippets are provided and briefly described. You can copy and paste these snippets directly into Pharo and each one illustrat...

This chapter describes an expressive way to build lines in Roassal. The chapter begins by illustrating the difficulties in defining lines. Subsequently, Line Builder is presented to address these difficulties.

GitHub is the most popular source code repository used at the time this chapter was written. A repository on GitHub contains historical information about a project’s source code and it lets anyone contribute through commits. GitHub Actions is a service proposed by GitHub that helps you automate tasks in a software development lifecycle and therefor...

Pharo offers many powerful and extensible software development tools. One of them is the Inspector, designed to inspect any Pharo object. The Inspector is a central tool in Pharo as it allows you to see the internal representation of an object, intimately interact with an object through an evaluation panel, and define visual representations of an o...

Use the Pharo interactive development environment to significantly reduce the cost of creating interactive visualizations. This book shows how Pharo leverages visualization development against traditional frameworks and toolkits. Agile Visualization with Pharo focuses on the Roassal visualization engine and first presents the basic and necessary to...

When working with a complex process, it is difficult to get a clear idea on how exactly changes to the input can impact the output. Visualising how the steps of such process evolves with input can help understanding and/or boost confidence in the produced result. We took a suitable existing industrial process, and created a visualisation for it usi...

Modern programming environments offer the Extract Method refactoring as a way to improve software quality by moving a source code fragment into a new method. This refactoring comes with an immediate positive feedback by shortening the refactored method. It can also increase code re-usage and encourage developers to remove code clones. The impact of...

Java 8 marked a shift in the Java development landscape by introducing functional-like concepts in its stream library. Java developers can now rely on stream pipelines to simplify data processing, reduce verbosity, easily enable parallel processing and increase the expressiveness of their code. While streams have seemingly positive effects in Java...

Assessing code comment quality is known to be a difficult problem. A number of coding style guidelines have been created with the aim to encourage writing of informative, readable, and consistent comments. However, it is not clear from the research to date which specific aspects of comments the guidelines cover (e.g., syntax, content, structure). F...

The success of the CubeSats space missions depends on the ability of performing properly in a harsh environment. A key component in space missions is the flight software, which manages all of the processes executed by the satellite on its onboard computer. Literature shows that CubeSat missions suffer high infant mortality, and many spacecraft fail...

Test amplification is a novel technique which extends a manually created test suite with additional test cases to increase the code coverage. The technique is effective, in the sense that it suggests strong and understandable test cases, generally adopted by software engineers. Unfortunately, the current state-of-the-art for test amplification heav...

Java 8 marked a shift in the Java development landscape by introducing functional-like concepts in its stream library. Java developers can now rely on stream pipelines to simplify data processing, reduce verbosity, easily enable parallel processing and increase the expressiveness of their code. While streams have seemingly positive effects on Java...

Large code refactoring projects can consist of hundreds of refactoring rules that are applied iteratively to make code easier to maintain. Visualising the refactoring process can help engineers and stakeholders understand how chains of refactorings were applied and to gain more confidence in the produced result. An apparently suitable existing visu...

The paper questions whether data-driven and problem-driven models are sufficient for a software to automatically represent a meaningful graphical representation of scientific findings. The paper presents descriptive and prescriptive case studies to understand the benefits and the shortcomings of existing models that aim to provide graphical represe...

Programming is a form of communication between the person who is writing code and the one reading it. Nevertheless, very often developers neglect readability, and even well-written code becomes less understandable as software evolves. Together with the growing complexity of software systems, this creates an increasing need for automated tools for i...

To characterize the building blocks of a legacy software system (e.g., structure, dependencies), programmers usually spend a long time navigating its source code. Yet, modern integrated development environments (IDEs) do not provide appropriate means to eiciently achieve complex software comprehension tasks. To deal with this unfulilled need, we pr...

This chapter illustrates the use of genetic algorithms by solving a number of difficult algorithmic problems. Most of the problems presented in this chapter involve some arithmetic operations and therefore have a mathematical flavor.

This chapter builds a small video game inspired by Nintendo’s Mario Bros. Our version of the game is a simplification of the real Mario Bros game. The purpose of this chapter is to provide a solid and realistic base on which we can build an intelligent artificial player. The goal of this chapter is not to provide a wonderful gaming experience. Inst...

This chapter revises the implementation of our neural network. In this revision, our network will use matrices to compute the forward and backward propagation algorithms. Overall, our matrix-based implementation is composed of two classes, NMLayer and NMNetwork. Since most of the computation is delegated to the matrix library we defined in the prev...

In the previous chapter, we saw how a perceptron operates and how a simple learning algorithm can be implemented. However, the perceptron has some serious limitations, which will motivate us to formulate a more robust artificial neuron, called the sigmoid neuron.

The previous chapter covered the design and implementation of an individual neuron. This chapter builds upon the effort initiated in previous chapters by connecting multiple neurons. We provide a complete implementation of a neural network and a backpropagation algorithm, which brings us to the core of the first part of the book.

The Traveling Salesman Problem (TSP) is a classical algorithm problem. It consists of identifying the shortest possible route between several connected cities. Not only is the problem relevant from an algorithmic point of view, but it also has many concrete applications, like microchip manufacturing, as you will shorty see.

NEAT is an algorithm that builds neural networks following an incremental and evolutionary process. It uses a genetic algorithm to evolve networks. In the very early generations, neural networks are very simple, composed of a few nodes and connections. However, complexity is added in each generation. NEAT supports a number of mutations, and these m...

This chapter covers the third and last part of the book. The book started with the topic of neural networks, which are computational metaphors for the biological brain. Subsequently, the book covered genetic algorithms, computational simulations of species evolution. After these two parts, the question that may naturally be asked is: Is it possible...

Genetic algorithms are often presented as a way to solve a difficult algorithmic problem. This chapter applies a genetic algorithm to help a small robot find an exit. It formulates a simple situation (a robot looking for the exit) as an optimization problem (minimizing the distance between the robot and the exit). This chapter builds a small robot...

The previous chapter presented the infrastructure that models and builds zoomorphic creatures. However, so far, the creature cannot do much: it stands where it was originally located, and we are lucky when it does not fall on its side. This chapter makes the creatures evolve to accomplish a displacement task, such as moving toward a particular dire...

The first part of the book is about neural networks, a computational metaphor about how the brain operates. This chapter, the first of the second part of the book, focuses on evolution. In particular, it will cover genetic algorithms, a computational metaphor for how genetic information is recombined and passed through generations. This algorithm f...

All major animal groups have brains made of neurons. A neuron is a specialized cell that transmits electrochemical stimulation using an axon to other neurons. A neuron receives this nerve impulse via a dendrite. Since the early age of computers, scientists have tried to produce a computational model of a neuron. The perceptron was one of the first...

Understanding the learning algorithm that’s used with neural networks involves a fair dose of mathematical notations. This chapter details some relevant theoretical aspects of the way that neural networks operate. We will therefore review the notions of loss functions and gradient descent. Note that this chapter is by no means a complete descriptio...

Neural networks have an incredibly large range of applications. Classifying data is a prominent one, and this chapter is devoted to it.

Genetic algorithms are often used to simulate aspects of how biological individuals behave. This chapter is about artificial life. It defines and creates what we call zoomorphic creatures. We refer to zoomorphic creatures as virtual beings that own particular traits of biological creatures. As such, a zoomorphic creature can be considered a small d...

In the previous chapters, we presented an implementation of a neural network made of layers and neurons (i.e., instances of NeuronLayer and Neuron). Although instructive, that implementation does not reflect classical ways of implementing a neural network. A layer can be expressed as a matrix of weights and a vector of biases. This is how most libr...

Context: Most modern programming environments support refactorings. Although refactorings are relevant to improve the quality of software source code, they unfortunately suffer from severe usability issues. In particular, the extract method refactoring, one of the most prominent refactorings, has a failure rate of 49% when users attempt to use it....

We introduce AVAR, a prototypical implementation of an agile situated visualization (SV) toolkit targeting liveness, integration, and expressiveness. We report on results of an exploratory study with AVAR and seven expert users. In it, participants wore a Microsoft HoloLens device and used a Bluetooth keyboard to program a visualization script for...

Context Software performance may suffer regressions caused by source code changes. Measuring performance at each new software version is useful for early detection of performance regressions. However, systematically running benchmarks is often impractical (e.g., long running execution, prioritizing functional correctness over non-functional). Obje...

Cover classical algorithms commonly used as artificial intelligence techniques and program agile artificial intelligence applications using Pharo. This book takes a practical approach by presenting the implementation details to illustrate the numerous concepts it explains. Along the way, you’ll learn neural net fundamentals to set you up for prac...

Monitoring software performance evolution is a daunting and challenging task. This paper proposes a lightweight visualization technique that contrasts source code variation with the memory consumption and execution time of a particular benchmark. The visualization fully integrates with the commit graph as common in many software repository managers...

Delivering better flight software is an important concern to improve CubeSat missions success. It has been identified as a key element to enhance team collaboration, increase reusability, reduce the mission risk and facilitate development and operation of new mission concepts, such as satellite mega constellations. An appropriated fight software ar...

Several studies provide the questions developers ask during software evolution tasks, providing foundations for subsequent work. Nevertheless, none of them focus on Live Programming environments that gain in popularity as they are perceived to have a positive effect on programming tasks. Studying the impact of a Live Programming environment on soft...

Performance analysis is an integral part of developing and optimizing parallel applications for high performance computing (HPC) platforms. Hierarchical data from different sources is typically available to identify performance issues or anomalies. Some hierarchical data such as the calling context can be very large in terms of breadth and depth of...

Developers are usually unaware of the impact of code changes to the performance of software systems. Although developers can analyze the performance of a system by executing, for instance, a performance test to compare the performance of two consecutive versions of the system, changing from a programming task to a testing task would disrupt the dev...

Developers are usually unaware of the impact of code changes to the performance of software systems. Although developers can analyze the performance of a system by executing, for instance, a performance test to compare the performance of two consecutive versions of the system, changing from a programming task to a testing task would disrupt the dev...

Context: Live programming environments are gaining momentum across multiple programming languages. A tenet of live programming is a development feedback cycle, resulting in faster development practices. Although practitioners of live programming consider it a positive inclusion in their workflow, no in-depth investigations have yet been conducted o...

This GI-Dagstuhl seminar addressed the problem of visualizing performance-related data of systems and the software that they run. Due to the scale of performance-related data and the open-ended nature of analyzing it, visualization is often the only feasible way to comprehend, improve, and debug the performance behaviour of systems. The rise of clo...

This GI-Dagstuhl seminar addressed the problem of visualizing performance-related data of systems and the software that they run. Due to the scale of performance-related data and the open-ended nature of analyzing it, visualization is often the only feasible way to comprehend, improve, and debug the performance behaviour of systems. The rise of clo...

Context: A common practice in JavaScript development is to ship and deploy an application as a large file, called bundle, which is the result of combining the application code along with the code of all the libraries the application depends on. Despite the benefits of having a single bundle per application, this approach leads to applications being...

Several usability issues (i.e., navigation, occlusion, selection, and text readability) affect the few 3D visualizations proposed to support developers on software engineering tasks. We observe that most 3D software visualizations are displayed on a standard computer screen, and hypothesize that displaying them in immersive augmented reality can he...