Program logics for homogeneous meta-programming.

A meta-program is a program that generates or manipulates another program; in homogeneous meta-programming, a program may generate new parts of, or manipulate, itself. Meta-programming has been used extensively since macros were introduced to Lisp, yet we have little idea how formally to reason about metaprograms. This paper provides the first program logics for homogeneous metaprogramming – using a variant of MiniMLe by Davies and Pfenning as underlying meta-programming language.We show the applicability of our approach by reasoning about example meta-programs from the literature. We also demonstrate that our logics are relatively complete in the sense of Cook, enable the inductive derivation of characteristic formulae, and exactly capture the observational properties induced by the operational semantics

Combining Monitoring with Run-Time Assertion Checking

According to a study in 2002 commissioned by a US Department, software bugs annually costs the US economy an estimated $59 billion. A more recent study in 2013 by Cambridge University estimated that the global cost has risen to$312 billion globally. There exists various ways to prevent, isolate and fix software bugs, ranging from lightweight methods that are (semi)-automatic, to heavyweight methods that require significant user interaction. Our own method described in this tutorial is based on automated run-time checking of a combination of protocol- and data-oriented properties of object-oriented programs

Viking '75 spacecraft design and test summary. Volume 3: Engineering test summary

The engineering test program for the lander and the orbiter are presented. The engineering program was developed to achieve confidence that the design was adequate to survive the expected mission environments and to accomplish the mission objective

Proceedings of International Workshop "Global Computing: Programming Environments, Languages, Security and Analysis of Systems"

According to the IST/ FET proactive initiative on GLOBAL COMPUTING, the goal is to obtain techniques (models, frameworks, methods, algorithms) for constructing systems that are flexible, dependable, secure, robust and efficient. The dominant concerns are not those of representing and manipulating data efficiently but rather those of handling the co-ordination and interaction, security, reliability, robustness, failure modes, and control of risk of the entities in the system and the overall design, description and performance of the system itself. Completely different paradigms of computer science may have to be developed to tackle these issues effectively. The research should concentrate on systems having the following characteristics: • The systems are composed of autonomous computational entities where activity is not centrally controlled, either because global control is impossible or impractical, or because the entities are created or controlled by different owners. • The computational entities are mobile, due to the movement of the physical platforms or by movement of the entity from one platform to another. • The configuration varies over time. For instance, the system is open to the introduction of new computational entities and likewise their deletion. The behaviour of the entities may vary over time. • The systems operate with incomplete information about the environment. For instance, information becomes rapidly out of date and mobility requires information about the environment to be discovered. The ultimate goal of the research action is to provide a solid scientific foundation for the design of such systems, and to lay the groundwork for achieving effective principles for building and analysing such systems. This workshop covers the aspects related to languages and programming environments as well as analysis of systems and resources involving 9 projects (AGILE , DART, DEGAS , MIKADO, MRG, MYTHS, PEPITO, PROFUNDIS, SECURE) out of the 13 founded under the initiative. After an year from the start of the projects, the goal of the workshop is to fix the state of the art on the topics covered by the two clusters related to programming environments and analysis of systems as well as to devise strategies and new ideas to profitably continue the research effort towards the overall objective of the initiative. We acknowledge the Dipartimento di Informatica and Tlc of the University of Trento, the Comune di Rovereto, the project DEGAS for partially funding the event and the Events and Meetings Office of the University of Trento for the valuable collaboration

Customizable Templates for OutSystems Applications

This dissertation addresses an extension of a metaprogramming mechanism in low-code platforms, specifically in the OutSystems platform. As proposed in the template language OSTRICH, model templates allow developers to reuse existing and thoroughly tested code fragments in a more productive and sound development process. Code templates help to overcome developer difficulties and lack of training. For instance, the development of professionally designed user interfaces is not a skill that is common amongst developers. Scenarios like specific synchronization algorithms are the other end of the spectrum for templates in OutSystems. The GOLEM project has the chief objective of providing mechanisms for automated programming. Such automation will make programming more accessible to a larger community of developers. This work is part of those efforts. To this end, our focus will be on developing and improving the template language OSTRICH that targets the OutSystems platform. It enables the creation of code fragments like screen templates, saving the user from the cumbersome task of repeatedly constructing code complex patterns. In OSTRICH, templates are instantiated by expanding their definition in the caller context to enable further customization of the resulting code. OSTRICH preserves the structure of the original model by expanding templates in place. However, expanding the template definition in place breaks the possibility of reapplying the template in the case of an update to a newer version or changing parameters. It requires the user to repeat all customization operations on top of a new instantiation of the template. Our purpose is to solve this issue by supporting customization operations that extend to all future template updates and new parameters. This way, the user will be saved from some erroneous trials, which could, eventually, push them to give up. We plan to evaluate our work using the benchmark template examples used previously to evaluate OSTRICH.Esta dissertação aborda uma extensão de um mecanismo de metaprogramação em pla- taformas low-code, especificamente na plataforma da OutSystems. Como proposto na linguagem de template OSTRICH, os templates permitem que os utilizadores reutilizem fragmentos de código existentes e completamente testados num processo de desenvol- vimento produtivo e seguro. Estes fragmentos ajudam os utilizadores a ultrapassar as dificuldades ou falta de conhecimento em linguagens de programação. Por exemplo, a sua utilização permite criar interfaces de forma profissional, o que nem sempre é uma habilidade comum entre desenvolvedores de software. Do outro lado do espetro, estão os algoritmos de sincronização específicos para modelos em OutSystems. O projeto GOLEM tem como principal objetivo fornecer mecanismos para automatizar a programação. Esta automatização irá tornar a programação mais acessível a um maior número de pessoas. Este trabalho faz parte destes esforços. Para alcançar este objetivo, estaremos focados no desenvolvimento e melhoria da linguagem de template OSTRICH para a plataforma da OutSystems. Esta permite a cria- ção de fragmentos de código como screen templates, poupando os utilizadores da tarefa complicada de repetir padrões complexos de código. Nesta linguagem, os templates são instanciados através da expansão da sua definição para permitir a customização do código resultante. Contudo, expandir esta definição no local quebra a possibilidade de reaplicar o template em caso de atualização para uma versão mais recente ou mudança de parâmetros. Isto acaba por obrigrar o utilizador a repetir todas as operações aplicadas numa nova instanciação de template. O nosso propósito passa por resolver este problema, permitindo que as operações do utilizador possam ser reaplicadas em todas as novas atualizações do template e novos parâmetros. Desta forma, o utilizador será poupado de seguir uma apren- dizagem tentativa e erro, que poderia eventualmente levá-lo a desistir. Planeamos avaliar o nosso trabalho utilizando como referência exemplos de templates usados anteriormente para avaliar a linguagem OSTRICH

A Transformation-Based Foundation for Semantics-Directed Code Generation

Interpreters and compilers are two different ways of implementing programming languages. An interpreter directly executes its program input. It is a concise definition of the semantics of a programming language and is easily implemented. A compiler translates its program input into another language. It is more difficult to construct, but the code that it generates runs faster than interpreted code. In this dissertation, we propose a transformation-based foundation for deriving compilers from semantic specifications in the form of four rules. These rules give apriori advice for staging, and allow explicit compiler derivation that would be less succinct with partial evaluation. When applied, these rules turn an interpreter that directly executes its program input into a compiler that emits the code that the interpreter would have executed. We formalize the language syntax and semantics to be used for the interpreter and the compiler, and also specify a notion of equality. It is then possible to precisely state the transformation rules and to prove both local and global correctness theorems. And although the transformation rules were developed so as to apply to an interpreter written in a denotational style, we consider how to modify non-denotational interpreters so that the rules apply. Finally, we illustrate these ideas by considering a larger example: a Prolog implementation

Bringing Model Checking Closer To Practical Software Engineering

Bal, H.E. [Promotor]Templon, J.A. [Copromotor]Willemse, T.A.C. [Copromotor

Staged Compilation with Two-Level Type Theory

The aim of staged compilation is to enable metaprogramming in a way such that we have guarantees about the well-formedness of code output, and we can also mix together object-level and meta-level code in a concise and convenient manner. In this work, we observe that two-level type theory (2LTT), a system originally devised for the purpose of developing synthetic homotopy theory, also serves as a system for staged compilation with dependent types. 2LTT has numerous good properties for this use case: it has a concise specification, well-behaved model theory, and it supports a wide range of language features both at the object and the meta level. First, we give an overview of 2LTT's features and applications in staging. Then, we present a staging algorithm and prove its correctness. Our algorithm is "staging-by-evaluation", analogously to the technique of normalization-by-evaluation, in that staging is given by the evaluation of 2LTT syntax in a semantic domain. The staging algorithm together with its correctness constitutes a proof of strong conservativity of 2LLT over the object theory. To our knowledge, this is the first description of staged compilation which supports full dependent types and unrestricted staging for types