Conference Proceedings

Shoker A, Yactine H, Moreno CB.  2017.  As Secure as Possible Eventual Consistency (Work in Progress). EuroSys PAPOC'17 workshops: International Workshop on Principles and Practice of Consistency for Distributed Data. :1-5.Secure EC
Shoker A, Yactine H, Moreno CB.  2017.  As Secure as Possible Eventual Consistency. In the proceedings of the 3rd International Workshop on Principles and Practice of Consistency for Distributed Data (EuroSys PAPOC’17). As Secure as Possible Eventual Consistency.pdf
Shoker A, Kassam Z, Almeida PS, Moreno CB.  2016.  Life Beyond Distributed Transactions on the Edge. The Middleware Workshop for Edge Clouds and Cloudlets (MECC’16). Abstractlifeedgedraft.pdf

Edge/Fog Computing is an extension to the Cloud Computing model, primarily proposed to pull some of the load on cloud data center towards the edge of the network, i.e., closer to the clients. Despite being a promising model, the foundations to adopt and fully exploit the edge model are yet to be clear, and thus new ideas are continuously advocated. In his paper on “Life beyond Distributed Transactions: an Apostate’s Opinion”, Pat Helland proposed his vision to build“al- most infinite” scale future applications, demonstrating why Distributed Transactions are not very practical under scale. His approach models the applications data state as independent “entities” with separate serialization scopes, thus allowing efficient local transactions within an entity, but precluding transactions involving different entities. Accessing remote data (which is assumed rare) can be done through separate channels in a more message-oriented manner. In this paper, we recall Helland’s vision in the aforementioned paper, explaining how his model fits the Edge Computing Model either regarding scalability, applications, or assumptions, and discussing the potential challenges leveraged

Machado N, Maia F, Matos M, Oliveira R.  2016.  BuzzPSS: A Dependable and Efficient Peer Sampling Service. 7th Latin-American Symposium on Dependable Computing (LADC’16). ladc16-nmachado.pdf
Machado N, Lucia B, Rodrigues L.  2016.  Production-guided Concurrency Debugging. 21st ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming (PPoPP '16). ppopp16-nmachado.pdf
Miranda J, Machado N, Rodrigues L.  2016.  Isolamento de Falhas em Redes Definidas por Software. Actas do Oitavo Simpósio de Informática (INForum’16). Best Paper Awardinforum16-jmiranda.pdf
[Anonymous].  2016.  Proceedings of the 8th ACM SIGCHI Symposium on Engineering Interactive Computing Systems, EICS '16. Abstract

The ACM SIGCHI Symposium on Engineering Interactive Computing Systems (EICS) is a yearly international conference devoted to engineering usable and reliable interactive computing systems. Research presented at EICS revolves around methods, processes, techniques and tools that support specifying, designing, developing, deploying and verifying interactive systems. This 8th ACM SIGCHI Symposium on Engineering Interactive Computing Systems (EICS'16) took place in Brussels, Belgium (21-24 June 2016) - at the heart of Europe.

EICS gathers researchers that aim to improve the ways we build interactive systems. Building interactive systems is a multi-faceted and challenging activity, involving a plethora of different actors and roles. This is particularly true in the domain of HCI, where we continuously push the edge of what is possible, where there is a crucial need for adequate processes, tools and methods to build reliable, useful and usable systems that help people cope with the ever increasing complexity of work and life. The primary goal of the EICS conference series is to provide a venue for novel and high quality contributions in this direction.

Cámara J, Proença J.  2015.  Preface. Proceedings 13th International Workshop on Foundations of Coordination Languages and Self-Adaptive Systems . 175
Shoker A, Almeida PS, Moreno CB.  2015.  Exactly-Once Quantity Transfer. Abstractquantity-transfer-srds-w-psds.pdfparishandoffaverage2015.pdf

Strongly consistent systems supporting distributed transactions can be prone to high latency and do not tolerate partitions. The present trend of using weaker forms of consistency, to achieve high availability, poses notable challenges in writing applications due to the lack of linearizability, e.g., to ensure global invariants, or perform mutator operations on a distributed datatype. This paper addresses a specific problem: the exactly-once transfer of a “quantity” from one node to another on an unreliable network (coping with message duplication, loss, or reordering) and without any form of global synchronization. This allows preserving a global property (the sum of quantities remains unchanged) without requiring global linearizability and only through using pairwise interactions between nodes, therefore allowing partitions in the system. We present the novel quantitytransfer algorithm while focusing on a specific use-case: a redistribution protocol to keep the quantities in a set of nodes balanced; in particular, averaging a shared real number across nodes. Since this is a work in progress, we briefly discuss the correctness of the protocol, and we leave potential extensions and empirical evaluations for future work.

Saraiva JA, Rebêlo H, Cunha J, Mendes J, Maia P.  2015.  Towards the Design and Implementation of Aspect-Oriented Programming for Spreadsheets. International Conference on Software Engineering (ICSE) Workshops. Abstract1503.03463v1.pdf

A spreadsheet usually starts as a simple and singleuser software artifact, but, as frequent as in other software systems, quickly evolves into a complex system developed by many actors. Often, different users work on different aspects of the same spreadsheet: while a secretary may be only involved in adding plain data to the spreadsheet, an accountant may define new business rules, while an engineer may need to adapt the spreadsheet content so it can be used by other software systems. Unfortunately, spreadsheet systems do not offer modular mechanisms, and as a consequence, some of the previous tasks may be defined by adding intrusive “code” to the spreadsheet. In this paper we go through the design and implementation of an aspect-oriented language for spreadsheets so that users can work on different aspects of a spreadsheet in a modular way. For example, aspects can be defined in order to introduce new business rules to an existing spreadsheet, or to manipulate the spreadsheet data to be ported to another system. Aspects are defined as aspect-oriented program specifications that are dynamically woven into the underlying spreadsheet by an a aspect weaver. In this aspect-oriented style of spreadsheet development, different users develop, or reuse, aspects without adding intrusive code to the original spreadsheet. Such code is added/executed by the spreadsheet weaving mechanism proposed in this paper.

Saraiva JA, Martins P, Zhu Z, Ko H-S, Hu Z.  2015.  BiYacc: Roll Your Parser and Reflective Printer into One. Fourth International Workshop on Bidirectional Transformations (Bx 2015). :43-50. Abstractp43-zhu_1.pdf

Language designers usually need to implement parsers and printers. Despite being two related programs, in practice they are designed and implemented separately. This approach has an obvious disadvantage: as a language evolves, both its parser and printer need to be separately revised and kept synchronised. Such tasks are routine but complicated and error-prone. To facilitate these tasks, we propose a language called BiYacc, whose programs denote both a parser and a printer. In essence, BiYacc is a domain-specific language for writing putback-based bidirectional transformations — the printer is a putback transformation,
and the parser is the corresponding get transformation. The pairs of parsers and printers generated by BiYacc are thus always guaranteed to satisfy the usual round-trip properties. The highlight that distinguishes this reflective printer from others is that the printer —being a putback transformation — accepts not only an abstract syntax tree but also a string, and produces an updated string consistent with the given abstract syntax tree. We can thus make use of the additional input string, with mechanisms such as simultaneous pattern matching on the view and the source, to provide users with full control over the printing-strategies.

Pinto JS, Pedro AM, Pereira D, Pinho LM.  2015.  Logic-based schedulability analysis for compositional hard real-time embedded systems. Abstract

Over the past decades several approaches for schedu- lability analysis have been proposed for both uniprocessor and multi-processor real-time systems. Although different techniques are employed, very little has been put forward in using formal specifications, with the consequent possibility for misinterpretations or ambiguities in the problem statement. Using a logic based approach to schedulability analysis in the design of hard real-time systems eases the synthesis of correct-by- construction procedures for both static and dynamic verification processes. In this paper we propose a novel approach to schedulability analysis based on a timed temporal logic with time durations. Our approach subsumes classical methods for uniprocessor scheduling analysis over compositional resource models by providing the developer with counter-examples, and by ruling out schedules that cause unsafe violations on the system. We also provide an example showing the effectiveness of our proposal.

Machado N, Lucia B, Rodrigues L.  2015.  Concurrency Debugging with Differential Schedule Projections. ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI’15). pldi15-nmachado.pdf
Almeida PS, Shoker A, Moreno CB.  2014.  Efficient State-based CRDTs by Decomposition. EuroSys Workshop Proceedings . 1:2. Abstractdeltapapec.pdf

CRDTs are distributed data types that make eventual consistency of a distributed object possible and non ad-hoc. Specifically, state-based CRDTs achieve this by sharing local state changes through shipping the entire state, that is then merged to other replicas with an idempotent, associative, and commutative join operation, ensuring convergence. This imposes a large communication overhead as the state size becomes larger. We introduce Delta State Conflict-Free Replicated Datatypes ({\delta}-CRDT), which make use of {\delta}-mutators, defined in such a way to return a delta-state, typically, with a much smaller size than the full state. Delta-states are joined to the local state as well as to the remote states (after being shipped). This can achieve the best of both worlds: small messages with an incremental nature, as in operation-based CRDTs, disseminated over unreliable communication channels, as in traditional state-based CRDTs. We introduce the {\delta}-CRDT framework, and we explain it through establishing a correspondence to current state- based CRDTs. In addition, we present two anti-entropy algorithms: a basic one that provides eventual convergence, and another one that ensures both convergence and causal consistency. We also introduce two {\delta}-CRDT specifications of well-known replicated datatypes.

Moreno CB, Almeida PS, Shoker A.  2014.  Making Operation-based CRDTs Operation-based. EuroSys Workshop Proceedings . :2. AbstractPaper

Conflict-free Replicated Datatypes can simplify the design of predictable eventual consistency. They can be classified into state-based or operation-based. Operation-based approaches have the potential for allowing compact designs in both the sent message and the object state size, but cur- rent approaches are still far from this objective. Here we explore the design space for operation-based solutions, and we leverage the interaction with the middleware by offering a technique that delivers very compact solutions, while only broadcasting operation names and arguments.

[Anonymous].  2014.  Central European Functional Programming School. 5th summer school - CEFP .