A recurring issue in generative approaches, in particular if they generate code for multiple target languages, is logging. How to ensure that logging is performed consistently for all the supported languages? How to e...
详细信息
ISBN:
(纸本)9781728125350
A recurring issue in generative approaches, in particular if they generate code for multiple target languages, is logging. How to ensure that logging is performed consistently for all the supported languages? How to ensure that the specific semantics of the source language, e.g. a modeling language or a domain-specific language, is reflected in the logs? How to expose logging concepts directly in the source language, so as to let developers specify what to log? This paper reports on our experience developing a concrete logging approach for ThingML, a textual modeling language built around asynchronous components, statecharts and a first-class action language, as well as a set of "compilers" targeting C, Go, Java and JavaScript.
The proceedings contain 74 papers. The topics discussed include: seer: leveraging big data to navigate the complexity of performance debugging in cloud microservices;a framework for memory oversubscription management ...
ISBN:
(纸本)9781450362405
The proceedings contain 74 papers. The topics discussed include: seer: leveraging big data to navigate the complexity of performance debugging in cloud microservices;a framework for memory oversubscription management in graphics processing units;swizzle inventor: data movement synthesis for GPU kernels;scalable processing of contemporary semi-structured data on commodity parallel processors - a compilation-based approach;X-containers: breaking down barriers to improve performance and isolation of cloud-native containers;buffets: an efficient and composable storage idiom for explicit decoupled data orchestration;puddle: a dynamic, error-correcting, full-stack microfluidics platform;intelligence beyond the edge: inference on intermittent embedded systems;and compress objects, not cache lines: an object-based compressed memory hierarchy.
In this extended abstract we explore the expressiveness and modularity of our recently published object propositions methodology by applying it to verify properties about programs that use the proxy design pattern. Th...
详细信息
Recent years are characterized by a growing digitalization of production environment and other areas of human's life. Complex cyber-physical systems play a very important role within this development. Hence, integ...
详细信息
This paper presents the design of a simple context-orientedprogramming extension to Emfrp, a purely functional reactive programming language for resource-constrained embedded systems. The language provides declarativ...
详细信息
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 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.
Pattern matching is a pervasive and useful feature in functional programming. There have been many attempts to bring similar notions to object-orientedprogramming (OOP) in the past. However, a key challenge in OOP is...
详细信息
ISBN:
(纸本)9781450360456
Pattern matching is a pervasive and useful feature in functional programming. There have been many attempts to bring similar notions to object-orientedprogramming (OOP) in the past. However, a key challenge in OOP is how pattern matching can coexist with the open nature of OOP data structures, while at the same time guaranteeing other desirable properties for pattern matching. This paper discusses several desirable properties for pattern matching in an OOP context and shows how existing approaches are lacking some of these properties. We argue that the traditional semantics of pattern matching, which is based on the order of patterns and adopted by many approaches, is in conflict with the openness of data structures. Therefore we suggest that a more restricted, top-level pattern matching model, where the order of patterns is irrelevant, is worthwhile considering in an OOP context. To compensate for the absence of ordered patterns we propose a complementary mechanism for case analysis with defaults, which can be used when nested and/or multiple case analysis is needed. To illustrate our points we develop CASTOR: a meta-programming library in Scala that adopts both ideas. CASTOR generates code that uses type-safe extensible visitors, and largely removes boilerplate code typically associated with visitors. We illustrate the applicability of our approach with a case study modularizing the interpreters in the famous book "Types and programminglanguages".
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.
Two or more incompatible versions of a library are sometimes needed in one software artifact, which is so-called dependency hell. One likely faces the problem if he or she uses two or more libraries that depend on the...
详细信息
暂无评论