In this talk, we present a series of tools to bootstrapping smaller crafted kernel languages.
Smaller kernels allow us to run applications in resources limited environments (IoT).
Also, it allows us to modify and study language modifications and extensions easing the evolution of new and existing languages.
These experiments are performed in a fully debuggable simulated environment, allowing us to overcome common mistakes and problems.
This is not only an experimental environment as it allows us to generate production-ready language kernels.
We use Pharo to generate language kernels that are intended to run on top of the Pharo VM.
These tools are also used to bootstrap bigger systems as Pharo itself.
The current explosion of embedded systems (i.e., IoT, Edge Computing) implies the need for generating tailored and customized software for them. Different approaches have been taken for building, deploying, updating and debugging these systems, although there is still no standard way to do this.
The goal of this talk is to present the tools and techniques necessary for building, debugging, and deploying custom small language kernels.
Kernel languages are generated from a combination of language definition and the description of the elements and processes to generate the runtime.
Kernel languages must be consistent internally and in relation with the environment where they run (e.g. the VM, the OS)
Languages that are bootstrapped from their source code are not new.
However, correctly defining a working consistent language kernel is a complex manual task without support from tools to debug or test before the generation of the language and its deployment.
This complexity limits the study of new languages, the creation of prototypes and the evolution of existing ones.
We present a set of tools to overcome the different difficulties that bootstrapping a reflective language kernel presents. Allowing us to simulate the kernel, debug it, validate it and generate it.
Moreover, our proposed approach offers tools to detect many common mistakes and causes of error.
We center our solution in reflective object-oriented languages that run on top of a VM.
Our tool uses Pharo and generates languages to run on top of its VM.
