Art Sci. Eng. Program., vol. 6, issue 1: "A Functional Programming Language ..."
A Functional Programming Language with Versions
Yudai Tanabe, Luthfan Anshar Lubis, Tomoyuki Aotani, and Hidehiko Masuhara
(Tokyo Institute of Technology, Japan; Mamezou, Japan)
While modern software development heavily uses versioned packages, programming languages rarely support the concept of versions in their semantics, which makes software updates more bulky and unsafe. This paper proposes a programming language that intrinsically supports versions. The main goals are to design core language features to support multiple versions in one program and establish a proper notion of type safety with those features. The proposed core calculus, called Lambda VL, has versioned values, each containing different values under different versions. We show the construction of the type system as an extension of coeffect calculus by mapping versions to computational resources. The type system guarantees the existence of a valid combination of versions for a program. The calculus enables programming languages to use multiple versions of a package within a program. It will serve as a basis for designing advanced language features like module systems and semantic versioning.
@Article{Programming Journal, Volume22p5,
author = {Yudai Tanabe and Luthfan Anshar Lubis and Tomoyuki Aotani and Hidehiko Masuhara},
title = {A Functional Programming Language with Versions},
journal = {},
volume = {},
number = {},
articleno = {5},
numpages = {30},
doi = {10.22152/programming-journal.org/2022/6/5},
year = {2022},
}
Publisher's Version
Art Sci. Eng. Program., vol. 6, issue 1: "Deriving Static Security Testing ..."
Deriving Static Security Testing from Runtime Security Protection for Web Applications
Angel Luis Scull Pupo, Jens Nicolay, and Elisa Gonzalez Boix
(Vrije Universiteit Brussel, Belgium)
Context: Static Application Security Testing (SAST) and Runtime Application Security Protection (RASP) are important and complementary techniques used for detecting and enforcing application-level security policies in web applications.
Inquiry: The current state of the art, however, does not allow a safe and efficient combination of SAST and RASP based on a shared set of security policies, forcing developers to reimplement and maintain the same policies and their enforcement code in both tools.
Approach: In this work, we present a novel technique for deriving SAST from an existing RASP mechanism by using a two-phase abstract interpretation approach in the SAST component that avoids duplicating the effort of specifying security policies and implementing their semantics. The RASP mechanism enforces security policies by instrumenting a base program to trap security-relevant operations and execute the required policy enforcement code. The static analysis of security policies is then obtained from the RASP mechanism by first statically analyzing the base program without any traps. The results of this first phase are used in a second phase to detect trapped operations and abstractly execute the associated and unaltered RASP policy enforcement code.
Knowledge: Splitting the analysis into two phases enables running each phase with a specific analysis configuration, rendering the static analysis approach tractable while maintaining sufficient precision.
Grounding: We validate the applicability of our two-phase analysis approach by using it to both dynamically enforce and statically detect a range of security policies found in related work. Our experiments suggest that our two-phase analysis can enable faster and more precise policy violation detection compared to analyzing the full instrumented application under a single analysis configuration.
Importance: Deriving a SAST component from a RASP mechanism enables equivalent semantics for the security policies across the static and dynamic contexts in which policies are verified during the software development lifecycle. Moreover, our two-phase abstract interpretation approach does not require RASP developers to reimplement the enforcement code for static analysis.
@Article{Programming Journal, Volume22p1,
author = {Angel Luis Scull Pupo and Jens Nicolay and Elisa Gonzalez Boix},
title = {Deriving Static Security Testing from Runtime Security Protection for Web Applications},
journal = {},
volume = {},
number = {},
articleno = {1},
numpages = {41},
doi = {10.22152/programming-journal.org/2022/6/1},
year = {2022},
}
Publisher's Version
Art Sci. Eng. Program., vol. 6, issue 1: "An Optimised Flow for Futures: ..."
An Optimised Flow for Futures: From Theory to Practice
Nicolas Chappe, Ludovic Henrio, Amaury Maillé, Matthieu Moy, and Hadrien Renaud
(University of Lyon, France; EnsL, France; Claude Bernard University Lyon 1, France; CNRS, France; Inria, France; LIP, France; École Polytechnique, France; Institut Polytechnique de Paris, France)
A future is an entity representing the result of an ongoing computation. A synchronisation with a "get" operation blocks the caller until the computation is over, to return the corresponding value. When a computation in charge of fulfilling a future delegates part of its processing to another task, mainstream languages return nested futures, and several "get" operations are needed to retrieve the computed value (we call such futures "control-flow futures"). Several approaches were proposed to tackle this issues: the "forward" construct, that allows the programmer to make delegation explicit and avoid nested futures, and "data-flow explicit futures" which natively collapse nested futures into plain futures.
This paper supports the claim that data-flow explicit futures form a powerful set of language primitives, on top of which other approaches can be built. We prove the equivalence, in the context of data-flow explicit futures, between the "forward" construct and classical "return" from functions. The proof relies on a branching bisimulation between a program using "forward" and its "return" counterpart. This result allows language designers to consider "forward" as an optimisation directive rather than as a language primitive.
Following the principles of the Godot system, we provide a library implementation of control-flow futures, based on data-flow explicit futures implemented in the compiler. This small library supports the claim that the implementation of classical futures based on data-flow ones is easier than the opposite. Our benchmarks show the viability of the approach from a performance point of view.
@Article{Programming Journal, Volume22p3,
author = {Nicolas Chappe and Ludovic Henrio and Amaury Maillé and Matthieu Moy and Hadrien Renaud},
title = {An Optimised Flow for Futures: From Theory to Practice},
journal = {},
volume = {},
number = {},
articleno = {3},
numpages = {41},
doi = {10.22152/programming-journal.org/2022/6/3},
year = {2022},
}
Publisher's Version
Art Sci. Eng. Program., vol. 6, issue 1: "The Art of the Meta Stream ..."
The Art of the Meta Stream Protocol: Torrents of Streams
Christophe De Troyer, Jens Nicolay, and Wolfgang De Meuter
(Vrije Universiteit Brussel, Belgium)
The rise of streaming libraries such as Akka Stream, Reactive Extensions, and LINQ popularized the declarative functional style of data processing. The stream paradigm offers concise syntax to write down processing pipelines to consume the vast amounts of real-time data available today.
These libraries offer the programmer a domain specific language (DSL) embedded in the host language to describe data streams. These libraries however, all suffer from extensibility issues. The semantics of a stream is hard-coded into the DSL language and cannot be changed by the user of the library.
We introduce an approach to modify the semantics of a streaming library by means of meta-programming at both run-time and compile-time, and showcase its generality.
We show that the expressiveness of the meta-facilities is strong enough to enable push and pull semantics, error handling, parallelism, and operator fusion.
We evaluate our work by implementing the identified shortcomings in terms of a novel stream meta-architecture and show that its design and architecture adhere to the design principles of a meta-level architecture.
The state of the art offers plenty of choice to programmers regarding reactive stream processing libraries. Expressing reactive systems is otherwise difficult to do in general purpose languages. Extensibility and fine-tuning should be possible in these libraries to ensure a broad variety of applications can be expressed within this single DSL.
@Article{Programming Journal, Volume22p2,
author = {Christophe De Troyer and Jens Nicolay and Wolfgang De Meuter},
title = {The Art of the Meta Stream Protocol: Torrents of Streams},
journal = {},
volume = {},
number = {},
articleno = {2},
numpages = {40},
doi = {10.22152/programming-journal.org/2022/6/2},
year = {2022},
}
Publisher's Version
Art Sci. Eng. Program., vol. 6, issue 1: "The Art of the Meta Stream ..."
The Art of the Meta Stream Protocol: Torrents of Streams
Christophe De Troyer, Jens Nicolay, and Wolfgang De Meuter
(Vrije Universiteit Brussel, Belgium)
The rise of streaming libraries such as Akka Stream, Reactive Extensions, and LINQ popularized the declarative functional style of data processing. The stream paradigm offers concise syntax to write down processing pipelines to consume the vast amounts of real-time data available today.
These libraries offer the programmer a domain specific language (DSL) embedded in the host language to describe data streams. These libraries however, all suffer from extensibility issues. The semantics of a stream is hard-coded into the DSL language and cannot be changed by the user of the library.
We introduce an approach to modify the semantics of a streaming library by means of meta-programming at both run-time and compile-time, and showcase its generality.
We show that the expressiveness of the meta-facilities is strong enough to enable push and pull semantics, error handling, parallelism, and operator fusion.
We evaluate our work by implementing the identified shortcomings in terms of a novel stream meta-architecture and show that its design and architecture adhere to the design principles of a meta-level architecture.
The state of the art offers plenty of choice to programmers regarding reactive stream processing libraries. Expressing reactive systems is otherwise difficult to do in general purpose languages. Extensibility and fine-tuning should be possible in these libraries to ensure a broad variety of applications can be expressed within this single DSL.
@Article{Programming Journal, Volume22p2,
author = {Christophe De Troyer and Jens Nicolay and Wolfgang De Meuter},
title = {The Art of the Meta Stream Protocol: Torrents of Streams},
journal = {},
volume = {},
number = {},
articleno = {2},
numpages = {40},
doi = {10.22152/programming-journal.org/2022/6/2},
year = {2022},
}
Publisher's Version
Art Sci. Eng. Program., vol. 6, issue 1: "An Optimised Flow for Futures: ..."
An Optimised Flow for Futures: From Theory to Practice
Nicolas Chappe, Ludovic Henrio, Amaury Maillé, Matthieu Moy, and Hadrien Renaud
(University of Lyon, France; EnsL, France; Claude Bernard University Lyon 1, France; CNRS, France; Inria, France; LIP, France; École Polytechnique, France; Institut Polytechnique de Paris, France)
A future is an entity representing the result of an ongoing computation. A synchronisation with a "get" operation blocks the caller until the computation is over, to return the corresponding value. When a computation in charge of fulfilling a future delegates part of its processing to another task, mainstream languages return nested futures, and several "get" operations are needed to retrieve the computed value (we call such futures "control-flow futures"). Several approaches were proposed to tackle this issues: the "forward" construct, that allows the programmer to make delegation explicit and avoid nested futures, and "data-flow explicit futures" which natively collapse nested futures into plain futures.
This paper supports the claim that data-flow explicit futures form a powerful set of language primitives, on top of which other approaches can be built. We prove the equivalence, in the context of data-flow explicit futures, between the "forward" construct and classical "return" from functions. The proof relies on a branching bisimulation between a program using "forward" and its "return" counterpart. This result allows language designers to consider "forward" as an optimisation directive rather than as a language primitive.
Following the principles of the Godot system, we provide a library implementation of control-flow futures, based on data-flow explicit futures implemented in the compiler. This small library supports the claim that the implementation of classical futures based on data-flow ones is easier than the opposite. Our benchmarks show the viability of the approach from a performance point of view.
@Article{Programming Journal, Volume22p3,
author = {Nicolas Chappe and Ludovic Henrio and Amaury Maillé and Matthieu Moy and Hadrien Renaud},
title = {An Optimised Flow for Futures: From Theory to Practice},
journal = {},
volume = {},
number = {},
articleno = {3},
numpages = {41},
doi = {10.22152/programming-journal.org/2022/6/3},
year = {2022},
}
Publisher's Version
Art Sci. Eng. Program., vol. 6, issue 1: "A Functional Programming Language ..."
A Functional Programming Language with Versions
Yudai Tanabe, Luthfan Anshar Lubis, Tomoyuki Aotani, and Hidehiko Masuhara
(Tokyo Institute of Technology, Japan; Mamezou, Japan)
While modern software development heavily uses versioned packages, programming languages rarely support the concept of versions in their semantics, which makes software updates more bulky and unsafe. This paper proposes a programming language that intrinsically supports versions. The main goals are to design core language features to support multiple versions in one program and establish a proper notion of type safety with those features. The proposed core calculus, called Lambda VL, has versioned values, each containing different values under different versions. We show the construction of the type system as an extension of coeffect calculus by mapping versions to computational resources. The type system guarantees the existence of a valid combination of versions for a program. The calculus enables programming languages to use multiple versions of a package within a program. It will serve as a basis for designing advanced language features like module systems and semantic versioning.
@Article{Programming Journal, Volume22p5,
author = {Yudai Tanabe and Luthfan Anshar Lubis and Tomoyuki Aotani and Hidehiko Masuhara},
title = {A Functional Programming Language with Versions},
journal = {},
volume = {},
number = {},
articleno = {5},
numpages = {30},
doi = {10.22152/programming-journal.org/2022/6/5},
year = {2022},
}
Publisher's Version
Art Sci. Eng. Program., vol. 6, issue 1: "An Optimised Flow for Futures: ..."
An Optimised Flow for Futures: From Theory to Practice
Nicolas Chappe, Ludovic Henrio, Amaury Maillé, Matthieu Moy, and Hadrien Renaud
(University of Lyon, France; EnsL, France; Claude Bernard University Lyon 1, France; CNRS, France; Inria, France; LIP, France; École Polytechnique, France; Institut Polytechnique de Paris, France)
A future is an entity representing the result of an ongoing computation. A synchronisation with a "get" operation blocks the caller until the computation is over, to return the corresponding value. When a computation in charge of fulfilling a future delegates part of its processing to another task, mainstream languages return nested futures, and several "get" operations are needed to retrieve the computed value (we call such futures "control-flow futures"). Several approaches were proposed to tackle this issues: the "forward" construct, that allows the programmer to make delegation explicit and avoid nested futures, and "data-flow explicit futures" which natively collapse nested futures into plain futures.
This paper supports the claim that data-flow explicit futures form a powerful set of language primitives, on top of which other approaches can be built. We prove the equivalence, in the context of data-flow explicit futures, between the "forward" construct and classical "return" from functions. The proof relies on a branching bisimulation between a program using "forward" and its "return" counterpart. This result allows language designers to consider "forward" as an optimisation directive rather than as a language primitive.
Following the principles of the Godot system, we provide a library implementation of control-flow futures, based on data-flow explicit futures implemented in the compiler. This small library supports the claim that the implementation of classical futures based on data-flow ones is easier than the opposite. Our benchmarks show the viability of the approach from a performance point of view.
@Article{Programming Journal, Volume22p3,
author = {Nicolas Chappe and Ludovic Henrio and Amaury Maillé and Matthieu Moy and Hadrien Renaud},
title = {An Optimised Flow for Futures: From Theory to Practice},
journal = {},
volume = {},
number = {},
articleno = {3},
numpages = {41},
doi = {10.22152/programming-journal.org/2022/6/3},
year = {2022},
}
Publisher's Version
Art Sci. Eng. Program., vol. 6, issue 1: "A Functional Programming Language ..."
A Functional Programming Language with Versions
Yudai Tanabe, Luthfan Anshar Lubis, Tomoyuki Aotani, and Hidehiko Masuhara
(Tokyo Institute of Technology, Japan; Mamezou, Japan)
While modern software development heavily uses versioned packages, programming languages rarely support the concept of versions in their semantics, which makes software updates more bulky and unsafe. This paper proposes a programming language that intrinsically supports versions. The main goals are to design core language features to support multiple versions in one program and establish a proper notion of type safety with those features. The proposed core calculus, called Lambda VL, has versioned values, each containing different values under different versions. We show the construction of the type system as an extension of coeffect calculus by mapping versions to computational resources. The type system guarantees the existence of a valid combination of versions for a program. The calculus enables programming languages to use multiple versions of a package within a program. It will serve as a basis for designing advanced language features like module systems and semantic versioning.
@Article{Programming Journal, Volume22p5,
author = {Yudai Tanabe and Luthfan Anshar Lubis and Tomoyuki Aotani and Hidehiko Masuhara},
title = {A Functional Programming Language with Versions},
journal = {},
volume = {},
number = {},
articleno = {5},
numpages = {30},
doi = {10.22152/programming-journal.org/2022/6/5},
year = {2022},
}
Publisher's Version
Art Sci. Eng. Program., vol. 6, issue 1: "An Optimised Flow for Futures: ..."
An Optimised Flow for Futures: From Theory to Practice
Nicolas Chappe, Ludovic Henrio, Amaury Maillé, Matthieu Moy, and Hadrien Renaud
(University of Lyon, France; EnsL, France; Claude Bernard University Lyon 1, France; CNRS, France; Inria, France; LIP, France; École Polytechnique, France; Institut Polytechnique de Paris, France)
A future is an entity representing the result of an ongoing computation. A synchronisation with a "get" operation blocks the caller until the computation is over, to return the corresponding value. When a computation in charge of fulfilling a future delegates part of its processing to another task, mainstream languages return nested futures, and several "get" operations are needed to retrieve the computed value (we call such futures "control-flow futures"). Several approaches were proposed to tackle this issues: the "forward" construct, that allows the programmer to make delegation explicit and avoid nested futures, and "data-flow explicit futures" which natively collapse nested futures into plain futures.
This paper supports the claim that data-flow explicit futures form a powerful set of language primitives, on top of which other approaches can be built. We prove the equivalence, in the context of data-flow explicit futures, between the "forward" construct and classical "return" from functions. The proof relies on a branching bisimulation between a program using "forward" and its "return" counterpart. This result allows language designers to consider "forward" as an optimisation directive rather than as a language primitive.
Following the principles of the Godot system, we provide a library implementation of control-flow futures, based on data-flow explicit futures implemented in the compiler. This small library supports the claim that the implementation of classical futures based on data-flow ones is easier than the opposite. Our benchmarks show the viability of the approach from a performance point of view.
@Article{Programming Journal, Volume22p3,
author = {Nicolas Chappe and Ludovic Henrio and Amaury Maillé and Matthieu Moy and Hadrien Renaud},
title = {An Optimised Flow for Futures: From Theory to Practice},
journal = {},
volume = {},
number = {},
articleno = {3},
numpages = {41},
doi = {10.22152/programming-journal.org/2022/6/3},
year = {2022},
}
Publisher's Version
Art Sci. Eng. Program., vol. 6, issue 1: "Deriving Static Security Testing ..."
Deriving Static Security Testing from Runtime Security Protection for Web Applications
Angel Luis Scull Pupo, Jens Nicolay, and Elisa Gonzalez Boix
(Vrije Universiteit Brussel, Belgium)
Context: Static Application Security Testing (SAST) and Runtime Application Security Protection (RASP) are important and complementary techniques used for detecting and enforcing application-level security policies in web applications.
Inquiry: The current state of the art, however, does not allow a safe and efficient combination of SAST and RASP based on a shared set of security policies, forcing developers to reimplement and maintain the same policies and their enforcement code in both tools.
Approach: In this work, we present a novel technique for deriving SAST from an existing RASP mechanism by using a two-phase abstract interpretation approach in the SAST component that avoids duplicating the effort of specifying security policies and implementing their semantics. The RASP mechanism enforces security policies by instrumenting a base program to trap security-relevant operations and execute the required policy enforcement code. The static analysis of security policies is then obtained from the RASP mechanism by first statically analyzing the base program without any traps. The results of this first phase are used in a second phase to detect trapped operations and abstractly execute the associated and unaltered RASP policy enforcement code.
Knowledge: Splitting the analysis into two phases enables running each phase with a specific analysis configuration, rendering the static analysis approach tractable while maintaining sufficient precision.
Grounding: We validate the applicability of our two-phase analysis approach by using it to both dynamically enforce and statically detect a range of security policies found in related work. Our experiments suggest that our two-phase analysis can enable faster and more precise policy violation detection compared to analyzing the full instrumented application under a single analysis configuration.
Importance: Deriving a SAST component from a RASP mechanism enables equivalent semantics for the security policies across the static and dynamic contexts in which policies are verified during the software development lifecycle. Moreover, our two-phase abstract interpretation approach does not require RASP developers to reimplement the enforcement code for static analysis.
@Article{Programming Journal, Volume22p1,
author = {Angel Luis Scull Pupo and Jens Nicolay and Elisa Gonzalez Boix},
title = {Deriving Static Security Testing from Runtime Security Protection for Web Applications},
journal = {},
volume = {},
number = {},
articleno = {1},
numpages = {41},
doi = {10.22152/programming-journal.org/2022/6/1},
year = {2022},
}
Publisher's Version
Art Sci. Eng. Program., vol. 6, issue 1: "The Art of the Meta Stream ..."
The Art of the Meta Stream Protocol: Torrents of Streams
Christophe De Troyer, Jens Nicolay, and Wolfgang De Meuter
(Vrije Universiteit Brussel, Belgium)
The rise of streaming libraries such as Akka Stream, Reactive Extensions, and LINQ popularized the declarative functional style of data processing. The stream paradigm offers concise syntax to write down processing pipelines to consume the vast amounts of real-time data available today.
These libraries offer the programmer a domain specific language (DSL) embedded in the host language to describe data streams. These libraries however, all suffer from extensibility issues. The semantics of a stream is hard-coded into the DSL language and cannot be changed by the user of the library.
We introduce an approach to modify the semantics of a streaming library by means of meta-programming at both run-time and compile-time, and showcase its generality.
We show that the expressiveness of the meta-facilities is strong enough to enable push and pull semantics, error handling, parallelism, and operator fusion.
We evaluate our work by implementing the identified shortcomings in terms of a novel stream meta-architecture and show that its design and architecture adhere to the design principles of a meta-level architecture.
The state of the art offers plenty of choice to programmers regarding reactive stream processing libraries. Expressing reactive systems is otherwise difficult to do in general purpose languages. Extensibility and fine-tuning should be possible in these libraries to ensure a broad variety of applications can be expressed within this single DSL.
@Article{Programming Journal, Volume22p2,
author = {Christophe De Troyer and Jens Nicolay and Wolfgang De Meuter},
title = {The Art of the Meta Stream Protocol: Torrents of Streams},
journal = {},
volume = {},
number = {},
articleno = {2},
numpages = {40},
doi = {10.22152/programming-journal.org/2022/6/2},
year = {2022},
}
Publisher's Version
Art Sci. Eng. Program., vol. 6, issue 1: "Deriving Static Security Testing ..."
Deriving Static Security Testing from Runtime Security Protection for Web Applications
Angel Luis Scull Pupo, Jens Nicolay, and Elisa Gonzalez Boix
(Vrije Universiteit Brussel, Belgium)
Context: Static Application Security Testing (SAST) and Runtime Application Security Protection (RASP) are important and complementary techniques used for detecting and enforcing application-level security policies in web applications.
Inquiry: The current state of the art, however, does not allow a safe and efficient combination of SAST and RASP based on a shared set of security policies, forcing developers to reimplement and maintain the same policies and their enforcement code in both tools.
Approach: In this work, we present a novel technique for deriving SAST from an existing RASP mechanism by using a two-phase abstract interpretation approach in the SAST component that avoids duplicating the effort of specifying security policies and implementing their semantics. The RASP mechanism enforces security policies by instrumenting a base program to trap security-relevant operations and execute the required policy enforcement code. The static analysis of security policies is then obtained from the RASP mechanism by first statically analyzing the base program without any traps. The results of this first phase are used in a second phase to detect trapped operations and abstractly execute the associated and unaltered RASP policy enforcement code.
Knowledge: Splitting the analysis into two phases enables running each phase with a specific analysis configuration, rendering the static analysis approach tractable while maintaining sufficient precision.
Grounding: We validate the applicability of our two-phase analysis approach by using it to both dynamically enforce and statically detect a range of security policies found in related work. Our experiments suggest that our two-phase analysis can enable faster and more precise policy violation detection compared to analyzing the full instrumented application under a single analysis configuration.
Importance: Deriving a SAST component from a RASP mechanism enables equivalent semantics for the security policies across the static and dynamic contexts in which policies are verified during the software development lifecycle. Moreover, our two-phase abstract interpretation approach does not require RASP developers to reimplement the enforcement code for static analysis.
@Article{Programming Journal, Volume22p1,
author = {Angel Luis Scull Pupo and Jens Nicolay and Elisa Gonzalez Boix},
title = {Deriving Static Security Testing from Runtime Security Protection for Web Applications},
journal = {},
volume = {},
number = {},
articleno = {1},
numpages = {41},
doi = {10.22152/programming-journal.org/2022/6/1},
year = {2022},
}
Publisher's Version
Art Sci. Eng. Program., vol. 6, issue 1: "An Optimised Flow for Futures: ..."
An Optimised Flow for Futures: From Theory to Practice
Nicolas Chappe, Ludovic Henrio, Amaury Maillé, Matthieu Moy, and Hadrien Renaud
(University of Lyon, France; EnsL, France; Claude Bernard University Lyon 1, France; CNRS, France; Inria, France; LIP, France; École Polytechnique, France; Institut Polytechnique de Paris, France)
A future is an entity representing the result of an ongoing computation. A synchronisation with a "get" operation blocks the caller until the computation is over, to return the corresponding value. When a computation in charge of fulfilling a future delegates part of its processing to another task, mainstream languages return nested futures, and several "get" operations are needed to retrieve the computed value (we call such futures "control-flow futures"). Several approaches were proposed to tackle this issues: the "forward" construct, that allows the programmer to make delegation explicit and avoid nested futures, and "data-flow explicit futures" which natively collapse nested futures into plain futures.
This paper supports the claim that data-flow explicit futures form a powerful set of language primitives, on top of which other approaches can be built. We prove the equivalence, in the context of data-flow explicit futures, between the "forward" construct and classical "return" from functions. The proof relies on a branching bisimulation between a program using "forward" and its "return" counterpart. This result allows language designers to consider "forward" as an optimisation directive rather than as a language primitive.
Following the principles of the Godot system, we provide a library implementation of control-flow futures, based on data-flow explicit futures implemented in the compiler. This small library supports the claim that the implementation of classical futures based on data-flow ones is easier than the opposite. Our benchmarks show the viability of the approach from a performance point of view.
@Article{Programming Journal, Volume22p3,
author = {Nicolas Chappe and Ludovic Henrio and Amaury Maillé and Matthieu Moy and Hadrien Renaud},
title = {An Optimised Flow for Futures: From Theory to Practice},
journal = {},
volume = {},
number = {},
articleno = {3},
numpages = {41},
doi = {10.22152/programming-journal.org/2022/6/3},
year = {2022},
}
Publisher's Version
Art Sci. Eng. Program., vol. 6, issue 1: "Sham: A DSL for Fast DSLs ..."
Sham: A DSL for Fast DSLs
Rajan Walia, Chung-chieh Shan, and Sam Tobin-Hochstadt
(Indiana University, USA)
Domain-specific languages (DSLs) are touted as both easy to embed in programs and easy to optimize. Yet these goals are often in tension. Embedded or internal DSLs fit naturally with a host language, while inheriting the host's performance characteristics. External DSLs can use external optimizers and languages but sit apart from the host.
We present Sham, a toolkit designed to enable internal DSLs with high performance. Sham provides a domain-specific language (embedded in Racket) for implementing other high-performance DSLs, with transparent compilation to assembly code at runtime. Sham is well suited as both a compilation target for other embedded DSLs and for transparently replacing DSL support code with faster versions. Sham provides seamless inter-operation with its host language without requiring any additional effort from its users. Sham also provides a framework for defining language syntax which implements Sham's own language interface as well.
We validate Sham's design on a series of case studies, ranging from Krishnamurthi's classic automata DSL to a sound synthesis DSL and a probabilistic programming language. All of these are existing DSLs where we replaced the backend using Sham, resulting in major performance gains. We present an example-driven description of how Sham can smoothly enhance an existing DSL into a high-performance one.
When compared to existing approaches for implementing high-performance DSLs, Sham's design aims for both simplicity and programmer control. This makes it easier to port our techniques to other languages and frameworks, or borrow Sham's innovations "à la carte" without adopting the whole approach. Sham builds a sophisticated and powerful DSL construction toolkit atop fundamental language features including higher-order functions, data structures, and a foreign-function interface (FFI), all readily available in other languages. Furthermore, Sham's approach allows DSL developers to simply write functions, either using Sham or generating Sham, without needing to work through complex staging or partial evaluation systems.
@Article{Programming Journal, Volume22p4,
author = {Rajan Walia and Chung-chieh Shan and Sam Tobin-Hochstadt},
title = {Sham: A DSL for Fast DSLs},
journal = {},
volume = {},
number = {},
articleno = {4},
numpages = {31},
doi = {10.22152/programming-journal.org/2022/6/4},
year = {2022},
}
Publisher's Version
Art Sci. Eng. Program., vol. 6, issue 1: "A Functional Programming Language ..."
A Functional Programming Language with Versions
Yudai Tanabe, Luthfan Anshar Lubis, Tomoyuki Aotani, and Hidehiko Masuhara
(Tokyo Institute of Technology, Japan; Mamezou, Japan)
While modern software development heavily uses versioned packages, programming languages rarely support the concept of versions in their semantics, which makes software updates more bulky and unsafe. This paper proposes a programming language that intrinsically supports versions. The main goals are to design core language features to support multiple versions in one program and establish a proper notion of type safety with those features. The proposed core calculus, called Lambda VL, has versioned values, each containing different values under different versions. We show the construction of the type system as an extension of coeffect calculus by mapping versions to computational resources. The type system guarantees the existence of a valid combination of versions for a program. The calculus enables programming languages to use multiple versions of a package within a program. It will serve as a basis for designing advanced language features like module systems and semantic versioning.
@Article{Programming Journal, Volume22p5,
author = {Yudai Tanabe and Luthfan Anshar Lubis and Tomoyuki Aotani and Hidehiko Masuhara},
title = {A Functional Programming Language with Versions},
journal = {},
volume = {},
number = {},
articleno = {5},
numpages = {30},
doi = {10.22152/programming-journal.org/2022/6/5},
year = {2022},
}
Publisher's Version
Art Sci. Eng. Program., vol. 6, issue 1: "Sham: A DSL for Fast DSLs ..."
Sham: A DSL for Fast DSLs
Rajan Walia, Chung-chieh Shan, and Sam Tobin-Hochstadt
(Indiana University, USA)
Domain-specific languages (DSLs) are touted as both easy to embed in programs and easy to optimize. Yet these goals are often in tension. Embedded or internal DSLs fit naturally with a host language, while inheriting the host's performance characteristics. External DSLs can use external optimizers and languages but sit apart from the host.
We present Sham, a toolkit designed to enable internal DSLs with high performance. Sham provides a domain-specific language (embedded in Racket) for implementing other high-performance DSLs, with transparent compilation to assembly code at runtime. Sham is well suited as both a compilation target for other embedded DSLs and for transparently replacing DSL support code with faster versions. Sham provides seamless inter-operation with its host language without requiring any additional effort from its users. Sham also provides a framework for defining language syntax which implements Sham's own language interface as well.
We validate Sham's design on a series of case studies, ranging from Krishnamurthi's classic automata DSL to a sound synthesis DSL and a probabilistic programming language. All of these are existing DSLs where we replaced the backend using Sham, resulting in major performance gains. We present an example-driven description of how Sham can smoothly enhance an existing DSL into a high-performance one.
When compared to existing approaches for implementing high-performance DSLs, Sham's design aims for both simplicity and programmer control. This makes it easier to port our techniques to other languages and frameworks, or borrow Sham's innovations "à la carte" without adopting the whole approach. Sham builds a sophisticated and powerful DSL construction toolkit atop fundamental language features including higher-order functions, data structures, and a foreign-function interface (FFI), all readily available in other languages. Furthermore, Sham's approach allows DSL developers to simply write functions, either using Sham or generating Sham, without needing to work through complex staging or partial evaluation systems.
@Article{Programming Journal, Volume22p4,
author = {Rajan Walia and Chung-chieh Shan and Sam Tobin-Hochstadt},
title = {Sham: A DSL for Fast DSLs},
journal = {},
volume = {},
number = {},
articleno = {4},
numpages = {31},
doi = {10.22152/programming-journal.org/2022/6/4},
year = {2022},
}
Publisher's Version
Art Sci. Eng. Program., vol. 6, issue 1: "Sham: A DSL for Fast DSLs ..."
Sham: A DSL for Fast DSLs
Rajan Walia, Chung-chieh Shan, and Sam Tobin-Hochstadt
(Indiana University, USA)
Domain-specific languages (DSLs) are touted as both easy to embed in programs and easy to optimize. Yet these goals are often in tension. Embedded or internal DSLs fit naturally with a host language, while inheriting the host's performance characteristics. External DSLs can use external optimizers and languages but sit apart from the host.
We present Sham, a toolkit designed to enable internal DSLs with high performance. Sham provides a domain-specific language (embedded in Racket) for implementing other high-performance DSLs, with transparent compilation to assembly code at runtime. Sham is well suited as both a compilation target for other embedded DSLs and for transparently replacing DSL support code with faster versions. Sham provides seamless inter-operation with its host language without requiring any additional effort from its users. Sham also provides a framework for defining language syntax which implements Sham's own language interface as well.
We validate Sham's design on a series of case studies, ranging from Krishnamurthi's classic automata DSL to a sound synthesis DSL and a probabilistic programming language. All of these are existing DSLs where we replaced the backend using Sham, resulting in major performance gains. We present an example-driven description of how Sham can smoothly enhance an existing DSL into a high-performance one.
When compared to existing approaches for implementing high-performance DSLs, Sham's design aims for both simplicity and programmer control. This makes it easier to port our techniques to other languages and frameworks, or borrow Sham's innovations "à la carte" without adopting the whole approach. Sham builds a sophisticated and powerful DSL construction toolkit atop fundamental language features including higher-order functions, data structures, and a foreign-function interface (FFI), all readily available in other languages. Furthermore, Sham's approach allows DSL developers to simply write functions, either using Sham or generating Sham, without needing to work through complex staging or partial evaluation systems.
@Article{Programming Journal, Volume22p4,
author = {Rajan Walia and Chung-chieh Shan and Sam Tobin-Hochstadt},
title = {Sham: A DSL for Fast DSLs},
journal = {},
volume = {},
number = {},
articleno = {4},
numpages = {31},
doi = {10.22152/programming-journal.org/2022/6/4},
year = {2022},
}
Publisher's Version