189 research outputs found

    Typechecking safe process synchronization

    Get PDF
    Session types describe the interactions between two parties within multi-party communications. They constitute a communication protocol in the sense that the order and type of interactions between two parties are specified. For their part, correspondence assertions provide a mechanism for synchronization. When session types and correspondence assertions are combined, they are able to describe synchronization across different communication sessions, yielding a rich language for imposing expressive interaction patterns in multi-party communications. This paper studies the typechecking problem for Iris, a typed π-calculus that combines session types and correspondence assertions. We define a typechecking algorithm and prove that it is sound and complete with respect to the typing rules. Furthermore, we show that the typing system satisfies the minimum effects property. Although session types have been extensively studied in the past few years, to our knowledge this is the first proof of decidability of typechecking for a type system with session types.Facultad de Informátic

    Security Policies as Membranes in Systems for Global Computing

    Get PDF
    We propose a simple global computing framework, whose main concern is code migration. Systems are structured in sites, and each site is divided into two parts: a computing body, and a membrane which regulates the interactions between the computing body and the external environment. More precisely, membranes are filters which control access to the associated site, and they also rely on the well-established notion of trust between sites. We develop a basic theory to express and enforce security policies via membranes. Initially, these only control the actions incoming agents intend to perform locally. We then adapt the basic theory to encompass more sophisticated policies, where the number of actions an agent wants to perform, and also their order, are considered

    Distributed Concurrent Persistent Languages: An Experimental Design and Implementation

    Get PDF
    A universal persistent object store is a logical space of persistent objects whose localities span over machines reachable over networks. It provides a conceptual framework in which, on one hand, the distribution of data is transparent to application programmers and, on the other, store semantics of conventional languages is preserved. This means the manipulation of persistent objects on remote machines is both syntactically and semantically the same as in the case of local data. Consequently, many aspects of distributed programming in which computation tasks cooperate over different processors and different stores can be addressed within the confines of persistent programming. The work reported in this thesis is a logical generalization of the notion of persistence in the context of distribution. The concept of a universal persistent store is founded upon a universal addressing mechanism which augments existing addressing mechanisms. The universal addressing mechanism is realized based upon remote pointers which although containing more locality information than ordinary pointers, do not require architectural changes. Moreover, these remote pointers are transparent to the programmers. A language, Distributed PS-algol, is designed to experiment with this idea. The novel features of the language include: lightweight processes with a flavour of distribution, mutexes as the store-based synchronization primitive, and a remote procedure call mechanism as the message-based interprocess communication mechanism. Furthermore, the advantages of shared store programming and network architecture are obtained with the introduction of the programming concept of locality in an unobtrusive manner. A characteristic of the underlying addressing mechanism is that data are never copied to satisfy remote demands except where efficiency can be attained without compromising the semantics of data. A remote store operation model is described to effect remote updates. It is argued that such a choice is the most natural given that remote store operations resemble remote procedure calls

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

    Get PDF
    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

    Acute: high-level programming language design for distributed computation

    No full text
    Existing languages provide good support for typeful programming of standalone programs. In a distributed system, however, there may be interaction between multiple instances of many distinct programs, sharing some (but not necessarily all) of their module structure, and with some instances rebuilt with new versions of certain modules as time goes on. In this paper we discuss programming language support for such systems, focussing on their typing and naming issues. We describe an experimental language, Acute, which extends an ML core to support distributed development, deployment, and execution, allowing type-safe interaction between separately-built programs. The main features are: (1) type-safe marshalling of arbitrary values; (2) type names that are generated (freshly and by hashing) to ensure that type equality tests suffice to protect the invariants of abstract types, across the entire distributed system; (3) expression-level names generated to ensure that name equality tests suffice for type-safety of associated values, e.g. values carried on named channels; (4) controlled dynamic rebinding of marshalled values to local resources; and (5) thunkification of threads and mutexes to support computation mobility. These features are a large part of what is needed for typeful distributed programming. They are a relatively lightweight extension of ML, should be efficiently implementable, and are expressive enough to enable a wide variety of distributed infrastructure layers to be written as simple library code above the byte-string network and persistent store APIs. This disentangles the language runtime from communication intricacies. This paper highlights the main design choices in Acute. It is supported by a full language definition (of typing, compilation, and operational semantics), by a prototype implementation, and by example distribution libraries

    Safe Stream-Based Programming with Refinement Types

    Full text link
    In stream-based programming, data sources are abstracted as a stream of values that can be manipulated via callback functions. Stream-based programming is exploding in popularity, as it provides a powerful and expressive paradigm for handling asynchronous data sources in interactive software. However, high-level stream abstractions can also make it difficult for developers to reason about control- and data-flow relationships in their programs. This is particularly impactful when asynchronous stream-based code interacts with thread-limited features such as UI frameworks that restrict UI access to a single thread, since the threading behavior of streaming constructs is often non-intuitive and insufficiently documented. In this paper, we present a type-based approach that can statically prove the thread-safety of UI accesses in stream-based software. Our key insight is that the fluent APIs of stream-processing frameworks enable the tracking of threads via type-refinement, making it possible to reason automatically about what thread a piece of code runs on -- a difficult problem in general. We implement the system as an annotation-based Java typechecker for Android programs built upon the popular ReactiveX framework and evaluate its efficacy by annotating and analyzing 8 open-source apps, where we find 33 instances of unsafe UI access while incurring an annotation burden of only one annotation per 186 source lines of code. We also report on our experience applying the typechecker to two much larger apps from the Uber Technologies Inc. codebase, where it currently runs on every code change and blocks changes that introduce potential threading bugs

    Customizable Templates for OutSystems Applications

    Get PDF
    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 Concurrent Language with a Uniform Treatment of Regions and Locks

    Full text link
    A challenge for programming language research is to design and implement multi-threaded low-level languages providing static guarantees for memory safety and freedom from data races. Towards this goal, we present a concurrent language employing safe region-based memory management and hierarchical locking of regions. Both regions and locks are treated uniformly, and the language supports ownership transfer, early deallocation of regions and early release of locks in a safe manner

    Type-based protocol conformance and aliasing control in concurrent java programs

    Get PDF
    Dissertação para obtenção do Grau de Mestre em Engenharia InformáticaIn an object-oriented setting, objects are modeled by their state and operations. The programmer should be aware of how each operation implicitly changes the state of an object. This is due to the fact that in certain states some operations might not be available, e.g., reading from a file when it is closed. Additional care must be taken if we consider aliasing, since many references to the same object might be held and manipulated. This hinders the ability to identify the source of a modification to an object, thus making it harder to track down its state. These difficulties increase in a concurrent setting, due to the unpredictability of the behavior of concurrent programs. Concurrent programs are complex and very hard to reason about and debug. Some of the errors that arise in concurrent programs are due to simultaneous accesses to shared memory by different threads, resulting in unpredictable outcomes due to the possible execution interleavings. This kind of errors are generally known as race conditions. Software verification and specification are important in software design and implementation as they provide early error detection, and can check conformity to a given specification, ensuring some intended correctness properties. To this end, our work builds on the work of Spatial-Behavioral types formalism providing object ownership support. Our approach consists in the integration of a behavioral type system, developed for a core fragment of the Java programming language, in the standard Java development process.PTDC/EIA-CCO/104583/2008 research scholarshi
    corecore