Program generation is indispensable. We propose a novel unification of two existing metaprogramming techniques: multi-stage programming and hygienic generative macros. the former supports runtime code generation and e...
详细信息
ISBN:
(纸本)9781450360456
Program generation is indispensable. We propose a novel unification of two existing metaprogramming techniques: multi-stage programming and hygienic generative macros. the former supports runtime code generation and execution in a type-safe manner while the latter offers compile-time code generation. In this work we draw upon a long line of research on metaprogramming, starting with Lisp, MetaML and MetaOCaml. We provide direct support for quotes, splices and top-level splices, all regulated uniformly by a level-counting Phase Consistency Principle. Our design enables the construction and combination of code values for both expressions and types. Moreover, code generation can happen either at runtime a la MetaML or at compile time, in a macro fashion, a la MacroML. We provide an implementation of our design in Scala and we present two case studies. the first implements the Hidden Markov Model, Shonan Challenge for HPC. the second implements the staged streaming library Strymonas.
A modular framework for the development of medical applications that promotes deterministic, robust and correct code is presented. the system is based on the portable Gambit Scheme programming language and provides a ...
详细信息
ISBN:
(纸本)9781450323260
A modular framework for the development of medical applications that promotes deterministic, robust and correct code is presented. the system is based on the portable Gambit Scheme programming language and provides a flexible cross-platform environment for developing graphical applications on mobile devices as well as medical instrumentation interfaces running on embedded platforms. Real world applications of this framework for mobile diagnostics, telemonitoring and automated drug infusions are reported. the source code for the core framework is open source and available at: https://***/part-cw/lambdanative.
In dependently typed languages run-time values can appear in types, making it possible to give programs more precise types than in languages without dependent types. this can range from keeping track of simple invaria...
详细信息
ISBN:
(纸本)9781450323260
In dependently typed languages run-time values can appear in types, making it possible to give programs more precise types than in languages without dependent types. this can range from keeping track of simple invariants like the length of a list, to full functional correctness. In addition to having some correctness guarantees on the final program, assigning more precise types to programs means that you can get more assistance from the type checker while writing them. this is what I focus on here, demonstrating how the programming environment of AGDA can help you when developing dependently typed programs.
One of the core challenges in creating interactive behaviors for social robots is testing. Programs implementing the interactive behaviors require real humans to test and this requirement makes testing of the programs...
详细信息
ISBN:
(数字)9781665407311
ISBN:
(纸本)9781665407311
One of the core challenges in creating interactive behaviors for social robots is testing. Programs implementing the interactive behaviors require real humans to test and this requirement makes testing of the programs extremely expensive. To address this problem, human-robot interaction researchers in the past proposed using human simulators. However, human simulators are tedious to set up and context-dependent and therefore are not widely used in practice. We propose a program synthesis approach to building human simulators for the purpose of testing interactive robot programs. Our key ideas are (1) representing human simulators as probabilistic functional reactive programming programs and (2) using probabilistic inference for synthesizing human simulator programs. Programmers then will be able to build human simulators by providing interaction traces between a robot and a human or two humans which they can later use to test interactive robot programs and improve or tweak as needed.
the proceedings contain 19 papers. the topics discussed include: cooperative specification via composition control;aconite: towards generating Sirius-based graphical editors from annotated metamodels;towards an in-con...
ISBN:
(纸本)9798400711800
the proceedings contain 19 papers. the topics discussed include: cooperative specification via composition control;aconite: towards generating Sirius-based graphical editors from annotated metamodels;towards an in-context LLM-based approach for automating the definition of model views;concrete syntax metapatterns;efficient demand evaluation of fixed-point attributes using static analysis;the design of a self-compiling C transpiler targeting POSIX shell;DSLs in racket: you want it how, now?;design of software representation languages: a historical perspective;trading runtime for energy efficiency: leveraging power caps to save energy across programming languages;cloud programming languages and infrastructure from code: an empirical study;and statically and dynamically delayed sampling for typed probabilistic programming languages.
functional logic programming and probabilistic programming have demonstrated the broad benefits of combining laziness (non-strict evaluation with sharing of the results) with non-determinism. Yet these benefits are se...
详细信息
ISBN:
(纸本)9781605583327
functional logic programming and probabilistic programming have demonstrated the broad benefits of combining laziness (non-strict evaluation with sharing of the results) with non-determinism. Yet these benefits are seldom enjoyed in functionalprogramming, because the existing features for non-strictness, sharing, and non-determinism in functional languages are tricky to combine. We present a practical way to write purely functional lazy non-deterministic programs that are efficient and perspicuous. We achieve this goal by embedding the programs into existing languages (such as Haskell, SML, and OCaml) with high-quality implementations, by making choices lazily and representing data with non-deterministic components, by working with custom monadic data types and search strategies, and by providing equational laws for the programmer to reason about their code.
the proceedings contain 8 papers. the topics discussed include: fluid data structures;detecting unsatisfiable CSS rules in the presence of DTDs;towards compiling graph queries in relational engines;streaming saturatio...
ISBN:
(纸本)9781450367189
the proceedings contain 8 papers. the topics discussed include: fluid data structures;detecting unsatisfiable CSS rules in the presence of DTDs;towards compiling graph queries in relational engines;streaming saturation for large RDF graphs with dynamic schema information;arc: an IR for batch and stream programming;on the semantics of cypher’s implicit group-by;mixing set and bag semantics;and language-integrated provenance by trace analysis.
the evolution of Web sites towards very dynamic applications makes it necessary to reconsider current Web programming technologies. We believe that Web development would benefit greatly from more abstract paradigms an...
详细信息
ISBN:
(纸本)9781605583327
the evolution of Web sites towards very dynamic applications makes it necessary to reconsider current Web programming technologies. We believe that Web development would benefit greatly from more abstract paradigms and that a more semantical approach would result in huge gains in expressiveness. In particular, functionalprogramming provides a really elegant solution to some important Web interaction problems, but few frameworks take advantage of it. the Ocsigen project is an attempt to provide global solutions to these needs. We present our experience in designing this general framework for Web programming, written in Objective Caml. It provides a fully featured Web server and a framework for programming Web applications, withthe aim of improving expressiveness and safety. this is done by taking advantage of functionalprogramming and static typing as much as possible.
We give a denotational model for graphical user interface (GUI) programming using the Cartesian closed category of ultrametric spaces. the ultrametric structure enforces causality restrictions on reactive systems and ...
详细信息
ISBN:
(纸本)9781450308656
We give a denotational model for graphical user interface (GUI) programming using the Cartesian closed category of ultrametric spaces. the ultrametric structure enforces causality restrictions on reactive systems and allows well-founded recursive definitions by a generalization of guardedness. We capture the arbitrariness of user input (e. g., a user gets to decide the stream of clicks she sends to a program) by making use of the fact that the closed subsets of an ultrametric space themselves form an ultrametric space, allowing us to interpret nondeterminism with a "powerspace" monad. Algebras for the powerspace monad yield a model of intuitionistic linear logic, which we exploit in the definition of a mixed linear/non-linear domain-specific language for writing GUI programs. the non-linear part of the language is used for writing reactive stream-processing functions whilst the linear sublanguage naturally captures the generativity and usage constraints on the various linear objects in GUIs, such as the elements of a DOM or scene graph. We have implemented this DSL as an extension to OCaml, and give examples demonstrating that programs in this style can be short and readable.
Infrastructure-from-Code (IfC) is a new approach to DevOps and an advancement of Infrastructure-as-Code (IaC). One of its key concepts is to provide a higher level of abstraction facilitated by new programming languag...
详细信息
ISBN:
(纸本)9798400711800
Infrastructure-from-Code (IfC) is a new approach to DevOps and an advancement of Infrastructure-as-Code (IaC). One of its key concepts is to provide a higher level of abstraction facilitated by new programming languages or software development kits, which automatically generate the necessary code and configurations to provision the infrastructure, deploy the application, andmanage the cloud services. IfC approaches promise higher developer productivity by reducing DevOps-specific tasks and the expert knowledge required. However, empirical studies on developers' performance, perceived ease of use, and usability related to IfC are missing. We conducted a controlled experiment (n=40) to assess the usability of the cloud programming languages (PL) and software development kits (SDK). Both approaches involve similar effectiveness. We found that the PL-based approach was moderately less efficient but increased correctness with time spent on programming. Tracing generated infrastructure configurations from code was more challenging withthe SDK-based approach. Applying thematic analysis, 19 themes emerged related to usability barriers, supporting factors, security, cloud cost, and enhancement areas. We conclude with five findings and future directions.
暂无评论