25 research outputs found
Code Generation for Efficient Query Processing in Managed Runtimes
In this paper we examine opportunities arising from the conver-gence of two trends in data management: in-memory database sys-tems (IMDBs), which have received renewed attention following the availability of affordable, very large main memory systems; and language-integrated query, which transparently integrates database queries with programming languages (thus addressing the famous ‘impedance mismatch ’ problem). Language-integrated query not only gives application developers a more convenient way to query external data sources like IMDBs, but also to use the same querying language to query an application’s in-memory collections. The lat-ter offers further transparency to developers as the query language and all data is represented in the data model of the host program-ming language. However, compared to IMDBs, this additional free-dom comes at a higher cost for query evaluation. Our vision is to improve in-memory query processing of application objects by introducing database technologies to managed runtimes. We focus on querying and we leverage query compilation to im-prove query processing on application objects. We explore dif-ferent query compilation strategies and study how they improve the performance of query processing over application data. We take C] as the host programming language as it supports language-integrated query through the LINQ framework. Our techniques de-liver significant performance improvements over the default LINQ implementation. Our work makes important first steps towards a future where data processing applications will commonly run on machines that can store their entire datasets in-memory, and will be written in a single programming language employing language-integrated query and IMDB-inspired runtimes to provide transparent and highly efficient querying. 1
A theory of typed coercions and its applications
A number of important program rewriting scenarios can be recast as type-directed coercion insertion. These range from more theoretical applications such as coercive subtyping and supporting overloading in type theories, to more practical applications such as integrating static and dynamically typed code using gradual typing, and inlining code to enforce security policies such as access control and provenance tracking. In this paper we give a general theory of typedirected coercion insertion. We specifically explore the inherent tradeoff between expressiveness and ambiguity—the more powerful the strategy for generating coercions, the greater the possibility of several, semantically distinct rewritings for a given program. We consider increasingly powerful coercion generation strategies, work out example applications supported by the increased power (including those mentioned above), and identify the inherent ambiguity problems of each setting, along with various techniques to tame the ambiguities
Self-managed collections: Off-heap memory management for scalable query-dominated collections
Java and scala's type systems are unsound: the existential crisis of null pointers
We present short programs that demonstrate the unsoundness of Java and Scala's current type systems. In particular, these programs provide parametrically polymorphic functions that can turn any type into any type without (down) casting. Fortunately, parametric polymorphism was not integrated into the Java Virtual Machine (JVM), so these examples do not demonstrate any unsoundness of the JVM. Nonetheless, we discuss broader implications of these findings on the field of programming languages
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
Lost in Translation: Formalizing Proposed Extensions to C
Current real-world software applications typically involve heavy use of relational and XML data and their query languages. Unfortunately object-oriented languages and database query languages are based on different semantic foundations and optimization strategies. The resulting “ROX (Relations, Objects, XML) impedance mismatch ” makes life very difficult for developers. Microsoft Corporation is developing extensions to the.NET framework to facilitate easier processing of non-objectoriented data models. Part of this project (known as “LINQ”) includes various extensions to the.NET languages to leverage this support. In this paper we consider proposals for C ♯ 3.0, the next version of the C ♯ programming language. We give both an informal introduction to the new language features, and a precise formal account by defining a translation from C ♯ 3.0 to C ♯ 2.0. This translation also demonstrates how these language extensions do not require any changes to the underlying CLR
OOlong : An Extensible Concurrent Object Calculus
We present OOlong, an object calculus with interface inheritance, structured concurrency and locks. The goal of the calculus is extensibility and reuse. The semantics are therefore available in a version for LaTeX typesetting (written in Ott), and a mechanised version for doing rigorous proofs in Coq.Book Group Author(s): Assoc Comp Machinery</p
Semantic subtyping with an SMT solver
We study a first-order functional language with the novel combination of the ideas of refinement type (the subset of a type to satisfy a Boolean expression) and type-test (a Boolean expression testing whether a value belongs to a type). Our core calculus can express a rich variety of typing idioms; for example, intersection, union, negation, singleton, nullable, variant, and algebraic types are all derivable. We formulate a semantics in which expressions denote terms, and types are interpreted as first-order logic formulas. Subtyping is defined as valid implication between the semantics of types. The formulas are interpreted in a specific model that we axiomatize using standard first-order theories. On this basis, we present a novel type-checking algorithm able to eliminate many dynamic tests and to detect many errors statically. The key idea is to rely on an SMT solver to compute subtyping efficiently. Moreover, interpreting types as formulas allows us to call the SMT solver at run-time to compute instances of types