A Framework for Resource Dependent EDSLs in a Dependently Typed Language (Pearl)

Idris' Effects library demonstrates how to embed resource dependent algebraic effect handlers into a dependently typed host language, providing run-time and compile-time based reasoning on type-level resources. Building upon this work, Resources is a framework for realising Embedded Domain Specific Languages (EDSLs) with type systems that contain domain specific substructural properties. Differing from Effects, Resources allows a language’s substructural properties to be encoded within type-level resources that are associated with language variables. Such an association allows for multiple effect instances to be reasoned about autonomically and without explicit type-level declaration. Type-level predicates are used as proof that the language’s substructural properties hold. Several exemplar EDSLs are presented that illustrates our framework’s operation and how dependent types provide correctness-by-construction guarantees that substructural properties of written programs hold

Defensive Points-To Analysis: Effective Soundness via Laziness

We present a defensive may-point-to analysis approach, which offers soundness even in the presence of arbitrary opaque code: all non-empty points-to sets computed are guaranteed to be over-approximations of the sets of values arising at run time. A key design tenet of the analysis is laziness: the analysis computes points-to relationships only for variables or objects that are guaranteed to never escape into opaque code. This means that the analysis misses some valid inferences, yet it also never wastes work to compute sets of values that are not "complete", i.e., that may be missing elements due to opaque code. Laziness enables great efficiency, allowing a highly precise points-to analysis (such as a 5-call-site-sensitive, flow-sensitive analysis). Despite its conservative nature, our analysis yields sound, actionable results for a large subset of the program code, achieving (under worst-case assumptions) 34-74% of the program coverage of an unsound state-of-the-art analysis for real-world programs

Flexible Bindings for Type-Safe Embedded Operating Systems.

This paper presents the binding model implemented in Camille, an extensible operating system for resource-limited devices. Modern embedded systems need on the first hand to fully exploit the limited hardware on which they run and on the other hand to dynamically adapt themselves to changes in their runtime environment. Camille is an exokernel which support static customization of components and dynamic loading of system extensions. Dynamic kernel and application adaptation is implemented by an inter-component communication model. This model is based on flexible bindings which permit to fully customize the way components interact with each others. Bindings can be static, virtual or compiled to guarantee performances of inter-component communications. This paper shows that it is possible to build a flexible operating system without sacrificing runtime performances, even for devices as constrained as smart cards. We first present the architecture of the Camille exokernel and the intermediate language Facade into which applications and system components are translated to ease type verification. We then describe the component model implemented in Camille and the inter-component communication scheme based on embedded binding factories. We then details the binding generation process and the various verifications which can be enforced when implementing bindings. We present some experimental results we have obtained when monitoring the performances of our native code generator. Finally, we conclude and discuss the future work we plan to conduct concerning extraction of selected properties from generated code

The Role of Variable in Programming: Examples and Methodology

One of the hardest notions to define in programming is the variable and the related command of assignment. In our opinion, it is exactly these difficulties that are responsible for the reluctance towards programming. The reason for this, according to us and others [7], is the multifunctional nature of the variable: it can be used for various purposes. Its concept “in our heads” and in the programming languages is markedly different in this respect

Innovation for Sustainability and Networking

Throughout human history, innovation has been the main factor in adapting humanity to its settings. On the basis of earlier practice, human creativity allows the finding of new, permanent ways to do things. their applications encourage new spaces, new necessities and new lifestyles. Innovation has been an element of human capacities from its earlier stages, but it has been recognized only recently as a clear device of social and economic change

Pla(y)ceskabelse:når børn og robotteknologi mødes

Artiklen viser, hvordan et interdisciplinært ståsted mellem konstruktionisme / pragmatisk designtænkning og nordisk legekulturteori kan bidrage med nye læringsperspektiver på brug af robotteknologi i børns legekultur, herunder på den merværdi, som mødet mellem børn og robotteknologi kan generere, når det angår færdigheder, kompetencer og dannelse. I en analyse af feltobservationer af børehavebørns leg med Modular Robotoc Tiles fokuseres der på, hvordan robotteknologi gennem leg kan lykkes med at transgredere fra velfærdsteknologi til en teknologi, børn leger og designer med. Kernebegreber som pla(y)ceskabelse, transgression, det legekulturelle: "Hvad nu hvis...?" og det konstruktionistisk-designrettede "Hvordan kan vi...?" forstærker opmærksomheden over for læringspotentialer i leg som designvirksomhed. I en interdisciplinær analysemodel tilkobles desuden begreber for modularitet, flytbarhed, idégenerering, problemløsning, åbenhed og tilblivelse til indfangning af design- og læringspotentialer i legende børns interaktioner med robotteknologier. Artiklen konkluderer, at mødet mellem legebørn og robotteknologi, konceptualiseret som pla(y)ceskabelse, fremmer børns erobring af demokratiske færdigheder, kompetencer og dannelse

RML: Runtime Monitoring Language

Runtime verification is a relatively new software verification technique that aims to prove the correctness of a specific run of a program, rather than statically verify the code. The program is instrumented in order to collect all the relevant information, and the resulting trace of events is inspected by a monitor that verifies its compliance with respect to a specification of the expected properties of the system under scrutiny. Many languages exist that can be used to formally express the expected behavior of a system, with different design choices and degrees of expressivity. This thesis presents RML, a specification language designed for runtime verification, with the goal of being completely modular and independent from the instrumentation and the kind of system being monitored. RML is highly expressive, and allows one to express complex, parametric, non-context-free properties concisely. RML is compiled down to TC, a lower level calculus, which is fully formalized with a deterministic, rewriting-based semantics. In order to evaluate the approach, an open source implementation has been developed, and several examples with Node.js programs have been tested. Benchmarks show the ability of the monitors automatically generated from RML specifications to effectively and efficiently verify complex properties