18 research outputs found
Bacatá:Notebooks for DSLs, Almost for Free
Context: Computational notebooks are a contemporary style of literate
programming, in which users can communicate and transfer knowledge by
interleaving executable code, output, and prose in a single rich document. A
Domain-Specific Language (DSL) is an artificial software language tailored for
a particular application domain. Usually, DSL users are domain experts that may
not have a software engineering background. As a consequence, they might not be
familiar with Integrated Development Environments (IDEs). Thus, the development
of tools that offer different interfaces for interacting with a DSL is
relevant.
Inquiry: However, resources available to DSL designers are limited. We would
like to leverage tools used to interact with general purpose languages in the
context of DSLs. Computational notebooks are an example of such tools. Then,
our main question is: What is an efficient and effective method of designing
and implementing notebook interfaces for DSLs? By addressing this question we
might be able to speed up the development of DSL tools, and ease the
interaction between end-users and DSLs.
Approach: In this paper, we present Bacat\'a, a mechanism for generating
notebook interfaces for DSLs in a language parametric fashion. We designed this
mechanism in a way in which language engineers can reuse as many language
components (e.g., language processors, type checkers, code generators) as
possible.
Knowledge: Our results show that notebook interfaces generated by Bacat\'a
can be automatically generated with little manual configuration. There are few
considerations and caveats that should be addressed by language engineers that
rely on language design aspects. The creation of a notebook for a DSL with
Bacat\'a becomes a matter of writing the code that wires existing language
components in the Rascal language workbench with the Jupyter platform.
Grounding: We evaluate Bacat\'a by generating functional computational
notebook interfaces for three different non-trivial DSLs, namely: a small
subset of Halide (a DSL for digital image processing), SweeterJS (an extended
version of JavaScript), and QL (a DSL for questionnaires). Additionally, it is
relevant to generate notebook implementations rather than implementing them
manually. We measured and compared the number of Source Lines of Code (SLOCs)
that we reused from existing implementations of those languages.
Importance: The adoption of notebooks by novice-programmers and end-users has
made them very popular in several domains such as exploratory programming, data
science, data journalism, and machine learning. Why are they popular? In (data)
science, it is essential to make results reproducible as well as
understandable. However, notebooks are only available for GPLs. This paper
opens up the notebook metaphor for DSLs to improve the end-user experience when
interacting with code and to increase DSLs adoption
Constraint-based Run-time State Migration for Live Modeling
Live modeling enables modelers to incrementally update models as they are running and get immediate feedback about the impact of their changes. Changes introduced in a model may trigger inconsistencies between the model and its run-time state (e.g., deleting the current state in a statemachine); effectively requiring to migrate the run-time state to comply with the updated model. In this paper, we introduce an approach that enables to automatically migrate such runtime state based on declarative constraints defined by the language designer. We illustrate the approach using Nextep, a meta-modeling language for defining invariants and migration constraints on run-time state models. When a model changes, Nextep employs model finding techniques, backed by a solver, to automatically infer a new run-time model that satisfies the declared constraints. We apply Nextep to define migration strategies for two DSLs, and report on its expressiveness and performance
Debugging and Verification Tools for LINGUA FRANCA in GEMOC Studio
International audienceLINGUA FRANCA (LF) is a polyglot coordination language designed for the composition of concurrent, timesensitive, and potentially distributed reactive components called reactors. The LF coordination layer facilitates the use of target languages (e.g., C, C++, Python, TypeScript) to realize the program logic, where each target language requires a separate runtime implementation that must correctly implement the reactor semantics. Verifying the correctness of runtime implementations is not a trivial task, and is currently done on the basis of regression testing. To provide a more formal verification tool for existing and future target runtimes, as well as to help verify properties of LF programs, we recruit the use of GEMOC Studio-an Eclipse-based workbench for the development, integration, and use of heterogeneous executable modeling languages. We present an operational model for LF, realized in GEMOC Studio, that is primed to interact with a rich set of analysis and verification tools. Our instrumentation provides the ability to navigate the execution of LF programs using an omniscient debugger with graphical model animation; to check assertions in particular execution runs, or exhaustively, using a model checker; and to validate or debug traces obtained from arbitrary LF runtime environments