299 research outputs found
Untangling Typechecking of Intersections and Unions
Intersection and union types denote conjunctions and disjunctions of
properties. Using bidirectional typechecking, intersection types are relatively
straightforward, but union types present challenges. For union types, we can
case-analyze a subterm of union type when it appears in evaluation position
(replacing the subterm with a variable, and checking that term twice under
appropriate assumptions). This technique preserves soundness in a call-by-value
semantics.
Sadly, there are so many choices of subterms that a direct implementation is
not practical. But carefully transforming programs into let-normal form
drastically reduces the number of choices. The key results are soundness and
completeness: a typing derivation (in the system with too many subterm choices)
exists for a program if and only if a derivation exists for the let-normalized
program.Comment: In Proceedings ITRS 2010, arXiv:1101.410
Bidirectional Type Checking for Relational Properties
Relational type systems have been designed for several applications including
information flow, differential privacy, and cost analysis. In order to achieve
the best results, these systems often use relational refinements and relational
effects to maximally exploit the similarity in the structure of the two
programs being compared. Relational type systems are appealing for relational
properties because they deliver simpler and more precise verification than what
could be derived from typing the two programs separately. However, relational
type systems do not yet achieve the practical appeal of their non-relational
counterpart, in part because of the lack of a general foundations for
implementing them.
In this paper, we take a step in this direction by developing bidirectional
relational type checking for systems with relational refinements and effects.
Our approach achieves the benefits of bidirectional type checking, in a
relational setting. In particular, it significantly reduces the need for typing
annotations through the combination of type checking and type inference. In
order to highlight the foundational nature of our approach, we develop
bidirectional versions of several relational type systems which incrementally
combine many different components needed for expressive relational analysis.Comment: 14 page
Rewrite based Verification of XML Updates
We consider problems of access control for update of XML documents. In the
context of XML programming, types can be viewed as hedge automata, and static
type checking amounts to verify that a program always converts valid source
documents into also valid output documents. Given a set of update operations we
are particularly interested by checking safety properties such as preservation
of document types along any sequence of updates. We are also interested by the
related policy consistency problem, that is detecting whether a sequence of
authorized operations can simulate a forbidden one. We reduce these questions
to type checking problems, solved by computing variants of hedge automata
characterizing the set of ancestors and descendants of the initial document
type for the closure of parameterized rewrite rules
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
- …