We present a declarative, object-oriented language in which queries play a central role. Queries are used not only to access data, but also to refer to the application's object members and as a means of program co...
详细信息
ISBN:
(纸本)9781450360302
We present a declarative, object-oriented language in which queries play a central role. Queries are used not only to access data, but also to refer to the application's object members and as a means of program control. The language is fully declarative, with queries and other pure functions defining the relations between the attributes of different objects. A rule-base-like write operation allows state to be updated. Control is achieved by queries selecting the class variants (mixin classes) which are active in each object. The dynamic activation and deactivation of declarative mixin classes allows decomposition of functionality into small reusable classes. The programming style in the language is functional and reactive, with function applications defining object members. Queries are one type of function, which also serves as the glue which puts these functions together, providing them with their input. Since queries describe declaratively what they return, they leave it to the system to implement the how of getting it. Combining this with an organization around objects makes the language highly suitable for complex interactive applications driven by large amounts of data from multiple sources. Our implementation of the language includes a strong display component. It can be seen as a conceptual extension of HTML and CSS in a way which replaces the need for the JavaScript imperative component in web applications. The work described here is not restricted, however, to front-end development and can be applied elsewhere as well.
The proceedings contain 20 papers. The topics discussed include: how to make tasks faster: revealing the complex interactions of tasks in the memory system;combining visual and textual languages for dyslexia;genetic i...
ISBN:
(纸本)9781450355148
The proceedings contain 20 papers. The topics discussed include: how to make tasks faster: revealing the complex interactions of tasks in the memory system;combining visual and textual languages for dyslexia;genetic improvement in code interpreters and compilers;simulation-based code duplication for enhancing compiler optimizations;advanced debugging techniques to identify concurrency bugs in actor-based programs;framework support for usability evaluation of domain-specific languages;understanding the interplay between task scheduling, memory and performance;computer-assisted specification of asynchronous interfaces with non-deterministic behavior;verifying the proxy design pattern using object propositions;ZenSheet Studio: a spreadsheet-inspired environment for reactive computing;how are programming questions from women received on stack overflow? a case study of peer parity;devirtualization in LLVM;Principles, patterns, and techniques for designing and implementing practical fluent interfaces in Java;SmartJS: dynamic and self-adaptable runtime middleware for next-generation IoT systems;incremental parametric syntax for multi-language transformation;and QuixBugs: a multi-lingual program repair benchmark set based on the Quixey challenge.
Previous work has shown how the well-studied and SIMD-friendly Structure of Arrays (SOA) data layout strategy can speed up applications in high-performance computing compared to a traditional Array of Structures (AOS)...
详细信息
Emerging mobile applications, such as cognitive assistance and augmented reality (AR) based gaming, are increasingly computation-intensive and latency-sensitive, while running on resource-constrained devices. The stan...
详细信息
ISBN:
(纸本)9781450349116
Emerging mobile applications, such as cognitive assistance and augmented reality (AR) based gaming, are increasingly computation-intensive and latency-sensitive, while running on resource-constrained devices. The standard approaches to addressing these involve either offloading to a cloud(let) or local system optimizations to speed up the computation, often trading off computation quality for low latency. Instead, we observe that these applications often operate on similar input data from the camera feed and share common processing components, both within the same (type of) applications and across different ones. Therefore, deduplicating processing across applications could deliver the best of both worlds. In this paper, we present Potluck, to achieve approximate deduplication. At the core of the system is a cache service that stores and shares processing results between applications and a set of algorithms to process the input data to maximize deduplication opportunities. This is implemented as a background service on Android. Extensive evaluation shows that Potluck can reduce the processing latency for our AR and vision workloads by a factor of 2.5 to 10.
Low-level programming languages with weak/static type systems, such as C and C++, are vulnerable to errors relating to the misuse of memory at runtime, such as (sub-)object bounds overflows, (re) use-after-free, and t...
详细信息
ISBN:
(纸本)9781450356985
Low-level programming languages with weak/static type systems, such as C and C++, are vulnerable to errors relating to the misuse of memory at runtime, such as (sub-)object bounds overflows, (re) use-after-free, and type confusion. Such errors account for many security and other undefined behavior bugs for programs written in these languages. In this paper, we introduce the notion of dynamically typed C/C++, which aims to detect such errors by dynamically checking the "effective type" of each object before use at runtime. We also present an implementation of dynamically typed C/C++ in the form of the Effective Type Sanitizer (EffectiveSan). EffectiveSan enforces type and memory safety using a combination of low-fat pointers, type meta data and type/bounds check instrumentation. We evaluate EffectiveSan against the SPEC2006 benchmark suite and the Firefox web browser, and detect several new type and memory errors. We also show that EffectiveSan achieves high compatibility and reasonable overheads for the given error coverage. Finally, we highlight that EffectiveSan is one of only a few tools that can detect sub-object bounds errors, and uses a novel approach (dynamic type checking) to do so.
The proceedings contain 6 papers. The topics discussed include: declarative language for context activation;a context-orientedprogramming approach to dependency hell;feature visualizer: an inspection tool for context...
ISBN:
(纸本)9781450357227
The proceedings contain 6 papers. The topics discussed include: declarative language for context activation;a context-orientedprogramming approach to dependency hell;feature visualizer: an inspection tool for context-oriented programmers;a simple context-orientedprogramming extension to an FRP language for small-scale embedded systems;activity contexts: improving modularity in blockchain-based smart contracts using context-orientedprogramming;and cross-cutting commentary: narratives for multi-party mechanisms and concerns.
The demand for thread-level-parallelism (TLP) on commodity processors is endless as it is essential for gaining performance and saving energy. However, TLP in today's programs is limited by dependences that must b...
详细信息
ISBN:
(纸本)9781450349116
The demand for thread-level-parallelism (TLP) on commodity processors is endless as it is essential for gaining performance and saving energy. However, TLP in today's programs is limited by dependences that must be satisfied at run time. We have found that for nondeterministic programs, some of these actual dependences can be satisfied with alternative data that can be generated in parallel, thus boosting the program's TLP. Satisfying these dependences with alternative data nonetheless produces final outputs that match those of the original nondeterministic program. To demonstrate the practicality of our technique, we describe the design, implementation, and evaluation of our compilers, autotuner, profiler, and runtime, which are enabled by our proposed C++ programming language extensions. The resulting system boosts the performance of six well-known nondeterministic and multi-threaded benchmarks by 158.2% (geometric mean) on a 28-core Intel-based platform.
The proceedings contain 21 papers. The topics discussed include: refining semantics for multi-stage programming;staging for generic programming in space and time;a classification of variation control systems;analyzing...
ISBN:
(纸本)9781450355247
The proceedings contain 21 papers. The topics discussed include: refining semantics for multi-stage programming;staging for generic programming in space and time;a classification of variation control systems;analyzing the impact of natural language processing over feature location in models;how preprocessor annotations (do not) affect maintainability: a case study on change-proneness;type qualifiers as composable language extensions;accurate reification of complete supertype information for dynamic analysis on the JVM;rewriting for sound and complete union, intersection and negation types;quoted staged rewriting: a practical approach to library-defined optimizations;reducing calling convention overhead in object-orientedprogramming on embedded ARM Thumb-2 platforms;RaTrace: simple and efficient abstractions for BVH ray traversal algorithms;towards compositional and generative tensor optimizations;avoiding useless mutants;Silverchain: a fluent API generator;parser generation by example for legacy pattern languages;a Haskell compiler for signal transforms;automatic generation of virtual learning spaces driven by CaVaDSL: an experience report;and rewriting a shallow DSL using a GHC compiler extension.
Structure of Arrays (SOA) is a well-studied data layout technique for SIMD architectures. Previous work has shown that it can speed up applications in high-performance computing by several factors compared to a tradit...
详细信息
Data containers enable users to control access to their data while untrusted applications compute on it. However, they require replicating an application inside each container - compromising functionality, programmabi...
详细信息
ISBN:
(纸本)9781450349116
Data containers enable users to control access to their data while untrusted applications compute on it. However, they require replicating an application inside each container - compromising functionality, programmability, and performance. We propose DATS - a system to run web applications that retains application usability and efficiency through a mix of hardware capability enhanced containers and the introduction of two new primitives modeled after the popular model-view-controller (MVC) pattern. (1) DATS introduces a templating language to create views that compose data across data containers. (2) DATS uses authenticated storage and confinement to enable an untrusted storage service, such as memcached and deduplication, to operate on plain-text data across containers. These two primitives act as robust declassifiers that allow DATS to enforce non-interference across containers, taking large applications out of the trusted computing base (TCB). We showcase eight different web applications including Gitlab and a Slack-like chat, significantly improve the worstcase overheads due to application replication, and demonstrate usable performance for common-case usage.
暂无评论