Results 1 -
4 of
4
Reify Your Collection Queries for Modularity and Speed!
"... Modularity and efficiency are often contradicting requirements, such that programers have to trade one for the other. We analyze this dilemma in the context of programs operating on collections. Performance-critical code using collections need often to be hand-optimized, leading to non-modular, brit ..."
Abstract
-
Cited by 2 (1 self)
- Add to MetaCart
(Show Context)
Modularity and efficiency are often contradicting requirements, such that programers have to trade one for the other. We analyze this dilemma in the context of programs operating on collections. Performance-critical code using collections need often to be hand-optimized, leading to non-modular, brittle, and redundant code. In principle, this dilemma could be avoided by automatic collection-specific optimizations, such as fusion of collection traversals, usage of indexing, or reordering of filters. Unfortunately, it is not obvious how to encode such optimizations in terms of ordinary collection APIs, because the program operating on the collections is not reified and hence cannot be analyzed. We propose SQuOpt, the Scala Query Optimizer—a deep embedding of the Scala collections API that allows such analyses and optimizations to be defined and executed within Scala, without relying on external tools or compiler extensions. SQuOpt provides the same “look and feel ” (syntax and static typing guarantees) as the standard collections API. We evaluate SQuOpt by re-implementing several code analyses of the FindBugs tool using SQuOpt, show average speedups of 12x with a maximum of 12800x and hence demonstrate that SQuOpt can reconcile modularity and efficiency in real-world applications.
Compiling LINQ and a Scala subset into SQL:1999
, 2009
"... Persistent programming languages have yet to embrace two relatively recent developments: (a) the integration of the functional and object paradigms; and (b) advances in optimization techniques for functional query languages. The expressiveness thus gained over the relational data model calls for an ..."
Abstract
-
Cited by 1 (1 self)
- Add to MetaCart
(Show Context)
Persistent programming languages have yet to embrace two relatively recent developments: (a) the integration of the functional and object paradigms; and (b) advances in optimization techniques for functional query languages. The expressiveness thus gained over the relational data model calls for an extended research agenda. We focus in this technical report on two subproblems from that agenda. Firstly, we address the engineering issues associated to making the Scala compiler aware about comprehensions, which constitute the semantic foundation for both Microsoft’s LINQ and the Scala notation for (main-memory) querying. As with other expressions in the host language, the queries thus embedded are subject to syntactic and semantic analyses, followed by a translation into an optimizing query language (Ferry) which targets SQL:1999. The second problem area we address involves showing the translation above to be semantics preserving, as established after comparing relevant aspects of the LINQ, Scala and Ferry type systems. The reported techniques constitute a basis for further progress in bridging the programming and the database worlds.
unknown title
"... Abstract Some programming languages provide language-level integration for event processing. Objectoriented languages offer language constructs for imperatively triggered events as object attributes. Aspect-oriented languages feature implicit events that are defined as identifiable points in the co ..."
Abstract
- Add to MetaCart
(Show Context)
Abstract Some programming languages provide language-level integration for event processing. Objectoriented languages offer language constructs for imperatively triggered events as object attributes. Aspect-oriented languages feature implicit events that are defined as identifiable points in the control flow of a program. However, such a language-level integration is not yet available for complex event processing (CEP) where event streams from multiple sources are combined to infer higher-level and more abstract complex events. In this thesis we propose an approach to introduce language-level support for CEP into Scala. Zusammenfassung Manche Programmiersprachen haben eine tiefe Integration für die Verarbeitung von Ereignissen: Objektorientierte Sprachen enthalten Sprachkonstrukte, die es ermöglichen Ereignisse als explizit auslösbare Objektattribute auszudrücken. Aspektorientierte Sprachen unterstützen implizite Ereignisse, die durch identifizierbare Punkte im Ablauf eines Programms definiert sind. Diese Art von Sprachintegration ist jedoch noch nicht für Complex Event Processing (CEP) verfügbar, eine Technik bei der Ereignisse aus einer Vielzahl von Quellen miteinander kombiniert werden um abstraktere komplexe Ereignisse abzuleiten. In dieser Thesis besprechen wir einen Ansatz zur Integration von CEP in Scala auf Sprachebene.
Reify Your Collection Queries for Modularity and Speed! Extended Version Tillmann Rendel
"... ABSTRACT Modularity and efficiency are often contradicting requirements, such that programers have to trade one for the other. We analyze this dilemma in the context of programs operating on collections. Performance-critical code using collections need often to be hand-optimized, leading to nonmodu ..."
Abstract
- Add to MetaCart
(Show Context)
ABSTRACT Modularity and efficiency are often contradicting requirements, such that programers have to trade one for the other. We analyze this dilemma in the context of programs operating on collections. Performance-critical code using collections need often to be hand-optimized, leading to nonmodular, brittle, and redundant code. In principle, this dilemma could be avoided by automatic collection-specific optimizations, such as fusion of collection traversals, usage of indexing, or reordering of filters. Unfortunately, it is not obvious how to encode such optimizations in terms of ordinary collection APIs, because the program operating on the collections is not reified and hence cannot be analyzed. We propose SQuOpt, the Scala Query Optimizer-a deep embedding of the Scala collections API that allows such analyses and optimizations to be defined and executed within Scala, without relying on external tools or compiler extensions. SQuOpt provides the same "look and feel" (syntax and static typing guarantees) as the standard collections API. We evaluate SQuOpt by re-implementing several code analyses of the Findbugs tool using SQuOpt, show average speedups of 12x with a maximum of 12800x and hence demonstrate that SQuOpt can reconcile modularity and efficiency in real-world applications.
