191 research outputs found

    Special Delivery: Programming with Mailbox Types (Extended Version)

    Full text link
    The asynchronous and unidirectional communication model supported by mailboxes is a key reason for the success of actor languages like Erlang and Elixir for implementing reliable and scalable distributed systems. While many actors may send messages to some actor, only the actor may (selectively) receive from its mailbox. Although actors eliminate many of the issues stemming from shared memory concurrency, they remain vulnerable to communication errors such as protocol violations and deadlocks. Mailbox types are a novel behavioural type system for mailboxes first introduced for a process calculus by de'Liguoro and Padovani in 2018, which capture the contents of a mailbox as a commutative regular expression. Due to aliasing and nested evaluation contexts, moving from a process calculus to a programming language is challenging. This paper presents Pat, the first programming language design incorporating mailbox types, and describes an algorithmic type system. We make essential use of quasi-linear typing to tame some of the complexity introduced by aliasing. Our algorithmic type system is necessarily co-contextual, achieved through a novel use of backwards bidirectional typing, and we prove it sound and complete with respect to our declarative type system. We implement a prototype type checker, and use it to demonstrate the expressiveness of Pat on a factory automation case study and a series of examples from the Savina actor benchmark suite.Comment: Extended version of paper accepted to ICFP'2

    Immersive Search: Comparing Conventional and Spatially Arranged Search Engine Result Pages in Immersive Virtual Environments

    Get PDF
    Advances in immersive technologies (e.g., virtual reality head-mounted displays) have brought a new dimension into user interfaces to increasingly more people in the recent years. However, little prior work has explored how people could use the extra dimension afforded by VR HMDs to aid in the information retrieval process. My dissertation research investigated how different task types and layouts of search engine result pages (displays) in immersive virtual environments impact the information retrieval process. In this dissertation, I present results from a within-subjects user study to investigate users' search behaviors, system interactions, perceptions, and eye-tracking behaviors for four different spatial arrangements of search results (``list'' - a 2D list; ``curve3'' - a 3x3 grid; ``curve4'' - a 4x4 grid; and ``sphere'' - a 4x4 sphere) in a VR HMD across two different task types (Find All relevant, Pick 3 best). Thirty-two (32) participants completed 5 search trials in 8 experimental conditions (4 displays x 2 task types). Results show that: (1) participants were accepting of and performed well in the spatial displays (curve3, curve4, and sphere); (2) participants had a positional bias for the top or top left of SERPs; (3) the angle of search results and layouts influenced the navigation patterns used; (4) participants had a preference for physical navigation (e.g., head movement) over virtual navigation (e.g., scrolling) to view and compare search results, and (5) participants were less likely to perceive a rank order in the spatial displays where a clear scan path was not obvious to them.Doctor of Philosoph

    Examining the Antecedents and Consequences of Employee Engagement on Temporary Agency Workers in a Partner-led Environment

    Get PDF
    The recent Covid-19 pandemic highlighted the increasing reliance of organisations on temporary agency workers (TAWs) to survive in business environments that are characterised as being temporal, unpredictable, and cyclical. Temporary workforces are growing in popularity as it offers flexibility and independence for both employees and the employer (i.e., The Client). At the same time, the recruitment industry has witnessed significant growth and heightened competition to source reliable, high-quality TAWs as this niche cohort of the workforce underpin the successful performance and outcomes of both agency and client.Despite the increasing number of TAWs and their significant contributions to sustaining competitive advantage and economic growth, extant literature on employee engagement of TAWs to date is rather limited. Also, what research does exist is rather limited as seminal research focused on employee engagement of full time employees, rather than any rigorous examination of engagement with TAWs who operate in turbulent and constantly changing ‘real world’ business environments.This study addresses this gap in knowledge by “examining employee engagement from the perspective of the TAWs to identify the influence and implications of job and organisation engagement”. This study draws on an exemplar case study of a well-known large UK retailer (i.e., The Client) that operates a distribution warehouse and employs TAWs who are sourced through three recruitment agencies.A review of seminal literature provides the theoretical base for the antecedents and proposed outcomes of employee engagement to inform the proposed research model to capture the perceptions of TAW engagement at The Client organisation. A self-completion questionnaire was completed by 277 TAWS and the research model was tested using partial least squares structural equation modelling (PLS-SEM) and SmartPLS v.4.The findings challenge two long-held assumptions about employee engagements First, job engagement and organisation engagement are two significantly distinct constructs that have implications for The Client organisation. Second, experiences of employee engagement for TAWs differ from that of traditional employees as they are heavily reliant on The Client organisation’s ability to support, value and embed them into the workforce and wider mission of the organisation

    The Design Principles of the Elixir Type System

    Full text link
    Elixir is a dynamically-typed functional language running on the Erlang Virtual Machine, designed for building scalable and maintainable applications. Its characteristics have earned it a surging adoption by hundreds of industrial actors and tens of thousands of developers. Static typing seems nowadays to be the most important request coming from the Elixir community. We present a gradual type system we plan to include in the Elixir compiler, outline its characteristics and design principles, and show by some short examples how to use it in practice. Developing a static type system suitable for Erlang's family of languages has been an open research problem for almost two decades. Our system transposes to this family of languages a polymorphic type system with set-theoretic types and semantic subtyping. To do that, we had to improve and extend both semantic subtyping and the typing techniques thereof, to account for several characteristics of these languages -- and of Elixir in particular -- such as the arity of functions, the use of guards, a uniform treatment of records and dictionaries, the need for a new sound gradual typing discipline that does not rely on the insertion at compile time of specific run-time type-tests but, rather, takes into account both the type tests performed by the virtual machine and those explicitly added by the programmer. The system presented here is "gradually" being implemented and integrated in Elixir, but a prototype implementation is already available. The aim of this work is to serve as a longstanding reference that will be used to introduce types to Elixir programmers, as well as to hint at some future directions and possible evolutions of the Elixir language

    Towards Scalable OLTP Over Fast Networks

    Get PDF
    Online Transaction Processing (OLTP) underpins real-time data processing in many mission-critical applications, from banking to e-commerce. These applications typically issue short-duration, latency-sensitive transactions that demand immediate processing. High-volume applications, such as Alibaba's e-commerce platform, achieve peak transaction rates as high as 70 million transactions per second, exceeding the capacity of a single machine. Instead, distributed OLTP database management systems (DBMS) are deployed across multiple powerful machines. Historically, such distributed OLTP DBMSs have been primarily designed to avoid network communication, a paradigm largely unchanged since the 1980s. However, fast networks challenge the conventional belief that network communication is the main bottleneck. In particular, emerging network technologies, like Remote Direct Memory Access (RDMA), radically alter how data can be accessed over a network. RDMA's primitives allow direct access to the memory of a remote machine within an order of magnitude of local memory access. This development invalidates the notion that network communication is the primary bottleneck. Given that traditional distributed database systems have been designed with the premise that the network is slow, they cannot efficiently exploit these fast network primitives, which requires us to reconsider how we design distributed OLTP systems. This thesis focuses on the challenges RDMA presents and its implications on the design of distributed OLTP systems. First, we examine distributed architectures to understand data access patterns and scalability in modern OLTP systems. Drawing on these insights, we advocate a distributed storage engine optimized for high-speed networks. The storage engine serves as the foundation of a database, ensuring efficient data access through three central components: indexes, synchronization primitives, and buffer management (caching). With the introduction of RDMA, the landscape of data access has undergone a significant transformation. This requires a comprehensive redesign of the storage engine components to exploit the potential of RDMA and similar high-speed network technologies. Thus, as the second contribution, we design RDMA-optimized tree-based indexes — especially applicable for disaggregated databases to access remote data efficiently. We then turn our attention to the unique challenges of RDMA. One-sided RDMA, one of the network primitives introduced by RDMA, presents a performance advantage in enabling remote memory access while bypassing the remote CPU and the operating system. This allows the remote CPU to process transactions uninterrupted, with no requirement to be on hand for network communication. However, that way, specialized one-sided RDMA synchronization primitives are required since traditional CPU-driven primitives are bypassed. We found that existing RDMA one-sided synchronization schemes are unscalable or, even worse, fail to synchronize correctly, leading to hard-to-detect data corruption. As our third contribution, we address this issue by offering guidelines to build scalable and correct one-sided RDMA synchronization primitives. Finally, recognizing that maintaining all data in memory becomes economically unattractive, we propose a distributed buffer manager design that efficiently utilizes cost-effective NVMe flash storage. By leveraging low-latency RDMA messages, our buffer manager provides a transparent memory abstraction, accessing the aggregated DRAM and NVMe storage across nodes. Central to our approach is a distributed caching protocol that dynamically caches data. With this approach, our system can outperform RDMA-enabled in-memory distributed databases while managing larger-than-memory datasets efficiently

    Safe Programming Over Distributed Streams

    Get PDF
    The sheer scale of today\u27s data processing needs has led to a new paradigm of software systems centered around requirements for high-throughput, distributed, low-latency computation.Despite their widespread adoption, existing solutions have yet to provide a programming model with safe semantics -- and they disagree on basic design choices, in particular with their approach to parallelism. As a result, naive programmers are easily led to introduce correctness and performance bugs. This work proposes a reliable programming model for modern distributed stream processing, founded in a type system for partially ordered data streams. On top of the core type system, we propose language abstractions for working with streams -- mechanisms to build stream operators with (1) type-safe compositionality, (2) deterministic distribution, (3) run-time testing, and (4) static performance bounds. Our thesis is that viewing streams as partially ordered conveniently exposes parallelism without compromising safety or determinism. The ideas contained in this work are implemented in a series of open source software projects, including the Flumina, DiffStream, and Data Transducers libraries

    Jewish Studies in the Digital Age

    Get PDF
    The digitisation boom of the last two decades, and the rapid advancement of digital tools to analyse data in myriad ways, have opened up new avenues for humanities research. This volume discusses how the so-called digital turn has affected the field of Jewish Studies, explores the current state of the art and probes how digital developments can be harnessed to address the specific questions, challenges and problems in the field

    Legal Records at Risk

    Get PDF
    Why do so few institutions in the legal sector have professional records managers or archivists on their staff? This book is the culmination of a three year project by experienced archivist and records managers on private sector legal records at risk in England at Wales. It summarises the work of the Legal Records at Risk (LRAR) project and its predecessors, diagnoses the problems of preservation of archives in the legal sector in England and Wales and outlines a national strategy for such records

    Raphtory: Modelling, Maintenance and Analysis of Distributed Temporal Graphs.

    Get PDF
    PhD ThesesTemporal graphs capture the development of relationships within data throughout time. This model ts naturally within a streaming architecture, where new events can be inserted directly into the graph upon arrival from a data source and be compared to related entities or historical state. However, the majority of graph processing systems only consider traditional graph analysis on static data, whilst those which do expand past this often only support batched updating and delta analysis across graph snapshots. In this work we de ne a temporal property graph model and the semantics for updating it in both a distributed and non-distributed context. We have built Raphtory, a distributed temporal graph analytics platform which maintains the full graph history in memory, leveraging the de ned update semantics to insert streamed events directly into the model without batching or centralised ordering. In parallel with the ingestion, traditional and time-aware analytics may be performed on the most up-to-date version of the graph, as well as any point throughout its history. The depth of history viewed from the perspective of a time point may also be varied to explore both short and long term patterns within the data. Through this we extract novel insights over a variety of use cases, including phenomena never seen before in social networks. Finally, we demonstrate Raphtory's ability to scale both vertically and horizontally, handling consistent throughput in excess of 100,000 updates a second alongside the ingestion and maintenance of graphs built from billions of events

    Multiparty Session Types for Safe Runtime Adaptation in an Actor Language

    Get PDF
    Human fallibility, unpredictable operational environments, and the heterogeneity (and corresponding resource constraints) of hardware devices are driving in the need for software to be able to \textit{adapt} as seen in the Internet of Things or national telecommunication networks. Unfortunately, mainstream programming languages do not readily allow a software component to sense and respond to its operating environment, by \emph{discovering}, \emph{replacing}, and \emph{communicating} with other software components that are not part of the original system design, while maintaining static correctness guarantees. In particular, if a new component is discovered at runtime, there is no guarantee that its communication \emph{behaviour} is compatible with existing components. We address this problem by using \emph{multiparty session types with explicit connection actions}, a type formalism used to model distributed communication protocols. By associating session types with software components, the discovery process can check protocol compatibility and, when required, correctly replace components. Moreover, the use of session types throughout the software system design guarantees the correctness of all communication, whether or not it is adaptive. We present the design and implementation of EnsembleS, the \emph{first} actor-based language with adaptive features and a static session type system. We apply it to a case study based on an adaptive DNS server. Finally, we formalise the type system of EnsembleS and prove the safety of well-typed programs, making essential use of recent advances in \emph{non-classical} multiparty session types
    • 

    corecore