Deep Learning experiments have critical requirements regarding the careful handling of their datasets as well as the efficient and correct usage of APIs that interact with hardware accelerators. On the one hand, software mistakes during data handling can contaminate experiments and lead to incorrect results. On the other hand, poorly coded APIs that interact with the hardware can lead to sub-optimal usage and untrustworthy conclusions. In this work we investigate the use of Linear Logic for the analysis of Deep Learning experiments. We show that primitives and operators of Linear Logic can be used to express: (i) an abstract representation of the control flow of an experiment, (ii) a set of available experimental resources, such as API calls to the underlying data-structures and hardware as well as (iii) reasoning rules about the correct consumption of resources during experiments. Our proposed model is not only lightweight but also easy to comprehend having both a symbolic and a visual component. Finally, its artifacts are themselves proofs in Linear Logic that can be readily verified by off-the-shelf reasoners.

We present a new AI task and baseline solution for Inter-Subjective Reasoning. We define inter-subjective information, to be a mixture of objective and subjective information possibly shared by different parties. Examples may include commodities and their objective properties as reported by IR (Information Retrieval) systems, that need to be cross-referenced with subjective user reviews from an online forum. For an AI system to successfully reason about both, it needs to be able to combine symbolic reasoning of objective facts with the shared consensus found on subjective user reviews. To this end we introduce the NeuroQL dataset and DSL (Domain-specific Language) as a baseline solution for this problem. NeuroQL is a neuro-symbolic language that extends logical unification with neural primitives for extraction and retrieval. It can function as a target for automatic translation of inter-subjective questions (posed in natural language) into the neuro-symbolic code that can answer them.

Following publication of the original article [1], the author noticed that the following lines were missing from the published article. The original article has been corrected.

Since their introduction in 2004, Parsing Expression Grammars (PEGs for short) have been gaining widespread adoption both in industry and academia. More than 400 subsequent works cite B. Ford's original paper, while a total of 29 implementations in 14 different programming languages are reported in active use. Nevertheless reviewing PEG-related bibliography reveals that the original argumentation in favor of PEGs has actually been weakened by subsequent work, regarding basic parsing features such as (a) recursion handling and (b) associativity support. To this day all proposed enhancements either address these issues in isolation or in implementation specific ways. It is still unclear if there is a single way to parse PEGs without facing these issues or introducing implementation directives external to the formalism. Our subsequent analysis takes us a step further, questioning the very core of the initial PEG proposal: (c) by design unambiguous grammars. We then discuss why a form of ordered choice and conditional operators that PEGs advocate are worth saving, but only within a wider synthesis that could address the aforementioned issues. To this end we present our on-going effort with the Gray algorithm and MOGs (Multi-Ordered Grammars), a possible alternative to the PEG and CFG formalisms.

Background. Context-free grammars (CFGs) and Parsing-expression Grammars (PEGs) are the two main formalisms used by formal specifications and parsing frameworks to describe programming languages. They mainly differ in the definition of the choice operator, describing language alternatives. CFGs support the use of non-deterministic choice (i.e., unordered choice), where all alternatives are equally explored. PEGs support a deterministic choice (i.e., ordered choice), where alternatives are explored in strict succession. In practice the two formalisms, are used through concrete classes of parsing algorithms (such as Left-to-right, rightmost derivation (LR) for CFGs and Packrat parsing for PEGs), that follow the semantics of the formal operators. Problem Statement. Neither the two formalisms, nor the accompanying algorithms are sufficient for a complete description of common cases arising in language design. In order to properly handle ambiguity, recursion, precedence or associativity, parsing frameworks either introduce implementation specific directives or ask users to refactor their grammars to fit the needs of the framework/algorithm/formalism combo. This introduces significant complexity even in simple cases and results in incompatible grammar specifications. Our Proposal. We introduce Multi-Ordered Grammars (MOGs) as an alternative to the CFG and PEG formalisms. MOGs aim for a better exploration of ambiguity, ordering, recursion and associativity during language design. This is achieved by (a) allowing both deterministic and non-deterministic choices to co-exist, and (b) introducing a form of recursive and scoped ordering. The formalism is accompanied by a new parsing algorithm (Gray) that extends chart parsing (normally used for Natural Language Processing) with the proposed MOG operators. Results. We conduct two case-studies to assess the expressiveness of MOGs, compared to CFGs and PEGs. The first consists of two idealized examples from literature (an expression grammar and a simple procedural language). The second examines a real-world case (the entire Smalltalk grammar and eleven new Smalltalk extensions) probing the complexities of practical needs. We show that in comparison, MOGs are able to reduce complexity and naturally express language constructs, without resorting to implementation specific directives. Conclusion. We conclude that combining deterministic and non-deterministic choices in a single grammar specification is indeed not only possible but also beneficial. Moreover, augmented by operators for recursive and scoped ordering the resulting multi-ordered formalism presents a viable alternative to both CFGs and PEGs. Concrete implementations of MOGs can be constructed by extending chart parsing with MOG operators for recursive and scoped ordering.

Lan.d.s is a new solution for language design. From general purpose languages like Lise (short for (list (embedding)) to Domain-Specific Languages using the MOODs framework, and everything else in between. Lan.d.s is build around the formalism of Multi-Ordered Grammars, which are a possible alternative to CFGs and PEGs in wider use today. Multi- ordered grammars (or simply MOGs) aim for a better explo- ration of ambiguity, recursion, ordering and associativity during language design. They can be parsed using the Gray algorithm. After parsing in order to ease the production of executable code Lan.d.s introduces the Abstract Syntax Language (ASL), which is an OO solution for compile-time meta-programming. Finally in order to promote language ex- tension and re-use Lan.d.s employs GrammarTraits, as units of composition for both MOG rules and ASL actions.

Cormas (for Common Pool Resources and Multi-Agent Systems) is an Agent-Based Modeling (ABM) platform dedicated to natural and common-pool resources management. As an open-source software, it is used by an international community of researchers willing to understand the relationships between societies and their environment. Cormas is intended to facilitate the design of ABM as well as the monitoring and analysis of agent-based simulation scenarios. From recent years, the development of Cormas has taken an innovative direction more oriented towards participatory modeling, i.e. the collective design of models as an appropriate medium for fostering interdisciplinarity, and interactive simulation involving several stakeholders who interact with a simulation by acting directly on their agents. As our intention is to involve more deeply various types of stakeholders (from farmers to scientists and from technicians to decision makers) into the modeling process, it is necessary to have an easily changeable tool to act on the simulation and to modify the conceptual model on the fly. Cormas benefits from all the functionalities offered by Smalltalk, which opens a space of potentialities much richer than the other ABM platforms on the market do. Its minimalist syntax enables fast language learning even for non-computer specialists. As an immersive OO system, that enables concept reification, introspection and intercession, Smalltalk promotes rapid and efficient model prototyping. The power of its debugger allows a novice modeler to check finely the functioning of his model, but also to code directly during the execution of a simulation. Thus, participatory design of models and interactive simulations enable to collectively explore medium and long-term scenarios to better understand how a desired situation may be reached on the field.

Aspects of live-programming that have originated with Lisp and Smalltalk systems have recently seen a renewed research and industrial interest due to their educational and productivity potential (Live workshops at ECOOP, ICSE, and SPLASH, live facilities for the Microsoft .NET, Java, Python, and Swift platforms). Especially in the case of visual modeling and simulation tools that are used by experts outside Informatics (such as ecologists, biologists, economists, epidemiologists, ...), this constant-feedback loop that live-systems provide can ease the development and comprehension of complex systems, via truly explorable environments. Unfortunately, taking the domain of Epidemiology as an example, we observe that the visual aspect of such systems offer no notion of modularity and thus exploration is limited only to small monolithic examples. In order to address this issue, we propose a model for modular visual exploration. This model is based on an extension of the OpenPonk platform targeting Kendrick, an domain-specific language (DSL) about epidemiology. Through this model, we were able to map the separation of concerns of the Kendrick DSL, in a live visual notation that supports modularity and exploration of part-whole hierarchies.

Object-oriented programming has had a long-standing history with simulation systems in terms of human-computer interaction [1] dating back to Simula and early versions of Smalltalk-72 and Smalltalk-76. These frameworks were based on discrete, event-based simulations as revealed by the classic simulation examples of Smalltalk-80 Blue-book [2]. Nevertheless present time trends have pivoted towards agent-based modelling and abstractions, with systems like NetLogo capturing a sizeable following and heed. Two of the widely known agent-based modelling (ABM) platforms in Smalltalk (MobiDyC and CORMAS) have recently begun experimenting with porting their systems to Pharo. The rationale behind this choice is to allow modern re-imagination of the platforms that can take advantage of developments in: agile visualization, moldable tools, domain-specific languages (DSLs) and so on. This work focuses on the salient user interface component of these platforms, namely the spatial interface, which empowers a user to visualize the evolution of the system through time. We start with a concise analysis of the state-of-the-art for spatial interfaces and their platforms (MobiDyC, NetLogo, GAMA and CORMAS), scrutinizing in terms of programming flexibility, extensibility, portability, scalability, and interaction. Subsequently we highlight our on-going efforts in building an open-source extension for CORMAS' spatial interface in Pharo. In closing, we detail the pragmatic experience gained in the course of our work and present future perspectives.

Data analysis and visualizations techniques (such as split-apply-combine) make extensive use of associative tabular data-structures that are cumbersome to use with common aggregation APIs (for arrays, lists or dictionaries). In these cases a fluent API for querying associative tabular data (like the ones provided by Pandas, Mathematica or LINQ) is more appropriate for interactive exploration environments. In Smalltalk despite the fact that many important analysis tools are already present (for e.g., in the PolyMath library), we are still missing this essential part of the data science toolkit. These specialized data structures for tabular datasets can provide us with a simple and powerful API for summarizing, cleaning, and manipulating a wealth of data-sources that are currently cumbersome to use. In this paper we introduce the DataFrame and DataSeries collections - that are specifically designed for working with structured data. We demonstrate how these tools can be used for descriptive statistics and Exploratory Data Analysis (EDA) - the critical first step of data analysis which allows us to get the summary of a dataset, detect mistakes, determine the relations, and select the appropriate model for further confirmatory analysis. We then detail the implementation trade-offs that we are currently facing in our implementation for Pharo and discuss future perspectives.

Reflective facilities in OO languages are used both for implementing language extensions (such as AOP frameworks) and for supporting new programming tools and methodologies (such as object-centric debugging and message-based profiling). Yet controlling the runtime behavior of these reflective facilities introduces several challenges, such as computational overhead, the possibility of meta-recursion and an unclean separation of concerns between base and meta-level. In this paper we present five dimensions of meta-level control from related literature that try to remedy these problems. These dimensions are namely: temporal and spatial control, placement control, level control and identity control. We then discuss how these dimensions interact with language semantics in class-based OO languages in terms of: scoping, inheritance and first-class entities. We argue that the reification of the descriptive notion of reflectogram can unify the control of meta-level execution in all these five dimensions while expressing properly the underlying language semantics. We present an extended model for the reification of the reflectogram based on our additional analysis and validate our approach through a new prototype implementation that relies on byte-code instrumentation. Finally, we illustrate our approach through a case study on runtime tracing.

Domain Specific Languages (DSL) are designed to be syntactically and semantically easier to use than general-purpose languages performing the same task. This is generally achieved by tailoring programming notions and constructs to the domain tasks at hand. Yet there are examples of domain specific problems that demand elaborate constructs (for e.g. aspects in Aspect DSLs) which need to be carefully introduced as to avoid complicating the language. We present such an example in Pharo for the epidemiological language KENDRICK. KENDRICK simplifies the programming of epidemiological simulations by decomposing highly-coupled monolithic models into modular concerns. This decomposition though, is based on a mathematical model that introduces non-trivial composition semantics into the language that need to be carefully integrated. In this work, we address this problem by extending KENDRICK's DSL with explicit composition semantics, entities and operators.

Modeling and simulation have been heavily used in epidemiology, for instance to study the transmission of infectious diseases, their pathogenicity and their propagation. A major hindrance to modeling in epidemiology is the mixing of concerns that ought to be separated. The most obvious one is the computer implementation that should not be mixed with domain aspects. But several domain concerns should also be separated from the core epidemiological ones. These include the distribution of the studied populations into spatial regions, age intervals, sexes, species, viral strains... We propose an approach that relies on a mathematical model of the dynamics of a compartment-based population. The separation of domain concerns is provided by expressing each one as a stochastic automaton and combining them with a tensor sum. A DSL, Kendrick, and a tool, support this approach that has been validated on several case studies.

Allowing end-users to extend and adapt applications can speedup software evolution and serve as a pedagogical tool for programming. Alas even open-ended architectures (like the Emacs architecture) presuppose a significant familiarity with programming languages and tools for end-users. General visual programming (as in the case of blocks) offers a more gentle alternative but still introduces additional tools and cognitive abstractions for prospective developers. We propose a possible third alternative: the direct mapping of reflective and meta-programming facilities onto base-level notions and interfaces through an additional self representation model, the projection layer. Our main hypothesis is that for certain types of applications used by non programmers (like for e.g., simulation software) this projection to the base-level has the potential to open a more gradual learning path for programming extensions, by using the same UI and abstractions that the end-user is already familiar with. This position paper analyses our approach and describes our on-going efforts to support or refute our hypothesis through a case-study on software for crisis assessment.

Reflective facilities in OO languages are used both for implementing language extensions (such as AOP frameworks) and for supporting new programming tools and methodologies (such as object-centric debugging and message-based profiling). Yet controlling the run-time behavior of these reflective facilities introduces several challenges, such as computational overhead, the possibility of metarecursion and an unclean separation of concerns between base and meta-level. In this paper we present five dimensions of meta-level control from related literature that try to remedy these problems. These dimensions are namely: temporal and spatial control, placement control, level control and identity control. We argue that the reification of the descriptive notion of the reflectogram, can unify the control of meta-level execution in all these five dimensions. We present a model for the reification of the reflectogram and validate our approach through a prototype implementation in the Pharo programming environment. Finally we detail a case-study on run-time tracing illustrating our approach.

Remote debugging facilities are a technical necessity for devices that lack appropriate input/output interfaces (display, keyboard, mouse) for programming (e.g., smartphones, mobile robots) or are simply unreachable for local development (e.g., cloud-servers).Yet remote debugging solutions can prove awkward to use due to re-deployments.Empirical studies show us that on average 10.5 minutes per coding hour (over five 40-hour work weeks per year) are spent for re-deploying applications (including re-deployments during debugging).Moreover current solutions lack facilities that would otherwise be available in a local setting because it is difficult to reproduce them remotely.Our work identifies three desirable properties that a remote debugging solution should exhibit, namely: run-time evolution, semantic instrumentation and adaptable distribution.Given these properties we propose and validate Mercury, a remote debugging model based on reflection.Mercury supports run-time evolution through a causally connected remote meta-level, semantic instrumentation through the reification of the underlying execution environment and adaptable distribution through a modular architecture of the debugging middleware.

Reflective facilities in OO languages are used both for implementing language extensions (such as AOP frameworks) and for supporting new programming tools and methodologies (such as object-centric debugging and message-based profiling). Yet controlling the run-time behavior of these reflective facilities introduces several challenges, such as computational overhead, the possibility of metarecursion and an unclean separation of concerns between base and meta-level. In this paper we present five dimensions of meta-level control from related literature that try to remedy these problems. These dimensions are namely: temporal and spatial control, placement control, level control and identity control. We argue that the reification of the descriptive notion of the reflectogram, can unify the control of meta-level execution in all these five dimensions. We present a model for the reification of the reflectogram and validate our approach through a prototype implementation in the Pharo programming environment. Finally we detail a case-study on run-time tracing illustrating our approach.

Mirrors are meta-level entities introduced to decouple reflection from the base-level system. Current mirror-based systems focus on functional decomposition of reflection. In this paper we advocate that mirrors should also address structural decomposition. Mirrors should not only be the entry points of reflective behavior but also be the storage entities of metainformation. This decomposition can help resolve issues in terms of resource constraints (e.g. embedded systems and robotics) or security. Indeed, structural decomposition enables discarding meta-information.

While debugging in general is an essential part of the development cycle, debuggers have not themselves evolved over the years as other development tools have through the advancement of Integrated Development Environments. In this free-software research project we propose a way to overcome this problem by introducing, designing and developing a high-level debugging system.High-Level debugging systems are systems that integrate a source level debugger with other technologies as to extent both the facilities and the interfaces of the debugging cycle. We designed and developed such a system in a debugging-centric IDE, Misha. Misha, introduces among other things: syntax-aware navigation, data-displaying and editing, reverse execution, debugging scripting and inter-language evaluation through the integration of its source-level debugger (gdb) with a full-fledged source parser, data visualisation tools and other free software technologies.