96 research outputs found
On the Pursuit of Static and Coherent Weaving
Aspect-oriented programming (AOP) has been shown to be a useful
model for software development. Special care must be taken
when we try to adapt AOP to strongly typed functional languages
which come with features like type inference mechanism, polymorphic
types, higher-order functions and type-scoped pointcuts.
Specifically, it is highly desirable that weaving of aspect-oriented
functional programs can be performed statically and coherently. In
[13], we showed a type-directed weaver which resolves all advice
chainings coherently at static time. The novelty of this paper lies in
the extended framework which supports static and coherent weaving
in the presence of polymorphic recursive functions, advising
advice bodies and higher-order advices
Type-Directed Weaving of Aspects for Polymorphically Typed Functional Languages
Incorporating aspect-oriented paradigm to a polymorphically typed functional
language enables the declaration of type-scoped advice, in which the
effect of an aspect can be harnessed by introducing possibly polymorphic
type constraints to the aspect. The amalgamation of aspect orientation and
functional programming enables quick behavioral adaption of functions, clear
separation of concerns and expressive type-directed programming. However,
proper static weaving of aspects in polymorphic languages with a type-erasure
semantics remains a challenge. In this paper, we describe a type-directed
static weaving strategy, as well as its implementation, that supports
static type inference and static weaving of programs written in an aspect-oriented
polymorphically typed functional language, AspectFun. We show
examples of type-scoped advice, identify the challenges faced with compile-time
weaving in the presence of type-scoped advice, and demonstrate how
various advanced aspect features can be handled by our techniques. Lastly,
we prove the correctness of the static weaving strategy with respect to the
operational semantics of AspectFun
What Does Aspect-Oriented Programming Mean for Functional Programmers?
Aspect-Oriented Programming (AOP) aims at modularising crosscutting concerns that show up in software. The success of AOP has been almost viral and nearly all areas in Software Engineering and Programming Languages have become "infected" by the AOP bug in one way or another. Interestingly the functional programming community (and, in particular, the pure functional programming community) seems to be resistant to the pandemic. The goal of this paper is to debate the possible causes of the functional programming community's resistance and to raise awareness and interest by showcasing the benefits that could be gained from having a functional AOP language. At the same time, we identify the main challenges and explore the possible design-space
Side-Effect Localization for Lazy, Purely Functional Languages via Aspects
Many side-effecting programming activities, such as profiling and tracing,
can be formulated as crosscutting concerns and be framed as side-effecting aspects in the aspect-oriented programming paradigm. The benefit gained from this separation of concerns is particularly evident in purely functional programming, as adding such aspects using techniques such as monadification will generally lead to crosscutting changes. This paper presents an approach to provide side-effecting aspects for lazy purely functional languages in a user transparent fashion. We propose a simple yet direct state manipulation construct for developing side-effecting aspects and devise a
systematic monadification scheme to translate the woven code to monadic style purely functional code. Furthermore, we present a static and dynamic semantics of the aspect programs and reason about the correctness of our monadification scheme with respect to them
A Typed Slicing Compilation of the Polymorphic RPC Calculus
The polymorphic RPC calculus allows programmers to write succinct multitier
programs using polymorphic location constructs. However, until now it lacked an
implementation. We develop an experimental programming language based on the
polymorphic RPC calculus. We introduce a polymorphic Client-Server (CS)
calculus with the client and server parts separated. In contrast to existing
untyped CS calculi, our calculus is not only able to resolve polymorphic
locations statically, but it is also able to do so dynamically. We design a
type-based slicing compilation of the polymorphic RPC calculus into this CS
calculus, proving type and semantic correctness. We propose a method to erase
types unnecessary for execution but retaining locations at runtime by
translating the polymorphic CS calculus into an untyped CS calculus, proving
semantic correctness.Comment: A long version of PPDP 2021 (23rd International Symposium on
Principles and Practice of Declarative Programming
Optimization Coaching for JavaScript
The performance of dynamic object-oriented programming languages such as JavaScript depends heavily on highly optimizing just-in-time compilers. Such compilers, like all compilers, can silently fall back to generating conservative, low-performance code during optimization. As a result, programmers may inadvertently cause performance issues on users\u27 systems by making seemingly inoffensive changes to programs. This paper shows how to solve the problem of silent optimization failures. It specifically explains how to create a so-called optimization coach for an object-oriented just-in-time-compiled programming language. The development and evaluation build on the SpiderMonkey JavaScript engine, but the results should generalize to a variety of similar platforms
Static and dynamic semantics of NoSQL languages
We present a calculus for processing semistructured data that spans
differences of application area among several novel query languages, broadly
categorized as "NoSQL". This calculus lets users define their own operators,
capturing a wider range of data processing capabilities, whilst providing a
typing precision so far typical only of primitive hard-coded operators. The
type inference algorithm is based on semantic type checking, resulting in type
information that is both precise, and flexible enough to handle structured and
semistructured data. We illustrate the use of this calculus by encoding a large
fragment of Jaql, including operations and iterators over JSON, embedded SQL
expressions, and co-grouping, and show how the encoding directly yields a
typing discipline for Jaql as it is, namely without the addition of any type
definition or type annotation in the code
Overcoming Restraint: Composing Verification of Foreign Functions with Cogent
Cogent is a restricted functional language designed to reduce the cost of
developing verified systems code. Because of its sometimes-onerous
restrictions, such as the lack of support for recursion and its strict
uniqueness type system, Cogent provides an escape hatch in the form of a
foreign function interface (FFI) to C code. This poses a problem when verifying
Cogent programs, as imported C components do not enjoy the same level of static
guarantees that Cogent does. Previous verification of file systems implemented
in Cogent merely assumed that their C components were correct and that they
preserved the invariants of Cogent's type system. In this paper, we instead
prove such obligations. We demonstrate how they smoothly compose with existing
Cogent theorems, and result in a correctness theorem of the overall Cogent-C
system. The Cogent FFI constraints ensure that key invariants of Cogent's type
system are maintained even when calling C code. We verify reusable higher-order
and polymorphic functions including a generic loop combinator and array
iterators and demonstrate their application to several examples including
binary search and the BilbyFs file system. We demonstrate the feasibility of
verification of mixed Cogent-C systems, and provide some insight into
verification of software comprised of code in multiple languages with differing
levels of static guarantees
- âŚ