bib/other.bib

   1
   2 @inproceedings{suchocki_microscheme:_2015,
   3         address = {Washington DC, USA},
   4         series = {{CS} {Techreport} 718},
   5         title = {Microscheme: {Functional} programming for the {Arduino}},
   6         booktitle = {Proceedings of the 2014 {Scheme} and {Functional} {Programming} {Workshop}},
   7         publisher = {University of Indiana},
   8         author = {Suchocki, Ryan and Kalvala, Sara},
   9         year = {2015},
  10         pages = {9},
  11         file = {Suchocki and Kalvala - 2015 - Microscheme Functional programming for the Arduin.pdf:/home/mrl/.local/share/zotero/storage/DDQZ9LP7/Suchocki and Kalvala - 2015 - Microscheme Functional programming for the Arduin.pdf:application/pdf},
  12 }
  13
  14 @mastersthesis{crooijmans_reducing_2021,
  15         address = {Nijmegen},
  16         title = {Reducing the {Power} {Consumption} of {IoT} {Devices} in {Task}-{Oriented} {Programming}},
  17         language = {en},
  18         school = {Radboud University},
  19         author = {Crooijmans, Sjoerd},
  20         month = jul,
  21         year = {2021},
  22         file = {Crooijmans - 2021 - Reducing the Power Consumption of IoT Devices in T.pdf:/home/mrl/.local/share/zotero/storage/98LY9YHH/Crooijmans - 2021 - Reducing the Power Consumption of IoT Devices in T.pdf:application/pdf},
  23 }
  24
  25 @inproceedings{plasmeijer_task-oriented_2012,
  26         address = {New York, NY, USA},
  27         series = {{PPDP} '12},
  28         title = {Task-{Oriented} {Programming} in a {Pure} {Functional} {Language}},
  29         isbn = {978-1-4503-1522-7},
  30         doi = {10.1145/2370776.2370801},
  31         abstract = {Task-Oriented Programming (TOP) is a novel programming paradigm for the construction of distributed systems where users work together on the internet. When multiple users collaborate, they need to interact with each other frequently. TOP supports the definition of tasks that react to the progress made by others. With TOP, complex multi-user interactions can be programmed in a declarative style just by defining the tasks that have to be accomplished, thus eliminating the need to worry about the implementation detail that commonly frustrates the development of applications for this domain. TOP builds on four core concepts: tasks that represent computations or work to do which have an observable value that may change over time, data sharing enabling tasks to observe each other while the work is in progress, generic type driven generation of user interaction, and special combinators for sequential and parallel task composition. The semantics of these core concepts is defined in this paper. As an example we present the iTask3 framework, which embeds TOP in the functional programming language Clean.},
  32         booktitle = {Proceedings of the 14th {Symposium} on {Principles} and {Practice} of {Declarative} {Programming}},
  33         publisher = {ACM},
  34         author = {Plasmeijer, Rinus and Lijnse, Bas and Michels, Steffen and Achten, Peter and Koopman, Pieter},
  35         year = {2012},
  36         note = {event-place: Leuven, Belgium},
  37         keywords = {clean, task-oriented programming},
  38         pages = {195--206},
  39         file = {103802.pdf:/home/mrl/.local/share/zotero/storage/ZE6A65AW/103802.pdf:application/pdf},
  40 }
  41
  42 @inproceedings{brus_clean_1987,
  43         address = {Berlin, Heidelberg},
  44         title = {Clean — {A} language for functional graph rewriting},
  45         isbn = {978-3-540-47879-9},
  46         abstract = {Clean is an experimental language for specifying functional computations in terms of graph rewriting. It is based on an extension of Term Rewriting Systems (TRS) in which the terms are replaced by graphs. Such a Graph Rewriting System (GRS) consists of a, possibly cyclic, directed graph, called the data graph and graph rewrite rules which specify how this data graph may be rewritten. Clean is designed to provide a firm base for functional programming. In particular, Clean is suitable as an intermediate language between functional languages and (parallel) target machine architectures. A sequential implementation of Clean on a conventional machine is described and its performance is compared with other systems. The results show that Clean can be efficiently implemented.},
  47         booktitle = {Functional {Programming} {Languages} and {Computer} {Architecture}},
  48         publisher = {Springer Berlin Heidelberg},
  49         author = {Brus, T. H. and van Eekelen, M. C. J. D. and van Leer, M. O. and Plasmeijer, M. J.},
  50         editor = {Kahn, Gilles},
  51         year = {1987},
  52         pages = {364--384},
  53         file = {brut87-Clean.ps.gz:/home/mrl/.local/share/zotero/storage/T2QATWIE/brut87-Clean.ps.gz:application/gzip},
  54 }
  55
  56 @misc{bolingbroke_constraint_2011,
  57         title = {Constraint {Kinds} for {GHC}},
  58         url = {http://blog.omega-prime.co.uk/2011/09/10/constraint-kinds-for-ghc/},
  59         urldate = {2021-06-09},
  60         journal = {:: (Bloggable a) ={\textgreater} a -{\textgreater} IO ()},
  61         author = {Bolingbroke, Max},
  62         month = sep,
  63         year = {2011},
  64         file = {Constraint Kinds for GHC:/home/mrl/.local/share/zotero/storage/R6RL79K7/constraint-kinds-for-ghc.html:text/html},
  65 }
  66
  67 @inproceedings{fegaras_revisiting_1996,
  68         address = {New York, NY, USA},
  69         series = {{POPL} '96},
  70         title = {Revisiting {Catamorphisms} over {Datatypes} with {Embedded} {Functions} (or, {Programs} from {Outer} {Space})},
  71         isbn = {0-89791-769-3},
  72         doi = {10.1145/237721.237792},
  73         abstract = {We revisit the work of Paterson and of Meijer \& Hutton, which describes how to construct catamorphisms for recursive datatype definitions that embed contravariant occurrences of the type being defined. Their construction requires, for each catamorphism, the definition of an anamorphism that has an inverse-like relationship to that catamorphism. We present an alternative construction, which replaces the stringent requirement that an inverse anamorphism be defined for each catamorphism with a more lenient restriction. The resulting construction has a more efficient implementation than that of Paterson, Meijer, and Hutton and the relevant restriction can be enforced by a Hindley-Milner type inference algorithm. We provide numerous examples illustrating our method.},
  74         booktitle = {Proceedings of the 23rd {ACM} {SIGPLAN}-{SIGACT} {Symposium} on {Principles} of {Programming} {Languages}},
  75         publisher = {ACM},
  76         author = {Fegaras, Leonidas and Sheard, Tim},
  77         year = {1996},
  78         note = {event-place: St. Petersburg Beach, Florida, USA},
  79         pages = {284--294},
  80         file = {Fegaras and Sheard - 1996 - Revisiting Catamorphisms over Datatypes with Embed.pdf:/home/mrl/.local/share/zotero/storage/WCSRVWGC/Fegaras and Sheard - 1996 - Revisiting Catamorphisms over Datatypes with Embed.pdf:application/pdf},
  81 }
  82
  83 @inproceedings{pfenning_higher-order_1988,
  84         address = {New York, NY, USA},
  85         series = {{PLDI} '88},
  86         title = {Higher-{Order} {Abstract} {Syntax}},
  87         isbn = {0-89791-269-1},
  88         doi = {10.1145/53990.54010},
  89         abstract = {We describe motivation, design, use, and implementation of higher-order abstract syntax as a central representation for programs, formulas, rules, and other syntactic objects in program manipulation and other formal systems where matching and substitution or unification are central operations. Higher-order abstract syntax incorporates name binding information in a uniform and language generic way. Thus it acts as a powerful link integrating diverse tools in such formal environments. We have implemented higher-order abstract syntax, a supporting matching and unification algorithm, and some clients in Common Lisp in the framework of the Ergo project at Carnegie Mellon University.},
  90         booktitle = {Proceedings of the {ACM} {SIGPLAN} 1988 {Conference} on {Programming} {Language} {Design} and {Implementation}},
  91         publisher = {ACM},
  92         author = {Pfenning, F. and Elliott, C.},
  93         year = {1988},
  94         note = {event-place: Atlanta, Georgia, USA},
  95         pages = {199--208},
  96         file = {Pfenning and Elliott - 1988 - Higher-Order Abstract Syntax.pdf:/home/mrl/.local/share/zotero/storage/2HSRWURK/Pfenning and Elliott - 1988 - Higher-Order Abstract Syntax.pdf:application/pdf},
  97 }
  98
  99 @inproceedings{chlipala_parametric_2008,
 100         address = {New York, NY, USA},
 101         series = {{ICFP} '08},
 102         title = {Parametric {Higher}-{Order} {Abstract} {Syntax} for {Mechanized} {Semantics}},
 103         isbn = {978-1-59593-919-7},
 104         doi = {10.1145/1411204.1411226},
 105         abstract = {We present parametric higher-order abstract syntax (PHOAS), a new approach to formalizing the syntax of programming languages in computer proof assistants based on type theory. Like higher-order abstract syntax (HOAS), PHOAS uses the meta language's binding constructs to represent the object language's binding constructs. Unlike HOAS, PHOAS types are definable in general-purpose type theories that support traditional functional programming, like Coq's Calculus of Inductive Constructions. We walk through how Coq can be used to develop certified, executable program transformations over several statically-typed functional programming languages formalized with PHOAS; that is, each transformation has a machine-checked proof of type preservation and semantic preservation. Our examples include CPS translation and closure conversion for simply-typed lambda calculus, CPS translation for System F, and translation from a language with ML-style pattern matching to a simpler language with no variable-arity binding constructs. By avoiding the syntactic hassle associated with first-order representation techniques, we achieve a very high degree of proof automation.},
 106         booktitle = {Proceedings of the 13th {ACM} {SIGPLAN} {International} {Conference} on {Functional} {Programming}},
 107         publisher = {ACM},
 108         author = {Chlipala, Adam},
 109         year = {2008},
 110         note = {event-place: Victoria, BC, Canada},
 111         keywords = {compiler verification, dependent types, interactive proof assistants, type-theoretic semantics},
 112         pages = {143--156},
 113         file = {Chlipala - 2008 - Parametric Higher-Order Abstract Syntax for Mechan.pdf:/home/mrl/.local/share/zotero/storage/DZ33DAMU/Chlipala - 2008 - Parametric Higher-Order Abstract Syntax for Mechan.pdf:application/pdf},
 114 }
 115
 116 @incollection{reynolds_user-defined_1978,
 117         address = {New York, NY},
 118         title = {User-{Defined} {Types} and {Procedural} {Data} {Structures} as {Complementary} {Approaches} to {Data} {Abstraction}},
 119         isbn = {978-1-4612-6315-9},
 120         abstract = {User-defined types (or modes) and procedural (or functional) data structures are complementary methods for data abstraction, each providing a capability lacked by the other. With user-defined types, all information about the representation of a particular kind of data is centralized in a type definition and hidden from the rest of the program. With procedural data structures, each part of the program which creates data can specify its own representation, independently of any representations used elsewhere for the same kind of data. However, this decentralization of the description of data is achieved at the cost of prohibiting primitive operations from accessing the representations of more than one data item. The contrast between these approaches is illustrated by a simple example.},
 121         booktitle = {Programming {Methodology}: {A} {Collection} of {Articles} by {Members} of {IFIP} {WG2}.3},
 122         publisher = {Springer New York},
 123         author = {Reynolds, John C.},
 124         editor = {Gries, David},
 125         year = {1978},
 126         doi = {10.1007/978-1-4612-6315-9_22},
 127         pages = {309--317},
 128         file = {Reynolds - 1978 - User-Defined Types and Procedural Data Structures .pdf:/home/mrl/.local/share/zotero/storage/ASXE73U2/Reynolds - 1978 - User-Defined Types and Procedural Data Structures .pdf:application/pdf},
 129 }
 130
 131 @misc{ghc_team_ghc_2021,
 132         title = {{GHC} {User}’s {Guide} {Documentation}},
 133         url = {https://downloads.haskell.org/~ghc/latest/docs/users_guide.pdf},
 134         language = {English},
 135         urldate = {2021-02-24},
 136         publisher = {Release},
 137         author = {{{{{GHC Team}}}}},
 138         year = {2021},
 139         file = {GHC Team - 2021 - GHC User’s Guide Documentation.pdf:/home/mrl/.local/share/zotero/storage/87ZT5VXL/GHC Team - 2021 - GHC User’s Guide Documentation.pdf:application/pdf},
 140 }
 141
 142 @misc{ghc_team_datadynamic_2021,
 143         title = {Data.{Dynamic}},
 144         url = {https://hackage.haskell.org/package/base-4.14.1.0/docs/Data-Dynamic.html},
 145         language = {English},
 146         urldate = {2021-02-24},
 147         publisher = {Release},
 148         author = {{{{{GHC Team}}}}},
 149         year = {2021},
 150 }
 151
 152 @inproceedings{jeuring_polytypic_1996,
 153         address = {Berlin, Heidelberg},
 154         title = {Polytypic programming},
 155         isbn = {978-3-540-70639-7},
 156         abstract = {Many functions have to be written over and over again for different datatypes, either because datatypes change during the development of programs, or because functions with similar functionality are needed on different datatypes. Examples of such functions are pretty printers, debuggers, equality functions, unifiers, pattern matchers, rewriting functions, etc. Such functions are called polytypic functions. A polytypic function is a function that is defined by induction on the structure of user-defined datatypes. This paper introduces polytypic functions, and shows how to construct and reason about polytypic functions. A larger example is studied in detail: polytypic functions for term rewriting and for determining whether a collection of rewrite rules is normalising.},
 157         booktitle = {Advanced {Functional} {Programming}},
 158         publisher = {Springer Berlin Heidelberg},
 159         author = {Jeuring, Johan and Jansson, Patrik},
 160         editor = {Launchbury, John and Meijer, Erik and Sheard, Tim},
 161         year = {1996},
 162         pages = {68--114},
 163         file = {Jeuring and Jansson - 1996 - Polytypic programming.pdf:/home/mrl/.local/share/zotero/storage/SLC4G2IT/Jeuring and Jansson - 1996 - Polytypic programming.pdf:application/pdf},
 164 }
 165
 166 @book{peyton_jones_haskell_2003,
 167         address = {Cambridge},
 168         title = {Haskell 98 language and libraries: the revised report},
 169         isbn = {0-521 826144},
 170         publisher = {Cambridge University Press},
 171         editor = {Peyton Jones, Simon},
 172         year = {2003},
 173         file = {Peyton Jones - 2003 - Haskell 98 language and libraries the revised rep.pdf:/home/mrl/.local/share/zotero/storage/UXEJT89I/Peyton Jones - 2003 - Haskell 98 language and libraries the revised rep.pdf:application/pdf},
 174 }
 175
 176 @inproceedings{laufer_combining_1994,
 177         title = {Combining type classes and existential types},
 178         booktitle = {Proceedings of the {Latin} {American} {Informatic} {Conference} ({PANEL})},
 179         publisher = {ITESM-CEM},
 180         author = {Läufer, Konstantin},
 181         year = {1994},
 182         note = {event-place: Monterrey, Mexico},
 183         file = {Läufer - COMBINING TYPE CLASSES AND EXISTENTIAL TYPES.pdf:/home/mrl/.local/share/zotero/storage/KR4P9EHS/Läufer - COMBINING TYPE CLASSES AND EXISTENTIAL TYPES.pdf:application/pdf},
 184 }
 185
 186 @techreport{hughes_restricted_1999,
 187         address = {Paris},
 188         title = {Restricted data types in {Haskell}},
 189         number = {UU-CS-1999-28},
 190         institution = {Department of Information and Computing Sciences, Utrecht University},
 191         author = {Hughes, John},
 192         year = {1999},
 193         pages = {16},
 194         file = {Hughes - 1999 - Restricted data types in Haskell.pdf:/home/mrl/.local/share/zotero/storage/7ZE2MYWE/Hughes - 1999 - Restricted data types in Haskell.pdf:application/pdf},
 195 }
 196
 197 @article{najd_trees_2017,
 198         title = {Trees that {Grow}},
 199         volume = {23},
 200         abstract = {We study the notion of extensibility in functional data types, as a new approach to the problem of decorating abstract syntax trees with additional information. We observed the need for such extensibility while redesigning the data types representing Haskell abstract syntax inside Glasgow Haskell Compiler (GHC). Specifically, we describe a programming idiom that exploits type-level functions to allow a particular form of extensibility. The approach scales to support existentials and generalised algebraic data types, and we can use pattern synonyms to make it convenient in practice.},
 201         number = {1},
 202         journal = {Journal of Universal Computer Science},
 203         author = {Najd, Shayan and Peyton Jones, Simon},
 204         month = jan,
 205         year = {2017},
 206         pages = {42--62},
 207         file = {Najd and Jones - 2017 - Trees that Grow.pdf:/home/mrl/.local/share/zotero/storage/HYQFTWZP/Najd and Jones - 2017 - Trees that Grow.pdf:application/pdf},
 208 }
 209
 210 @inproceedings{loh_open_2006,
 211         address = {New York, NY, USA},
 212         series = {{PPDP} '06},
 213         title = {Open {Data} {Types} and {Open} {Functions}},
 214         isbn = {1-59593-388-3},
 215         doi = {10.1145/1140335.1140352},
 216         abstract = {The problem of supporting the modular extensibility of both data and functions in one programming language at the same time is known as the expression problem. Functional languages traditionally make it easy to add new functions, but extending data (adding new data constructors) requires modifying existing code. We present a semantically and syntactically lightweight variant of open data types and open functions as a solution to the expression problem in the Haskell language. Constructors of open data types and equations of open functions may appear scattered throughout a program with several modules. The intended semantics is as follows: the program should behave as if the data types and functions were closed, defined in one place. The order of function equations is determined by best-fit pattern matching, where a specific pattern takes precedence over an unspecific one. We show that our solution is applicable to the expression problem, generic programming, and exceptions. We sketch two implementations: a direct implementation of the semantics, and a scheme based on mutually recursive modules that permits separate compilation},
 217         booktitle = {Proceedings of the 8th {ACM} {SIGPLAN} {International} {Conference} on {Principles} and {Practice} of {Declarative} {Programming}},
 218         publisher = {ACM},
 219         author = {Löh, Andres and Hinze, Ralf},
 220         year = {2006},
 221         note = {event-place: Venice, Italy},
 222         keywords = {functional programming, Haskell, expression problem, extensible data types, extensible exceptions, extensible functions, generic programming, mutually recursive modules},
 223         pages = {133--144},
 224         file = {OpenDatatypes.pdf:/home/mrl/.local/share/zotero/storage/NEP9GZ9N/OpenDatatypes.pdf:application/pdf},
 225 }
 226
 227 @inproceedings{hutton_fold_1998,
 228         address = {New York, NY, USA},
 229         series = {{ICFP} '98},
 230         title = {Fold and {Unfold} for {Program} {Semantics}},
 231         isbn = {1-58113-024-4},
 232         doi = {10.1145/289423.289457},
 233         abstract = {In this paper we explain how recursion operators can be used to structure and reason about program semantics within a functional language. In particular, we show how the recursion operator fold can be used to structure denotational semantics, how the dual recursion operator unfold can be used to structure operational semantics, and how algebraic properties of these operators can be used to reason about program semantics. The techniques are explained with the aid of two main examples, the first concerning arithmetic expressions, and the second concerning Milner's concurrent language CCS. The aim of the paper is to give functional programmers new insights into recursion operators, program semantics, and the relationships between them.},
 234         booktitle = {Proceedings of the {Third} {ACM} {SIGPLAN} {International} {Conference} on {Functional} {Programming}},
 235         publisher = {ACM},
 236         author = {Hutton, Graham},
 237         year = {1998},
 238         note = {event-place: Baltimore, Maryland, USA},
 239         pages = {280--288},
 240         file = {Hutton - 1998 - Fold and unfold for program semantics.pdf:/home/mrl/.local/share/zotero/storage/YEB9K2TP/Hutton - 1998 - Fold and unfold for program semantics.pdf:application/pdf},
 241 }
 242
 243 @article{abadi_dynamic_1991,
 244         title = {Dynamic {Typing} in a {Statically} {Typed} {Language}},
 245         volume = {13},
 246         issn = {0164-0925},
 247         doi = {10.1145/103135.103138},
 248         abstract = {Statically typed programming languages allow earlier error checking, better enforcement of diciplined programming styles, and the generation of more efficient object code than languages where all type consistency checks are performed at run time. However, even in statically typed languages, there is often the need to deal with datawhose type cannot be determined at compile time. To handle such situations safely, we propose to add a type Dynamic whose values are pairs of a value v and a type tag T where v has the type denoted by T. Instances of Dynamic are built with an explicit tagging construct and inspected with a type safe typecase construct.This paper explores the syntax, operational semantics, and denotational semantics of a simple language that includes the type Dynamic. We give examples of how dynamically typed values can be used in programming. Then we discuss an operational semantics for our language and obtain a soundness theorem. We present two formulations of the denotational semantics of this language and relate them to the operational semantics. Finally, we consider the implications of polymorphism and some implementation issues.},
 249         number = {2},
 250         journal = {ACM Trans. Program. Lang. Syst.},
 251         author = {Abadi, Martín and Cardelli, Luca and Pierce, Benjamin and Plotkin, Gordon},
 252         month = apr,
 253         year = {1991},
 254         note = {Place: New York, NY, USA
 255 Publisher: Association for Computing Machinery},
 256         keywords = {theory},
 257         pages = {237--268},
 258         file = {Abadi et al. - 1991 - Dynamic typing in a statically typed language.pdf:/home/mrl/.local/share/zotero/storage/CJSBG6X7/Abadi et al. - 1991 - Dynamic typing in a statically typed language.pdf:application/pdf},
 259 }
 260
 261 @inproceedings{svenningsson_combining_2013,
 262         address = {Berlin, Heidelberg},
 263         title = {Combining {Deep} and {Shallow} {Embedding} for {EDSL}},
 264         isbn = {978-3-642-40447-4},
 265         doi = {10.1007/978-3-642-40447-4_2},
 266         abstract = {When compiling embedded languages it is natural to use an abstract syntax tree to represent programs. This is known as a deep embedding and it is a rather cumbersome technique compared to other forms of embedding, typically leading to more code and being harder to extend. In shallow embeddings, language constructs are mapped directly to their semantics which yields more flexible and succinct implementations. But shallow embeddings are not well-suited for compiling embedded languages. We present a technique to combine deep and shallow embedding in the context of compiling embedded languages in order to provide the benefits of both techniques. In particular it helps keeping the deep embedding small and it makes extending the embedded language much easier. Our technique also has some unexpected but welcome knock-on effects. It provides fusion of functions to remove intermediate results for free without any additional effort. It also helps to give the embedded language a more natural programming interface.},
 267         booktitle = {Trends in {Functional} {Programming}},
 268         publisher = {Springer Berlin Heidelberg},
 269         author = {Svenningsson, Josef and Axelsson, Emil},
 270         editor = {Loidl, Hans-Wolfgang and Peña, Ricardo},
 271         year = {2013},
 272         pages = {21--36},
 273         file = {svenningsson2013combining.pdf:/home/mrl/.local/share/zotero/storage/NFBGZCZT/svenningsson2013combining.pdf:application/pdf},
 274 }
 275
 276 @inproceedings{yorgey_giving_2012,
 277         address = {New York, NY, USA},
 278         series = {{TLDI} '12},
 279         title = {Giving {Haskell} a {Promotion}},
 280         isbn = {978-1-4503-1120-5},
 281         doi = {10.1145/2103786.2103795},
 282         abstract = {Static type systems strive to be richly expressive while still being simple enough for programmers to use. We describe an experiment that enriches Haskell's kind system with two features promoted from its type system: data types and polymorphism. The new system has a very good power-to-weight ratio: it offers a significant improvement in expressiveness, but, by re-using concepts that programmers are already familiar with, the system is easy to understand and implement.},
 283         booktitle = {Proceedings of the 8th {ACM} {SIGPLAN} {Workshop} on {Types} in {Language} {Design} and {Implementation}},
 284         publisher = {ACM},
 285         author = {Yorgey, Brent A. and Weirich, Stephanie and Cretin, Julien and Peyton Jones, Simon and Vytiniotis, Dimitrios and Magalhães, José Pedro},
 286         year = {2012},
 287         note = {event-place: Philadelphia, Pennsylvania, USA},
 288         keywords = {haskell, kinds, polymorphism, promotion},
 289         pages = {53--66},
 290         file = {Yorgey et al. - 2012 - Giving Haskell a Promotion.pdf:/home/mrl/.local/share/zotero/storage/7GTDGQ3I/Yorgey et al. - 2012 - Giving Haskell a Promotion.pdf:application/pdf},
 291 }
 292
 293 @inproceedings{atkey_unembedding_2009,
 294         address = {New York, NY, USA},
 295         series = {Haskell '09},
 296         title = {Unembedding {Domain}-{Specific} {Languages}},
 297         isbn = {978-1-60558-508-6},
 298         doi = {10.1145/1596638.1596644},
 299         abstract = {Higher-order abstract syntax provides a convenient way of embedding domain-specific languages, but is awkward to analyse and manipulate directly. We explore the boundaries of higher-order abstract syntax. Our key tool is the unembedding of embedded terms as de Bruijn terms, enabling intensional analysis. As part of our solution we present techniques for separating the definition of an embedded program from its interpretation, giving modular extensions of the embedded language, and different ways to encode the types of the embedded language.},
 300         booktitle = {Proceedings of the 2nd {ACM} {SIGPLAN} {Symposium} on {Haskell}},
 301         publisher = {ACM},
 302         author = {Atkey, Robert and Lindley, Sam and Yallop, Jeremy},
 303         year = {2009},
 304         note = {event-place: Edinburgh, Scotland},
 305         keywords = {domain-specific languages, higher-order abstract syntax, type classes, unembedding},
 306         pages = {37--48},
 307         file = {Atkey et al. - 2009 - Unembedding Domain-Specific Languages.pdf:/home/mrl/.local/share/zotero/storage/GVFRIDUG/Atkey et al. - 2009 - Unembedding Domain-Specific Languages.pdf:application/pdf},
 308 }
 309
 310 @inproceedings{krishnamurthi_synthesizing_1998,
 311         address = {Berlin, Heidelberg},
 312         title = {Synthesizing object-oriented and functional design to promote re-use},
 313         isbn = {978-3-540-69064-1},
 314         abstract = {Many problems require recursively specified types of data and a collection of tools that operate on those data. Over time, these problems evolve so that the programmer must extend the toolkit or extend the types and adjust the existing tools accordingly. Ideally, this should be done without modifying existing code. Unfortunately, the prevailing program design strategies do not support both forms of extensibility: functional programming accommodates the addition of tools, while object-oriented programming supports either adding new tools or extending the data set, but not both. In this paper, we present a composite design pattern that synthesizes the best of both approaches and in the process resolves the tension between the two design strategies. We also show how this protocol suggests a new set of linguistic facilities for languages that support class systems.},
 315         booktitle = {{ECOOP}'98 — {Object}-{Oriented} {Programming}},
 316         publisher = {Springer Berlin Heidelberg},
 317         author = {Krishnamurthi, Shriram and Felleisen, Matthias and Friedman, Daniel P.},
 318         editor = {Jul, Eric},
 319         year = {1998},
 320         note = {event-place: Brussels, Belgium},
 321         pages = {91--113},
 322         file = {Krishnamurthi et al. - 1998 - Synthesizing object-oriented and functional design.pdf:/home/mrl/.local/share/zotero/storage/AMMULPPT/Krishnamurthi et al. - 1998 - Synthesizing object-oriented and functional design.pdf:application/pdf},
 323 }
 324
 325 @incollection{gibbons_functional_2015,
 326         address = {Cham},
 327         title = {Functional {Programming} for {Domain}-{Specific} {Languages}},
 328         isbn = {978-3-319-15940-9},
 329         abstract = {Domain-specific languages are a popular application area for functional programming; and conversely, functional programming is a popular implementation vehicle for domain-specific languages—at least, for embedded ones. Why is this? The appeal of embedded domain-specific languages is greatly enhanced by the presence of convenient lightweight tools for defining, implementing, and optimising new languages; such tools represent one of functional programming's strengths. In these lectures we discuss functional programming techniques for embedded domain-specific languages; we focus especially on algebraic datatypes and higher-order functions, and their influence on deep and shallow embeddings.},
 330         booktitle = {Central {European} {Functional} {Programming} {School}: 5th {Summer} {School}, {CEFP} 2013, {Cluj}-{Napoca}, {Romania}, {July} 8-20, 2013, {Revised} {Selected} {Papers}},
 331         publisher = {Springer International Publishing},
 332         author = {Gibbons, Jeremy},
 333         editor = {Zsók, Viktória and Horváth, Zoltán and Csató, Lehel},
 334         year = {2015},
 335         doi = {10.1007/978-3-319-15940-9_1},
 336         pages = {1--28},
 337         file = {Gibbons - 2015 - Functional Programming for Domain-Specific Languag.pdf:/home/mrl/.local/share/zotero/storage/ARUBLFU6/Gibbons - 2015 - Functional Programming for Domain-Specific Languag.pdf:application/pdf},
 338 }
 339
 340 @mastersthesis{van_der_veen_mutable_2020,
 341         address = {Nijmegen},
 342         title = {Mutable {Collection} {Types} in {Shallow} {Embedded} {DSLs}},
 343         language = {en},
 344         school = {Radboud University},
 345         author = {van der Veen, Erin},
 346         month = jun,
 347         year = {2020},
 348         file = {thesis_final.pdf:/home/mrl/.local/share/zotero/storage/Y9QWGGB9/thesis_final.pdf:application/pdf},
 349 }
 350
 351 @phdthesis{alimarine_generic_2005,
 352         address = {Nijmegen},
 353         type = {PhD Thesis},
 354         title = {Generic {Functional} {Programming}},
 355         language = {en},
 356         school = {Radboud University},
 357         author = {Alimarine, Artem},
 358         year = {2005},
 359         file = {Alimarine - Generic Functional Programming.pdf:/home/mrl/.local/share/zotero/storage/PDTS3SGX/Alimarine - Generic Functional Programming.pdf:application/pdf},
 360 }
 361
 362 @phdthesis{de_boer_secure_2020,
 363         address = {Nijmegen},
 364         type = {Bachelor's {Thesis}},
 365         title = {Secure {Communication} {Channels} for the {mTask} {System}.},
 366         language = {en},
 367         school = {Radboud University},
 368         author = {de Boer, Michel},
 369         month = jun,
 370         year = {2020},
 371         file = {Boer, de - 2020 - Secure Communication Channels for the mTask System.pdf:/home/mrl/.local/share/zotero/storage/C46E3FBF/Boer, de - 2020 - Secure Communication Channels for the mTask System.pdf:application/pdf},
 372 }
 373
 374 @phdthesis{vos_draadloze_2020,
 375         address = {Den Helder},
 376         type = {Bachelor's {Thesis}},
 377         title = {Draadloze prestaties van de {Wemos} {D1} {Mini} {V3}},
 378         language = {nl},
 379         school = {Netherlandse Defensie Academie},
 380         author = {Vos, W.F.T.},
 381         year = {2020},
 382         file = {Draadloze prestaties van de Wemos D1 Mini V3.pdf:/home/mrl/.local/share/zotero/storage/PMN5F2E7/Draadloze prestaties van de Wemos D1 Mini V3.pdf:application/pdf},
 383 }
 384
 385 @inproceedings{barendregt_towards_1987,
 386         title = {Towards an intermediate language for graph rewriting},
 387         volume = {1},
 388         booktitle = {{PARLE}, {Parallel} {Architectures} and {Languages} {Europe}},
 389         publisher = {Springer Verlag},
 390         author = {Barendregt, HP and van Eekelen, MCJD and Glauert, JRW and Kennaway, JR and Plasmeijer, MJ and Sleep, MR},
 391         year = {1987},
 392         pages = {159--174},
 393         file = {barh87-Lean.ps.gz:/home/mrl/.local/share/zotero/storage/63FBHND7/barh87-Lean.ps.gz:application/gzip;barh87-Lean.ps.gz:/home/mrl/.local/share/zotero/storage/6H2UKQGZ/barh87-Lean.ps.gz:application/gzip},
 394 }
 395
 396 @misc{johnson-davies_lisp_2020,
 397         title = {Lisp for microcontrollers},
 398         url = {https://ulisp.com},
 399         urldate = {2020-02-14},
 400         journal = {Lisp for microcontrollers},
 401         author = {Johnson-Davies, David},
 402         year = {2020},
 403 }
 404
 405 @incollection{wang_maintaining_2018,
 406         address = {Cham},
 407         title = {Maintaining {Separation} of {Concerns} {Through} {Task} {Oriented} {Software} {Development}},
 408         volume = {10788},
 409         isbn = {978-3-319-89718-9 978-3-319-89719-6},
 410         abstract = {Task Oriented Programming is a programming paradigm that enhances ‘classic’ functional programming with means to express the coordination of work among people and computer systems, the distribution and control of data sources, and the human-machine interfaces. To make the creation process of such applications feasible, it is important to have separation of concerns. In this paper we demonstrate how this is achieved within the Task Oriented Software Development process and illustrate the approach by means of a case study.},
 411         language = {en},
 412         urldate = {2019-01-14},
 413         booktitle = {Trends in {Functional} {Programming}},
 414         publisher = {Springer International Publishing},
 415         author = {Stutterheim, Jurriën and Achten, Peter and Plasmeijer, Rinus},
 416         editor = {Wang, Meng and Owens, Scott},
 417         year = {2018},
 418         doi = {10.1007/978-3-319-89719-6},
 419         pages = {19--38},
 420         file = {Stutterheim et al. - 2018 - Maintaining Separation of Concerns Through Task Or.pdf:/home/mrl/.local/share/zotero/storage/4GXJEM2U/Stutterheim et al. - 2018 - Maintaining Separation of Concerns Through Task Or.pdf:application/pdf},
 421 }
 422
 423 @phdthesis{serrano_type_2018,
 424         type = {{PhD} {Thesis}},
 425         title = {Type {Error} {Customization} for {Embedded} {Domain}-{Specific} {Languages}},
 426         school = {Utrecht University},
 427         author = {Serrano, Alejandro},
 428         year = {2018},
 429 }
 430
 431 @inproceedings{steiner_firmata:_2009,
 432         title = {Firmata: {Towards} {Making} {Microcontrollers} {Act} {Like} {Extensions} of the {Computer}.},
 433         booktitle = {{NIME}},
 434         author = {Steiner, Hans-Christoph},
 435         year = {2009},
 436         pages = {125--130},
 437         file = {Steiner - Firmata Towards Making Microcontrollers Act Like .pdf:/home/mrl/.local/share/zotero/storage/YXMY5XHP/Steiner - Firmata Towards Making Microcontrollers Act Like .pdf:application/pdf},
 438 }
 439
 440 @article{sugihara_programming_2008,
 441         title = {Programming models for sensor networks: {A} survey},
 442         volume = {4},
 443         issn = {15504859},
 444         shorttitle = {Programming models for sensor networks},
 445         url = {http://portal.acm.org/citation.cfm?doid=1340771.1340774},
 446         doi = {10.1145/1340771.1340774},
 447         language = {en},
 448         number = {2},
 449         urldate = {2019-11-01},
 450         journal = {ACM Transactions on Sensor Networks},
 451         author = {Sugihara, Ryo and Gupta, Rajesh K.},
 452         month = mar,
 453         year = {2008},
 454         pages = {1--29},
 455         file = {Sugihara and Gupta - 2008 - Programming models for sensor networks A survey.pdf:/home/mrl/.local/share/zotero/storage/PQWX7QFD/Sugihara and Gupta - 2008 - Programming models for sensor networks A survey.pdf:application/pdf;Sugihara and Gupta - 2008 - Programming models for sensor networks A survey.pdf:/home/mrl/.local/share/zotero/storage/DP7V3EV8/Sugihara and Gupta - 2008 - Programming models for sensor networks A survey.pdf:application/pdf},
 456 }
 457
 458 @article{dube_bit:_2000,
 459         title = {{BIT}: {A} very compact {Scheme} system for embedded applications},
 460         journal = {Proceedings of the Fourth Workshop on Scheme and Functional Programming},
 461         author = {Dubé, Danny},
 462         year = {2000},
 463         file = {dube.ps:/home/mrl/.local/share/zotero/storage/RNG6V7HT/dube.ps:application/postscript},
 464 }
 465
 466 @inproceedings{feeley_picbit:_2003,
 467         title = {{PICBIT}: {A} {Scheme} system for the {PIC} microcontroller},
 468         booktitle = {Proceedings of the {Fourth} {Workshop} on {Scheme} and {Functional} {Programming}},
 469         publisher = {Citeseer},
 470         author = {Feeley, Marc and Dubé, Danny},
 471         year = {2003},
 472         pages = {7--15},
 473         file = {Feeley and Dubé - 2003 - PICBIT A Scheme system for the PIC microcontrolle.pdf:/home/mrl/.local/share/zotero/storage/EAEJSKNR/Feeley and Dubé - 2003 - PICBIT A Scheme system for the PIC microcontrolle.pdf:application/pdf},
 474 }
 475
 476 @inproceedings{st-amour_picobit:_2009,
 477         title = {{PICOBIT}: a compact scheme system for microcontrollers},
 478         booktitle = {International {Symposium} on {Implementation} and {Application} of {Functional} {Languages}},
 479         publisher = {Springer},
 480         author = {St-Amour, Vincent and Feeley, Marc},
 481         year = {2009},
 482         pages = {1--17},
 483         file = {St-Amour and Feeley - 2009 - PICOBIT a compact scheme system for microcontroll.pdf:/home/mrl/.local/share/zotero/storage/KXRIEPJZ/St-Amour and Feeley - 2009 - PICOBIT a compact scheme system for microcontroll.pdf:application/pdf},
 484 }
 485
 486 @article{barendsen_uniqueness_1996,
 487         title = {Uniqueness typing for functional languages with graph rewriting semantics},
 488         volume = {6},
 489         number = {6},
 490         journal = {Mathematical structures in computer science},
 491         author = {Barendsen, Erik and Smetsers, Sjaak},
 492         year = {1996},
 493         pages = {579--612},
 494         file = {Barendsen and Smetsers - 1996 - Uniqueness typing for functional languages with gr.pdf:/home/mrl/.local/share/zotero/storage/BPRC6KJK/Barendsen and Smetsers - 1996 - Uniqueness typing for functional languages with gr.pdf:application/pdf},
 495 }
 496
 497 @incollection{bolderheij_mission-driven_2018,
 498         title = {A {Mission}-{Driven} {C2} {Framework} for {Enabling} {Heterogeneous} {Collaboration}},
 499         booktitle = {{NL} {ARMS} {Netherlands} {Annual} {Review} of {Military} {Studies} 2018},
 500         publisher = {Springer},
 501         author = {Bolderheij, F and Jansen, JM and Kool, AA and Stutterheim, J},
 502         year = {2018},
 503         pages = {107--130},
 504         file = {Bolderheij et al. - 2018 - A Mission-Driven C2 Framework for Enabling Heterog.pdf:/home/mrl/.local/share/zotero/storage/CHDHW2TU/Bolderheij et al. - 2018 - A Mission-Driven C2 Framework for Enabling Heterog.pdf:application/pdf},
 505 }
 506
 507 @inproceedings{lijnse_itasks_2009,
 508         title = {{iTasks} 2: {iTasks} for {End}-users},
 509         booktitle = {International {Symposium} on {Implementation} and {Application} of {Functional} {Languages}},
 510         publisher = {Springer},
 511         author = {Lijnse, Bas and Plasmeijer, Rinus},
 512         year = {2009},
 513         pages = {36--54},
 514         file = {Lijnse and Plasmeijer - 2009 - iTasks 2 iTasks for End-users.pdf:/home/mrl/.local/share/zotero/storage/KACEWKXY/Lijnse and Plasmeijer - 2009 - iTasks 2 iTasks for End-users.pdf:application/pdf},
 515 }
 516
 517 @inproceedings{plasmeijer_conference_2006,
 518         title = {A conference management system based on the {iData} toolkit},
 519         booktitle = {Symposium on {Implementation} and {Application} of {Functional} {Languages}},
 520         publisher = {Springer},
 521         author = {Plasmeijer, Rinus and Achten, Peter},
 522         year = {2006},
 523         pages = {108--125},
 524         file = {Plasmeijer and Achten - 2006 - A conference management system based on the iData .pdf:/home/mrl/.local/share/zotero/storage/D4ZXJJ22/Plasmeijer and Achten - 2006 - A conference management system based on the iData .pdf:application/pdf},
 525 }
 526
 527 @inproceedings{jansen_towards_2010,
 528         address = {Seattle, USA},
 529         title = {Towards dynamic workflows for crisis management},
 530         isbn = {978-972-49-2247-8},
 531         booktitle = {7th {Proceedings} of the {International} {Conference} on {Information} {Systems} for {Crisis} {Response} and {Management}, {Seattle}, {WA}, {USA}, {May}, 2010.},
 532         publisher = {Information Systems for Crisis Response and Management, ISCRAM},
 533         author = {Jansen, Jan Martin and Lijnse, Bas and Plasmeijer, Rinus},
 534         editor = {French, Simon and Tomaszewski, n and Zobel, Christopher},
 535         year = {2010},
 536         file = {Jansen et al. - 2010 - Towards dynamic workflows for crisis management.pdf:/home/mrl/.local/share/zotero/storage/AQSZJ3TA/Jansen et al. - 2010 - Towards dynamic workflows for crisis management.pdf:application/pdf},
 537 }
 538
 539 @inproceedings{van_der_heijden_managing_2011,
 540         title = {Managing {COPD} exacerbations with telemedicine},
 541         booktitle = {Conference on {Artificial} {Intelligence} in {Medicine} in {Europe}},
 542         publisher = {Springer},
 543         author = {van der Heijden, Maarten and Lijnse, Bas and Lucas, Peter JF and Heijdra, Yvonne F and Schermer, Tjard RJ},
 544         year = {2011},
 545         pages = {169--178},
 546         file = {Van Der Heijden et al. - 2011 - Managing COPD exacerbations with telemedicine.pdf:/home/mrl/.local/share/zotero/storage/AS3MPSEF/Van Der Heijden et al. - 2011 - Managing COPD exacerbations with telemedicine.pdf:application/pdf},
 547 }
 548
 549 @inproceedings{lijnse_incidone:_2012,
 550         title = {Incidone: {A} task-oriented incident coordination tool},
 551         volume = {12},
 552         booktitle = {Proceedings of the 9th {International} {Conference} on {Information} {Systems} for {Crisis} {Response} and {Management}, {ISCRAM}},
 553         author = {Lijnse, Bas and Jansen, Jan Martin and Plasmeijer, Rinus and {others}},
 554         year = {2012},
 555         file = {Lijnse et al. - 2012 - Incidone A task-oriented incident coordination to.pdf:/home/mrl/.local/share/zotero/storage/EYS9U69B/Lijnse et al. - 2012 - Incidone A task-oriented incident coordination to.pdf:application/pdf},
 556 }
 557
 558 @inproceedings{santanna_safe_2013,
 559         title = {Safe system-level concurrency on resource-constrained nodes},
 560         booktitle = {Proceedings of the 11th {ACM} {Conference} on {Embedded} {Networked} {Sensor} {Systems}},
 561         publisher = {ACM},
 562         author = {Sant'Anna, Francisco and Rodriguez, Noemi and Ierusalimschy, Roberto and Landsiedel, Olaf and Tsigas, Philippas},
 563         year = {2013},
 564         pages = {11},
 565         file = {Sant'Anna et al. - 2013 - Safe system-level concurrency on resource-constrai.pdf:/home/mrl/.local/share/zotero/storage/4865FAU3/Sant'Anna et al. - 2013 - Safe system-level concurrency on resource-constrai.pdf:application/pdf},
 566 }
 567
 568 @mastersthesis{bohm_asynchronous_2019,
 569         address = {Nijmegen},
 570         title = {Asynchronous {Actions} in a {Synchronous} {World}},
 571         abstract = {This thesis introduces a system for asynchronous communication in the iTasks framework. The
 572 framework is written in Clean, a pure, lazy, functional language. Tasks need to be able to access
 573 data in the system and retrieve data from all kinds of data sources. The share system allows
 574 tasks to read arbitrary data sources and provides a simple interface that allows composition of
 575 different data sources. This system allows tasks to share and store data in an efficient, re-usable
 576 way.
 577 A disadvantage of the share system is that it does not allow asynchronous evaluation. When
 578 one task is using a share, other tasks have to wait for the full evaluation of this share before they
 579 can be evaluated. This has the effect that users in the iTasks framework must wait on other
 580 users. This results in poor user experience.
 581 We implement a share system which, by way of share rewriting, allows asynchronous evalua-
 582 tion. The system can be used to communicate with arbitrary services on the internet, as well as
 583 to communicate between different iTasks servers in a distributed context.
 584 We show how asynchronous shares are implemented and what the limitations are. We also
 585 show multiple practical examples of using asynchronous shares. The new system can be effectively
 586 used to consume services on the internet. It fits nicely into existing iTasks programs and requires
 587 few changes in existing programs.},
 588         language = {en},
 589         school = {Radboud University},
 590         author = {Böhm, Haye},
 591         month = jan,
 592         year = {2019},
 593         file = {Bohm - Asynchronous Actions in a Synchronous World.pdf:/home/mrl/.local/share/zotero/storage/D3IYPAM5/Bohm - Asynchronous Actions in a Synchronous World.pdf:application/pdf},
 594 }
 595
 596 @inproceedings{hentschel_supersensors:_2016,
 597         address = {Vienna, Austria},
 598         title = {Supersensors: {Raspberry} {Pi} {Devices} for {Smart} {Campus} {Infrastructure}},
 599         isbn = {978-1-5090-4052-0},
 600         shorttitle = {Supersensors},
 601         doi = {10.1109/FiCloud.2016.16},
 602         abstract = {We describe an approach for developing a campuswide sensor network using commodity single board computers. We sketch various use cases for environmental sensor data, for different university stakeholders. Our key premise is that supersensors—sensors with signiﬁcant compute capability—enable more ﬂexible data collection, processing and reaction. In this paper, we describe the initial prototype deployment of our supersensor system in a single department at the University of Glasgow.},
 603         language = {en},
 604         urldate = {2019-09-04},
 605         booktitle = {2016 {IEEE} 4th {International} {Conference} on {Future} {Internet} of {Things} and {Cloud} ({FiCloud})},
 606         publisher = {IEEE},
 607         author = {Hentschel, Kristian and Jacob, Dejice and Singer, Jeremy and Chalmers, Matthew},
 608         month = aug,
 609         year = {2016},
 610         pages = {58--62},
 611         file = {Hentschel et al. - 2016 - Supersensors Raspberry Pi Devices for Smart Campu.pdf:/home/mrl/.local/share/zotero/storage/ATK53FN2/Hentschel et al. - 2016 - Supersensors Raspberry Pi Devices for Smart Campu.pdf:application/pdf},
 612 }
 613
 614 @inproceedings{feijs_multi-tasking_2013,
 615         address = {Wuxi, China},
 616         title = {Multi-tasking and {Arduino} : why and how?},
 617         isbn = {978-90-386-3462-3},
 618         abstract = {In this article I argue that it is important to develop experiential prototypes which have multi-tasking capabilities. At the same time I show that for embedded prototype software based on the popular Arduino platform this is not too difficult. The approach is explained and illustrated using technical examples – practical and hands-on, down to the code level. At the same time a few helpful notations for designing and documenting the software are introduced and illustrated by the same examples. Finally a few case studies of the technical approach are listed.},
 619         language = {English},
 620         booktitle = {8th {International} {Conference} on {Design} and {Semantics} of {Form} and {Movement} ({DeSForM} 2013)},
 621         author = {Feijs, Loe},
 622         editor = {Chen, L. L. and Djajadiningrat, T. and Feijs, L. M. G. and Fraser, S. and Hu, J. and Kyffin, S. and Steffen, D.},
 623         year = {2013},
 624         pages = {119--127},
 625         file = {Feijs - 2013 - Multi-tasking and Arduino why and how.pdf:/home/mrl/.local/share/zotero/storage/8A3Q8LHA/Feijs - 2013 - Multi-tasking and Arduino why and how.pdf:application/pdf},
 626 }
 627
 628 @article{haenisch_case_2016,
 629         title = {A case study on using functional programming for internet of things applications},
 630         volume = {3},
 631         number = {1},
 632         journal = {Athens Journal of Technology \& Engineering},
 633         author = {Haenisch, Till},
 634         year = {2016},
 635         file = {Haenisch - 2016 - A case study on using functional programming for i.pdf:/home/mrl/.local/share/zotero/storage/EID5EW5N/Haenisch - 2016 - A case study on using functional programming for i.pdf:application/pdf},
 636 }
 637
 638 @misc{achten_clean_2007,
 639         title = {Clean for {Haskell98} {Programmers}},
 640         url = {https://www.mbsd.cs.ru.nl/publications/papers/2007/achp2007-CleanHaskellQuickGuide.pdf},
 641         language = {en},
 642         author = {Achten, Peter},
 643         month = jul,
 644         year = {2007},
 645         file = {Achten - Clean for Haskell98 Programmers.pdf:/home/mrl/.local/share/zotero/storage/69WWSGLF/Achten - Clean for Haskell98 Programmers.pdf:application/pdf},
 646 }
 647
 648 @inproceedings{grebe_threading_2019,
 649         address = {Cham},
 650         title = {Threading the {Arduino} with {Haskell}},
 651         isbn = {978-3-030-14805-8},
 652         abstract = {Programming embedded microcontrollers often requires the scheduling of independent threads of execution, specifying the interaction and sequencing of actions in the multiple threads. Developing and debugging such multi-threaded systems can be especially challenging in highly resource constrained systems such as the Arduino line of microcontroller boards. The Haskino library, developed at the University of Kansas, allows programmers to develop code for Arduino-based microcontrollers using monadic Haskell program fragments. This paper describes our efforts to extend the Haskino library to translate monadic Haskell code to multi-threaded code executing on Arduino boards.},
 653         booktitle = {Trends in {Functional} {Programming}},
 654         publisher = {Springer International Publishing},
 655         author = {Grebe, Mark and Gill, Andy},
 656         editor = {Van Horn, David and Hughes, John},
 657         year = {2019},
 658         pages = {135--154},
 659         file = {Grebe and Gill - Threading the Arduino with Haskell.pdf:/home/mrl/.local/share/zotero/storage/DW5PS9ZA/Grebe and Gill - Threading the Arduino with Haskell.pdf:application/pdf},
 660 }
 661
 662 @inproceedings{baccelli_reprogramming_2018,
 663         title = {Reprogramming {Low}-end {IoT} {Devices} from the {Cloud}},
 664         booktitle = {2018 3rd {Cloudification} of the {Internet} of {Things} ({CIoT})},
 665         publisher = {IEEE},
 666         author = {Baccelli, Emmanuel and Doerr, Joerg and Jallouli, Ons and Kikuchi, Shinji and Morgenstern, Andreas and Padilla, Francisco Acosta and Schleiser, Kaspar and Thomas, Ian},
 667         year = {2018},
 668         pages = {1--6},
 669         file = {Baccelli et al. - 2018 - Reprogramming Low-end IoT Devices from the Cloud.pdf:/home/mrl/.local/share/zotero/storage/M6LX5ZJN/Baccelli et al. - 2018 - Reprogramming Low-end IoT Devices from the Cloud.pdf:application/pdf},
 670 }
 671
 672 @inproceedings{wand_continuation-based_1980,
 673         address = {Stanford University, California, United States},
 674         title = {Continuation-based multiprocessing},
 675         doi = {10.1145/800087.802786},
 676         abstract = {Any multiprocessing facility must include three features: elementary exclusion, data protection, and process saving. While elementary exclusion must rest on some hardware facility (e.g., a test-and-set instruction), the other two requirements are fulﬁlled by features already present in applicative languages. Data protection may be obtained through the use of procedures (closures or funargs), and process saving may be obtained through the use of the catch operator. The use of catch, in particular, allows an elegant treatment of process saving.},
 677         language = {en},
 678         urldate = {2019-02-13},
 679         booktitle = {Proceedings of the 1980 {ACM} conference on {LISP} and functional programming  - {LFP} '80},
 680         publisher = {ACM Press},
 681         author = {Wand, Mitchell},
 682         year = {1980},
 683         pages = {19--28},
 684         file = {Wand - 1980 - Continuation-based multiprocessing.pdf:/home/mrl/.local/share/zotero/storage/XF4Z2R9S/Wand - 1980 - Continuation-based multiprocessing.pdf:application/pdf},
 685 }
 686
 687 @inproceedings{elliott_functional_1997,
 688         title = {Functional reactive animation},
 689         volume = {32},
 690         booktitle = {{ACM} {SIGPLAN} {Notices}},
 691         publisher = {ACM},
 692         author = {Elliott, Conal and Hudak, Paul},
 693         year = {1997},
 694         pages = {263--273},
 695         file = {Elliott and Hudak - 1997 - Functional reactive animation.pdf:/home/mrl/.local/share/zotero/storage/IJZLGXHK/Elliott and Hudak - 1997 - Functional reactive animation.pdf:application/pdf},
 696 }
 697
 698 @mastersthesis{piers_task-oriented_2016,
 699         address = {Nijmegen},
 700         title = {Task-{Oriented} {Programming} for developing non-distributed interruptible embedded systems},
 701         language = {en},
 702         school = {Radboud University},
 703         author = {Piers, Jasper},
 704         year = {2016},
 705         file = {Piers - Task-Oriented Programming for developing non-distr.pdf:/home/mrl/.local/share/zotero/storage/X8BZM9D4/Piers - Task-Oriented Programming for developing non-distr.pdf:application/pdf},
 706 }
 707
 708 @inproceedings{baccelli_scripting_2018,
 709         title = {Scripting {Over}-{The}-{Air}: {Towards} {Containers} on {Low}-end {Devices} in the {Internet} of {Things}},
 710         booktitle = {{IEEE} {PerCom} 2018},
 711         author = {Baccelli, Emmanuel and Doerr, Joerg and Kikuchi, Shinji and Padilla, Francisco and Schleiser, Kaspar and Thomas, Ian},
 712         year = {2018},
 713         file = {Baccelli et al. - Scripting Over-The-Air Towards Containers on Low-.pdf:/home/mrl/.local/share/zotero/storage/98UTMFAC/Baccelli et al. - Scripting Over-The-Air Towards Containers on Low-.pdf:application/pdf},
 714 }
 715
 716 @mastersthesis{amazonas_cabral_de_andrade_developing_2018,
 717         address = {Nijmegen},
 718         title = {Developing {Real} {Life}, {Task} {Oriented} {Applications} for the {Internet} of {Things}},
 719         shorttitle = {Developing {Real} {Life}, {TOP} {Applications} for the {IOT}},
 720         language = {en},
 721         school = {Radboud University},
 722         author = {Amazonas Cabral de Andrade, Matheus},
 723         year = {2018},
 724         file = {Lubbers - prof. dr. dr.h.c. ir. M.J. Plasmeijer.pdf:/home/mrl/.local/share/zotero/storage/JXPEWS85/Lubbers - prof. dr. dr.h.c. ir. M.J. Plasmeijer.pdf:application/pdf},
 725 }
 726
 727 @article{swierstra_data_2008,
 728         title = {Data types à la carte},
 729         volume = {18},
 730         doi = {10.1017/S0956796808006758},
 731         number = {4},
 732         journal = {Journal of functional programming},
 733         author = {Swierstra, Wouter},
 734         year = {2008},
 735         pages = {423--436},
 736         file = {swierstra2008.pdf:/home/mrl/.local/share/zotero/storage/BEQKBXWP/swierstra2008.pdf:application/pdf},
 737 }
 738
 739 @article{van_groningen_exchanging_2010,
 740         title = {Exchanging sources between {Clean} and {Haskell}: {A} double-edged front end for the {Clean} compiler},
 741         volume = {45},
 742         shorttitle = {Exchanging sources between {Clean} and {Haskell}},
 743         number = {11},
 744         journal = {ACM Sigplan Notices},
 745         author = {van Groningen, John and van Noort, Thomas and Achten, Peter and Koopman, Pieter and Plasmeijer, Rinus},
 746         year = {2010},
 747         pages = {49--60},
 748         file = {groj10-Haskell_front_end_Clean.pdf:/home/mrl/.local/share/zotero/storage/WVZWX8WT/groj10-Haskell_front_end_Clean.pdf:application/pdf},
 749 }
 750
 751 @inproceedings{grebe_haskino:_2016,
 752         title = {Haskino: {A} remote monad for programming the arduino},
 753         shorttitle = {Haskino},
 754         booktitle = {International {Symposium} on {Practical} {Aspects} of {Declarative} {Languages}},
 755         publisher = {Springer},
 756         author = {Grebe, Mark and Gill, Andy},
 757         year = {2016},
 758         pages = {153--168},
 759         file = {Grebe-16-Haskino.pdf:/home/mrl/.local/share/zotero/storage/ABG7TTLV/Grebe-16-Haskino.pdf:application/pdf},
 760 }
 761
 762 @article{plasmeijer_itasks:_2007,
 763         title = {{iTasks}: executable specifications of interactive work flow systems for the web},
 764         volume = {42},
 765         number = {9},
 766         journal = {ACM SIGPLAN Notices},
 767         author = {Plasmeijer, Rinus and Achten, Peter and Koopman, Pieter},
 768         year = {2007},
 769         pages = {141--152},
 770         file = {plar2007-ICFP07-iTasks.pdf:/home/mrl/.local/share/zotero/storage/N8EUZP7D/plar2007-ICFP07-iTasks.pdf:application/pdf},
 771 }
 772
 773 @incollection{plasmeijer_shallow_2016,
 774         address = {Cham},
 775         series = {Lecture {Notes} in {Computer} {Science}},
 776         title = {A {Shallow} {Embedded} {Type} {Safe} {Extendable} {DSL} for the {Arduino}},
 777         volume = {9547},
 778         isbn = {978-3-319-39110-6},
 779         urldate = {2017-02-22},
 780         booktitle = {Trends in {Functional} {Programming}},
 781         publisher = {Springer International Publishing},
 782         author = {Plasmeijer, Rinus and Koopman, Pieter},
 783         year = {2016},
 784         doi = {10.1007/978-3-319-39110-6},
 785         file = {chp%3A10.1007%2F978-3-319-39110-6_6.pdf:/home/mrl/.local/share/zotero/storage/TJVP6FHF/chp%3A10.1007%2F978-3-319-39110-6_6.pdf:application/pdf},
 786 }
 787
 788 @inproceedings{cheney_lightweight_2002,
 789         title = {A lightweight implementation of generics and dynamics},
 790         doi = {10.1145/581690.581698},
 791         urldate = {2017-05-15},
 792         booktitle = {Proceedings of the 2002 {ACM} {SIGPLAN} workshop on {Haskell}},
 793         publisher = {ACM},
 794         author = {Cheney, James and Hinze, Ralf},
 795         year = {2002},
 796         note = {event-place: Pittsburgh Pennsylvania, USA},
 797         keywords = {dynamic typing, generic programming, type representations},
 798         pages = {90--104},
 799         file = {Cheney and Hinze - 2002 - A lightweight implementation of generics and dynam.pdf:/home/mrl/.local/share/zotero/storage/FZ6EGJRJ/Cheney and Hinze - 2002 - A lightweight implementation of generics and dynam.pdf:application/pdf;HW02.pdf:/home/mrl/.local/share/zotero/storage/A8Z49NK6/HW02.pdf:application/pdf},
 800 }
 801
 802 @article{lilis_survey_2019,
 803         title = {A {Survey} of {Metaprogramming} {Languages}},
 804         volume = {52},
 805         issn = {0360-0300},
 806         doi = {10.1145/3354584},
 807         abstract = {Metaprogramming is the process of writing computer programs that treat programs as data, enabling them to analyze or transform existing programs or generate new ones. While the concept of metaprogramming has existed for several decades, activities focusing on metaprogramming have been increasing rapidly over the past few years, with most languages offering some metaprogramming support and the amount of metacode being developed growing exponentially. In this article, we introduce a taxonomy of metaprogramming languages and present a survey of metaprogramming languages and systems based on the taxonomy. Our classification is based on the metaprogramming model adopted by the language, the phase of the metaprogram evaluation, the metaprogram source location, and the relation between the metalanguage and the object language.},
 808         number = {6},
 809         journal = {ACM Comput. Surv.},
 810         author = {Lilis, Yannis and Savidis, Anthony},
 811         month = oct,
 812         year = {2019},
 813         note = {Place: New York, NY, USA
 814 Publisher: Association for Computing Machinery},
 815         keywords = {aspect-oriented programming, generative programming, macro systems, meta-object protocols, Metaprogramming, multistage languages, reflection},
 816         file = {Lilis and Savidis - 2019 - A Survey of Metaprogramming Languages.pdf:/home/mrl/.local/share/zotero/storage/9MS6TUNR/Lilis and Savidis - 2019 - A Survey of Metaprogramming Languages.pdf:application/pdf},
 817 }
 818
 819 @inproceedings{mainland_why_2007,
 820         address = {New York, NY, USA},
 821         series = {Haskell '07},
 822         title = {Why {It}'s {Nice} to {Be} {Quoted}: {Quasiquoting} for {Haskell}},
 823         isbn = {978-1-59593-674-5},
 824         doi = {10.1145/1291201.1291211},
 825         abstract = {Quasiquoting allows programmers to use domain specific syntax to construct program fragments. By providing concrete syntax for complex data types, programs become easier to read, easier to write, and easier to reason about and maintain. Haskell is an excellent host language for embedded domain specific languages, and quasiquoting ideally complements the language features that make Haskell perform so well in this area. Unfortunately, until now no Haskell compiler has provided support for quasiquoting. We present an implementation in GHC and demonstrate that by leveraging existing compiler capabilities, building a full quasiquoter requires little more work than writing a parser. Furthermore, we provide a compile-time guarantee that all quasiquoted data is type-correct.},
 826         booktitle = {Proceedings of the {ACM} {SIGPLAN} {Workshop} on {Haskell} {Workshop}},
 827         publisher = {ACM},
 828         author = {Mainland, Geoffrey},
 829         year = {2007},
 830         note = {event-place: Freiburg, Germany},
 831         keywords = {meta programming, quasiquoting},
 832         pages = {73--82},
 833         file = {Mainland - 2007 - Why It's Nice to Be Quoted Quasiquoting for Haske.pdf:/home/mrl/.local/share/zotero/storage/PSJ59GY2/Mainland - 2007 - Why It's Nice to Be Quoted Quasiquoting for Haske.pdf:application/pdf},
 834 }
 835
 836 @article{tratt_domain_2008,
 837         title = {Domain {Specific} {Language} {Implementation} via {Compile}-{Time} {Meta}-{Programming}},
 838         volume = {30},
 839         issn = {0164-0925},
 840         doi = {10.1145/1391956.1391958},
 841         abstract = {Domain specific languages (DSLs) are mini-languages that are increasingly seen as being a valuable tool for software developers and non-developers alike. DSLs must currently be created in an ad-hoc fashion, often leading to high development costs and implementations of variable quality. In this article, I show how expressive DSLs can be hygienically embedded in the Converge programming language using its compile-time meta-programming facility, the concept of DSL blocks, and specialised error reporting techniques. By making use of pre-existing facilities, and following a simple methodology, DSL implementation costs can be significantly reduced whilst leading to higher quality DSL implementations.},
 842         number = {6},
 843         journal = {ACM Trans. Program. Lang. Syst.},
 844         author = {Tratt, Laurence},
 845         month = oct,
 846         year = {2008},
 847         note = {Place: New York, NY, USA
 848 Publisher: Association for Computing Machinery},
 849         keywords = {domain specific languages, compile-time meta-programming, Syntax extension},
 850         file = {Tratt - 2008 - Domain Specific Language Implementation via Compil.pdf:/home/mrl/.local/share/zotero/storage/HHGYJK4H/Tratt - 2008 - Domain Specific Language Implementation via Compil.pdf:application/pdf},
 851 }
 852
 853 @inproceedings{kariotis_making_2008,
 854         address = {New York, NY, USA},
 855         series = {Haskell '08},
 856         title = {Making {Monads} {First}-{Class} with {Template} {Haskell}},
 857         isbn = {978-1-60558-064-7},
 858         doi = {10.1145/1411286.1411300},
 859         abstract = {Monads as an organizing principle for programming and semantics are notoriously difficult to grasp, yet they are a central and powerful abstraction in Haskell. This paper introduces a domain-specific language, MonadLab, that simplifies the construction of monads, and describes its implementation in Template Haskell. MonadLab makes monad construction truly first class, meaning that arcane theoretical issues with respect to monad transformers are completely hidden from the programmer. The motivation behind the design of MonadLab is to make monadic programming in Haskell simpler while providing a tool for non-Haskell experts that will assist them in understanding this powerful abstraction.},
 860         booktitle = {Proceedings of the {First} {ACM} {SIGPLAN} {Symposium} on {Haskell}},
 861         publisher = {ACM},
 862         author = {Kariotis, Pericles S. and Procter, Adam M. and Harrison, William L.},
 863         year = {2008},
 864         note = {event-place: Victoria, BC, Canada},
 865         keywords = {domain-specific languages, monads, staged programming},
 866         pages = {99--110},
 867         file = {Kariotis et al. - 2008 - Making Monads First-Class with Template Haskell.pdf:/home/mrl/.local/share/zotero/storage/ZLX24WE8/Kariotis et al. - 2008 - Making Monads First-Class with Template Haskell.pdf:application/pdf},
 868 }
 869
 870 @inproceedings{gill_haskell_2009,
 871         address = {Berlin, Heidelberg},
 872         title = {A {Haskell} {Hosted} {DSL} for {Writing} {Transformation} {Systems}},
 873         isbn = {978-3-642-03034-5},
 874         abstract = {KURE is a Haskell hosted Domain Specific Language (DSL) for writing transformation systems based on rewrite strategies. When writing transformation systems, a significant amount of engineering effort goes into setting up plumbing to make sure that specific rewrite rules can fire. Systems like Stratego and Strafunski provide most of this plumbing as infrastructure, allowing the DSL user to focus on the rewrite rules. KURE is a strongly typed strategy control language in the tradition of Stratego and Strafunski. It is intended for writing reasonably efficient rewrite systems, makes use of type families to provide a delimited generic mechanism for tree rewriting, and provides support for efficient identity rewrite detection.},
 875         booktitle = {Domain-{Specific} {Languages}},
 876         publisher = {Springer Berlin Heidelberg},
 877         author = {Gill, Andy},
 878         editor = {Taha, Walid Mohamed},
 879         year = {2009},
 880         pages = {285--309},
 881         file = {Gill2009_Chapter_AHaskellHostedDSLForWritingTra.pdf:/home/mrl/.local/share/zotero/storage/I9RJNDYR/Gill2009_Chapter_AHaskellHostedDSLForWritingTra.pdf:application/pdf},
 882 }
 883
 884 @book{peyton_jones_implementation_1987,
 885         address = {Hertfordshire},
 886         title = {The {Implementation} of {Functional} {Programming} {Languages}},
 887         url = {https://www.microsoft.com/en-us/research/publication/the-implementation-of-functional-programming-languages/},
 888         abstract = {My 1987 book is now out of print, but it is available here in its entirety in PDF form, in one of two formats: single-page portrait double-page landscape Both are fully searchable, thanks to OCR and Norman Ramsey. Errata Section 5.2.4, p87. We need an extra rule match us [] E = E This accounts for the possibility that in the constructor rule (Section 5.2.4) there may be some non-nullary constructors for which there are no equations. P168, line 2, "VAR" should be "TVAR".},
 889         publisher = {Prentice Hall},
 890         author = {Peyton Jones, Simon},
 891         month = jan,
 892         year = {1987},
 893         file = {Peyton Jones - 1987 - The Implementation of Functional Programming Langu.pdf:/home/mrl/.local/share/zotero/storage/9RIR6KGD/Peyton Jones - 1987 - The Implementation of Functional Programming Langu.pdf:application/pdf},
 894 }
 895
 896 @inproceedings{sheard_template_2002,
 897         address = {New York, NY, USA},
 898         series = {Haskell '02},
 899         title = {Template {Meta}-{Programming} for {Haskell}},
 900         isbn = {1-58113-605-6},
 901         doi = {10.1145/581690.581691},
 902         abstract = {We propose a new extension to the purely functional programming language Haskell that supports compile-time meta-programming. The purpose of the system is to support the algorithmic construction of programs at compile-time.The ability to generate code at compile time allows the programmer to implement such features as polytypic programs, macro-like expansion, user directed optimization (such as inlining), and the generation of supporting data structures and functions from existing data structures and functions.Our design is being implemented in the Glasgow Haskell Compiler, ghc.},
 903         booktitle = {Proceedings of the 2002 {ACM} {SIGPLAN} {Workshop} on {Haskell}},
 904         publisher = {ACM},
 905         author = {Sheard, Tim and Peyton Jones, Simon},
 906         year = {2002},
 907         note = {event-place: Pittsburgh, Pennsylvania},
 908         keywords = {meta programming, templates},
 909         pages = {1--16},
 910         file = {Sheard and Jones - 2002 - Template Meta-Programming for Haskell.pdf:/home/mrl/.local/share/zotero/storage/2GSK6DSF/Sheard and Jones - 2002 - Template Meta-Programming for Haskell.pdf:application/pdf},
 911 }
 912
 913 @inproceedings{seefried_optimising_2004,
 914         address = {Berlin, Heidelberg},
 915         title = {Optimising {Embedded} {DSLs} {Using} {Template} {Haskell}},
 916         isbn = {978-3-540-30175-2},
 917         abstract = {Embedded domain specific languages (EDSLs) provide a specialised language for a particular application area while harnessing the infrastructure of an existing general purpose programming language. The reduction in implementation costs that results from this approach comes at a price: the EDSL often compiles to inefficient code since the host language's compiler only optimises at the level of host language constructs. The paper presents an approach to solving this problem based on compile-time meta-programming which retains the simplicity of the embedded approach. We use PanTHeon, our implementation of an existing EDSL for image synthesis to demonstrate the benefits and drawbacks of this approach. Furthermore, we suggest potential improvements to Template Haskell, the meta-programming framework we are using, which would greatly improve its applicability to this kind of task.},
 918         booktitle = {Generative {Programming} and {Component} {Engineering}},
 919         publisher = {Springer Berlin Heidelberg},
 920         author = {Seefried, Sean and Chakravarty, Manuel and Keller, Gabriele},
 921         editor = {Karsai, Gabor and Visser, Eelco},
 922         year = {2004},
 923         pages = {186--205},
 924         file = {Seefried et al. - 2004 - Optimising Embedded DSLs Using Template Haskell.pdf:/home/mrl/.local/share/zotero/storage/ZRKQ9AH6/Seefried et al. - 2004 - Optimising Embedded DSLs Using Template Haskell.pdf:application/pdf},
 925 }
 926
 927 @article{hammond_automatic_2003,
 928         title = {Automatic {Skeletons} in {Template} {Haskell}},
 929         volume = {13},
 930         doi = {10.1142/S0129626403001380},
 931         abstract = {This paper uses Template Haskell to automatically select appropriate skeleton implementations in the Eden parallel dialect of Haskell. The approach allows implementation parameters to be statically tuned according to architectural cost models based on source analyses. This permits us to target a range of parallel architecture classes from a single source specification. A major advantage of the approach is that cost models are user-definable and can be readily extended to new data or computation structures etc.},
 932         number = {03},
 933         journal = {Parallel Processing Letters},
 934         author = {Hammond, Kevin and Berthold, Jost and Loogen, Rita},
 935         year = {2003},
 936         pages = {413--424},
 937         file = {Hammond et al. - 2003 - AUTOMATIC SKELETONS IN TEMPLATE HASKELL.pdf:/home/mrl/.local/share/zotero/storage/HBQ8UXY3/Hammond et al. - 2003 - AUTOMATIC SKELETONS IN TEMPLATE HASKELL.pdf:application/pdf},
 938 }
 939
 940 @inproceedings{adams_template_2012,
 941         address = {New York, NY, USA},
 942         series = {Haskell '12},
 943         title = {Template {Your} {Boilerplate}: {Using} {Template} {Haskell} for {Efficient} {Generic} {Programming}},
 944         isbn = {978-1-4503-1574-6},
 945         doi = {10.1145/2364506.2364509},
 946         abstract = {Generic programming allows the concise expression of algorithms that would otherwise require large amounts of handwritten code. A number of such systems have been developed over the years, but a common drawback of these systems is poor runtime performance relative to handwritten, non-generic code. Generic-programming systems vary significantly in this regard, but few consistently match the performance of handwritten code. This poses a dilemma for developers. Generic-programming systems offer concision but cost performance. Handwritten code offers performance but costs concision.This paper explores the use of Template Haskell to achieve the best of both worlds. It presents a generic-programming system for Haskell that provides both the concision of other generic-programming systems and the efficiency of handwritten code. Our system gives the programmer a high-level, generic-programming interface, but uses Template Haskell to generate efficient, non-generic code that outperforms existing generic-programming systems for Haskell.This paper presents the results of benchmarking our system against both handwritten code and several other generic-programming systems. In these benchmarks, our system matches the performance of handwritten code while other systems average anywhere from two to twenty times slower.},
 947         booktitle = {Proceedings of the 2012 {Haskell} {Symposium}},
 948         publisher = {ACM},
 949         author = {Adams, Michael D. and DuBuisson, Thomas M.},
 950         year = {2012},
 951         note = {event-place: Copenhagen, Denmark},
 952         keywords = {generic programming, scrap your boilerplate, template haskell},
 953         pages = {13--24},
 954         file = {Adams and DuBuisson - 2012 - Template Your Boilerplate Using Template Haskell .pdf:/home/mrl/.local/share/zotero/storage/ANAHWLB5/Adams and DuBuisson - 2012 - Template Your Boilerplate Using Template Haskell .pdf:application/pdf},
 955 }
 956
 957 @inproceedings{norell_prototyping_2004,
 958         address = {Berlin, Heidelberg},
 959         title = {Prototyping {Generic} {Programming} in {Template} {Haskell}},
 960         isbn = {978-3-540-27764-4},
 961         abstract = {Generic Programming deals with the construction of programs that can be applied to many different datatypes. This is achieved by parameterizing the generic programs by the structure of the datatypes on which they are to be applied. Programs that can be defined generically range from simple map functions through pretty printers to complex XML tools.},
 962         booktitle = {Mathematics of {Program} {Construction}},
 963         publisher = {Springer Berlin Heidelberg},
 964         author = {Norell, Ulf and Jansson, Patrik},
 965         editor = {Kozen, Dexter},
 966         year = {2004},
 967         pages = {314--333},
 968         file = {Norell and Jansson - 2004 - Prototyping Generic Programming in Template Haskel.pdf:/home/mrl/.local/share/zotero/storage/S3EXD65Z/Norell and Jansson - 2004 - Prototyping Generic Programming in Template Haskel.pdf:application/pdf},
 969 }
 970
 971 @incollection{odonnell_embedding_2004,
 972         address = {Berlin, Heidelberg},
 973         title = {Embedding a {Hardware} {Description} {Language} in {Template} {Haskell}},
 974         isbn = {978-3-540-25935-0},
 975         abstract = {Hydra is a domain-specific language for designing digital circuits, which is implemented by embedding within Haskell. Many features required for hardware specification fit well within functional languages, leading in many cases to a perfect embedding. There are some situations, including netlist generation and software logic probes, where the DSL does not fit exactly within the host functional language. A new solution to these problems is based on program transformations performed automatically by metaprograms in Template Haskell.},
 976         booktitle = {Domain-{Specific} {Program} {Generation}: {International} {Seminar}, {Dagstuhl} {Castle}, {Germany}, {March} 23-28, 2003. {Revised} {Papers}},
 977         publisher = {Springer Berlin Heidelberg},
 978         author = {O'Donnell, John T.},
 979         editor = {Lengauer, Christian and Batory, Don and Consel, Charles and Odersky, Martin},
 980         year = {2004},
 981         doi = {10.1007/978-3-540-25935-0_9},
 982         pages = {143--164},
 983         file = {O'Donnell - 2004 - Embedding a Hardware Description Language in Templ.pdf:/home/mrl/.local/share/zotero/storage/Z2XT7SM3/O'Donnell - 2004 - Embedding a Hardware Description Language in Templ.pdf:application/pdf},
 984 }
 985
 986 @misc{lynagh_unrolling_2003,
 987         title = {Unrolling and {Simplifying} {Expressions} with {Template} {Haskell}},
 988         url = {http://web.comlab.ox.ac.uk/oucl/work/ian.lynagh/papers/},
 989         urldate = {2021-09-07},
 990         author = {Lynagh, Ian},
 991         month = may,
 992         year = {2003},
 993         file = {10.1.1.5.9813.pdf:/home/mrl/.local/share/zotero/storage/G4AFM8XZ/10.1.1.5.9813.pdf:application/pdf},
 994 }
 995
 996 @article{elliott_compiling_2003,
 997         title = {Compiling embedded languages},
 998         volume = {13},
 999         doi = {10.1017/S0956796802004574},
1000         number = {3},
1001         journal = {Journal of Functional Programming},
1002         author = {Elliott, Conal and Finne, Sigbjørn and de Moor, Oege},
1003         year = {2003},
1004         note = {Publisher: Cambridge University Press},
1005         pages = {455--481},
1006         file = {Elliott et al. - 2003 - Compiling embedded languages.pdf:/home/mrl/.local/share/zotero/storage/3X4Z6AKB/Elliott et al. - 2003 - Compiling embedded languages.pdf:application/pdf},
1007 }
1008
1009 @incollection{czarnecki_dsl_2004,
1010         address = {Berlin, Heidelberg},
1011         title = {{DSL} {Implementation} in {MetaOCaml}, {Template} {Haskell}, and {C}++},
1012         isbn = {978-3-540-25935-0},
1013         abstract = {A wide range of domain-specific languages (DSLs) has been implemented successfully by embedding them in general purpose languages. This paper reviews embedding, and summarizes how two alternative techniques – staged interpreters and templates – can be used to overcome the limitations of embedding. Both techniques involve a form of generative programming. The paper reviews and compares three programming languages that have special support for generative programming. Two of these languages (MetaOCaml and Template Haskell) are research languages, while the third (C++) is already in wide industrial use. The paper identifies several dimensions that can serve as a basis for comparing generative languages.},
1014         booktitle = {Domain-{Specific} {Program} {Generation}: {International} {Seminar}, {Dagstuhl} {Castle}, {Germany}, {March} 23-28, 2003. {Revised} {Papers}},
1015         publisher = {Springer Berlin Heidelberg},
1016         author = {Czarnecki, Krzysztof and O'Donnell, John T. and Striegnitz, Jörg and Taha, Walid},
1017         editor = {Lengauer, Christian and Batory, Don and Consel, Charles and Odersky, Martin},
1018         year = {2004},
1019         doi = {10.1007/978-3-540-25935-0_4},
1020         pages = {51--72},
1021         file = {Czarnecki et al. - 2004 - DSL Implementation in MetaOCaml, Template Haskell,.pdf:/home/mrl/.local/share/zotero/storage/U6E3325Q/Czarnecki et al. - 2004 - DSL Implementation in MetaOCaml, Template Haskell,.pdf:application/pdf},
1022 }
1023
1024 @inproceedings{sheard_accomplishments_2001,
1025         address = {Berlin, Heidelberg},
1026         title = {Accomplishments and {Research} {Challenges} in {Meta}-programming},
1027         isbn = {978-3-540-44806-8},
1028         abstract = {In the last ten years the study of meta-programming systems, as formal systems worthy of study in their own right, has vastly accelerated. In that time a lot has been accomplished, yet much remains to be done. In this invited talk I wish to review recent accomplishments and future research challenges in hopes that this will spur interest in meta-programming in general and lead to new and better meta-programming systems.},
1029         booktitle = {Semantics, {Applications}, and {Implementation} of {Program} {Generation}},
1030         publisher = {Springer Berlin Heidelberg},
1031         author = {Sheard, Tim},
1032         editor = {Taha, Walid},
1033         year = {2001},
1034         pages = {2--44},
1035         file = {Sheard - 2001 - Accomplishments and Research Challenges in Meta-pr.pdf:/home/mrl/.local/share/zotero/storage/M7NT6USA/Sheard - 2001 - Accomplishments and Research Challenges in Meta-pr.pdf:application/pdf},
1036 }
1037
1038 @inproceedings{kohlbecker_hygienic_1986,
1039         address = {New York, NY, USA},
1040         series = {{LFP} '86},
1041         title = {Hygienic {Macro} {Expansion}},
1042         isbn = {0-89791-200-4},
1043         doi = {10.1145/319838.319859},
1044         booktitle = {Proceedings of the 1986 {ACM} {Conference} on {LISP} and {Functional} {Programming}},
1045         publisher = {ACM},
1046         author = {Kohlbecker, Eugene and Friedman, Daniel P. and Felleisen, Matthias and Duba, Bruce},
1047         year = {1986},
1048         note = {event-place: Cambridge, Massachusetts, USA},
1049         pages = {151--161},
1050         file = {Kohlbecker et al. - 1986 - Hygienic Macro Expansion.pdf:/home/mrl/.local/share/zotero/storage/MFH642JU/Kohlbecker et al. - 1986 - Hygienic Macro Expansion.pdf:application/pdf},
1051 }
1052
1053 @inproceedings{lammel_scrap_2003,
1054         address = {New York, NY, USA},
1055         series = {{TLDI} '03},
1056         title = {Scrap {Your} {Boilerplate}: {A} {Practical} {Design} {Pattern} for {Generic} {Programming}},
1057         isbn = {1-58113-649-8},
1058         doi = {10.1145/604174.604179},
1059         abstract = {We describe a design pattern for writing programs that traverse data structures built from rich mutually-recursive data types. Such programs often have a great deal of "boilerplate" code that simply walks the structure, hiding a small amount of "real" code that constitutes the reason for the traversal.Our technique allows most of this boilerplate to be written once and for all, or even generated mechanically, leaving the programmer free to concentrate on the important part of the algorithm. These generic programs are much more adaptive when faced with data structure evolution because they contain many fewer lines of type-specific code.Our approach is simple to understand, reasonably efficient, and it handles all the data types found in conventional functional programming languages. It makes essential use of rank-2 polymorphism, an extension found in some implementations of Haskell. Further it relies on a simple type-safe cast operator.},
1060         booktitle = {Proceedings of the 2003 {ACM} {SIGPLAN} {International} {Workshop} on {Types} in {Languages} {Design} and {Implementation}},
1061         publisher = {ACM},
1062         author = {Lämmel, Ralf and Peyton Jones, Simon},
1063         year = {2003},
1064         note = {event-place: New Orleans, Louisiana, USA},
1065         keywords = {generic programming, rank-2 types, traversal, type cast},
1066         pages = {26--37},
1067         file = {Lämmel and Jones - 2003 - Scrap Your Boilerplate A Practical Design Pattern.pdf:/home/mrl/.local/share/zotero/storage/P2PJYYY3/Lämmel and Jones - 2003 - Scrap Your Boilerplate A Practical Design Pattern.pdf:application/pdf},
1068 }
1069
1070 @inproceedings{bawden_quasiquotation_1999,
1071         address = {Aarhus, Denmark},
1072         series = {{BRICS} {Notes} {Series}},
1073         title = {Quasiquotation in {Lisp}},
1074         volume = {NS-99-1},
1075         doi = {10.1.1.22.1290},
1076         booktitle = {O. {Danvy}, {Ed}., {University} of {Aarhus}, {Dept}. of {Computer} {Science}},
1077         publisher = {BRICS},
1078         author = {Bawden, Alan},
1079         year = {1999},
1080         pages = {88--99},
1081         file = {Bawden - 1999 - Quasiquotation in Lisp.pdf:/home/mrl/.local/share/zotero/storage/CIFANZAW/Bawden - 1999 - Quasiquotation in Lisp.pdf:application/pdf},
1082 }
1083
1084 @inproceedings{clifton-everest_embedding_2014,
1085         address = {Cham},
1086         title = {Embedding {Foreign} {Code}},
1087         isbn = {978-3-319-04132-2},
1088         abstract = {Special purpose embedded languages facilitate generating high-performance code from purely functional high-level code; for example, we want to program highly parallel GPUs without the usual high barrier to entry and the time-consuming development process. We previously demonstrated the feasibility of a skeleton-based, generative approach to compiling such embedded languages.},
1089         booktitle = {Practical {Aspects} of {Declarative} {Languages}},
1090         publisher = {Springer International Publishing},
1091         author = {Clifton-Everest, Robert and McDonell, Trevor L. and Chakravarty, Manuel M. T. and Keller, Gabriele},
1092         editor = {Flatt, Matthew and Guo, Hai-Feng},
1093         year = {2014},
1094         pages = {136--151},
1095         file = {Clifton-Everest et al. - 2014 - Embedding Foreign Code.pdf:/home/mrl/.local/share/zotero/storage/JTJGK5BX/Clifton-Everest et al. - 2014 - Embedding Foreign Code.pdf:application/pdf},
1096 }
1097
1098 @inproceedings{shioda_libdsl_2014,
1099         address = {New York, NY, USA},
1100         series = {{GPCE} 2014},
1101         title = {{LibDSL}: {A} {Library} for {Developing} {Embedded} {Domain} {Specific} {Languages} in d via {Template} {Metaprogramming}},
1102         isbn = {978-1-4503-3161-6},
1103         doi = {10.1145/2658761.2658770},
1104         abstract = {This paper presents a library called LibDSL that helps the implementer of an embedded domain specific language (EDSL) effectively develop it in D language. The LibDSL library accepts as input some kinds of “specifications” of the EDSL that the implementer is going to develop and a D program within which an EDSL source program written by the user is embedded. It produces the front-end code of an LALR parser for the EDSL program and back-end code of the execution engine. LibDSL is able to produce two kinds of execution engines, namely compiler-based and interpreter-based engines, either of which the user can properly choose depending on whether an EDSL program is known at compile time or not. We have implemented the LibDSL system by using template metaprogramming and other advanced facilities such as compile-time function execution of D language. EDSL programs developed by means of LibDSL have a nice integrativeness with the host language.},
1105         booktitle = {Proceedings of the 2014 {International} {Conference} on {Generative} {Programming}: {Concepts} and {Experiences}},
1106         publisher = {ACM},
1107         author = {Shioda, Masato and Iwasaki, Hideya and Sato, Shigeyuki},
1108         year = {2014},
1109         note = {event-place: Västerås, Sweden},
1110         keywords = {Metaprogramming, D language, Embedded domain specific languages, Library},
1111         pages = {63--72},
1112         file = {Shioda et al. - 2014 - LibDSL A Library for Developing Embedded Domain S.pdf:/home/mrl/.local/share/zotero/storage/3WFYJPFR/Shioda et al. - 2014 - LibDSL A Library for Developing Embedded Domain S.pdf:application/pdf},
1113 }
1114
1115 @inproceedings{duregard_embedded_2011,
1116         address = {New York, NY, USA},
1117         series = {Haskell '11},
1118         title = {Embedded {Parser} {Generators}},
1119         isbn = {978-1-4503-0860-1},
1120         doi = {10.1145/2034675.2034689},
1121         abstract = {We present a novel method of embedding context-free grammars in Haskell, and to automatically generate parsers and pretty-printers from them. We have implemented this method in a library called BNFC-meta (from the BNF Converter, which it is built on). The library builds compiler front ends using metaprogramming instead of conventional code generation. Parsers are built from labelled BNF grammars that are defined directly in Haskell modules. Our solution combines features of parser generators (static grammar checks, a highly specialised grammar DSL) and adds several features that are otherwise exclusive to combinatory libraries such as the ability to reuse, parameterise and generate grammars inside Haskell.To allow writing grammars in concrete syntax, BNFC-meta provides a quasi-quoter that can parse grammars (embedded in Haskell files) at compile time and use metaprogramming to replace them with their abstract syntax. We also generate quasi-quoters so that the languages we define with BNFC-meta can be embedded in the same way. With a minimal change to the grammar, we support adding anti-quotation to the generated quasi-quoters, which allows users of the defined language to mix concrete and abstract syntax almost seamlessly. Unlike previous methods of achieving anti-quotation, the method used by BNFC-meta is simple, efficient and avoids polluting the abstract syntax types.},
1122         booktitle = {Proceedings of the 4th {ACM} {Symposium} on {Haskell}},
1123         publisher = {ACM},
1124         author = {Duregård, Jonas and Jansson, Patrik},
1125         year = {2011},
1126         note = {event-place: Tokyo, Japan},
1127         keywords = {domain specific languages, metaprogramming},
1128         pages = {107--117},
1129         file = {Duregård and Jansson - 2011 - Embedded Parser Generators.pdf:/home/mrl/.local/share/zotero/storage/H5A8TPWV/Duregård and Jansson - 2011 - Embedded Parser Generators.pdf:application/pdf},
1130 }
1131
1132 @inproceedings{eisenberg_promoting_2014,
1133         address = {New York, NY, USA},
1134         series = {Haskell '14},
1135         title = {Promoting {Functions} to {Type} {Families} in {Haskell}},
1136         isbn = {978-1-4503-3041-1},
1137         doi = {10.1145/2633357.2633361},
1138         abstract = {Haskell, as implemented in the Glasgow Haskell Compiler (GHC), is enriched with many extensions that support type-level programming, such as promoted datatypes, kind polymorphism, and type families. Yet, the expressiveness of the type-level language remains limited. It is missing many features present at the term level, including case expressions, anonymous functions, partially-applied functions, and let expressions. In this paper, we present an algorithm - with a proof of correctness - to encode these term-level constructs at the type level. Our approach is automated and capable of promoting a wide array of functions to type families. We also highlight and discuss those term-level features that are not promotable. In so doing, we offer a critique on GHC's existing type system, showing what it is already capable of and where it may want improvement.We believe that delineating the mismatch between GHC's term level and its type level is a key step toward supporting dependently typed programming.},
1139         booktitle = {Proceedings of the 2014 {ACM} {SIGPLAN} {Symposium} on {Haskell}},
1140         publisher = {ACM},
1141         author = {Eisenberg, Richard A. and Stolarek, Jan},
1142         year = {2014},
1143         note = {event-place: Gothenburg, Sweden},
1144         keywords = {Haskell, defunctionalization, type-level programming},
1145         pages = {95--106},
1146         file = {Eisenberg and Stolarek - 2014 - Promoting Functions to Type Families in Haskell.pdf:/home/mrl/.local/share/zotero/storage/PQXGBM6M/Eisenberg and Stolarek - 2014 - Promoting Functions to Type Families in Haskell.pdf:application/pdf},
1147 }
1148
1149 @inproceedings{viera_staged_2018,
1150         address = {New York, NY, USA},
1151         series = {{IFL} 2018},
1152         title = {A {Staged} {Embedding} of {Attribute} {Grammars} in {Haskell}},
1153         isbn = {978-1-4503-7143-8},
1154         doi = {10.1145/3310232.3310235},
1155         abstract = {In this paper, we present an embedding of attribute grammars in Haskell, that is both modular and type-safe, while providing the user with domain specific error messages.Our approach involves to delay part of the safety checks to runtime. When a grammar is correct, we are able to extract a function that can be run without expecting any runtime error related to the EDSL.},
1156         booktitle = {Proceedings of the 30th {Symposium} on {Implementation} and {Application} of {Functional} {Languages}},
1157         publisher = {ACM},
1158         author = {Viera, Marcos and Balestrieri, Florent and Pardo, Alberto},
1159         year = {2018},
1160         note = {event-place: Lowell, MA, USA},
1161         keywords = {Haskell, EDSL, Attribute Grammars, Dynamics, Staging},
1162         pages = {95--106},
1163         file = {Viera et al. - 2018 - A Staged Embedding of Attribute Grammars in Haskel.pdf:/home/mrl/.local/share/zotero/storage/53D4HT9C/Viera et al. - 2018 - A Staged Embedding of Attribute Grammars in Haskel.pdf:application/pdf},
1164 }
1165
1166 @article{laufer_type_1996,
1167         title = {Type classes with existential types},
1168         volume = {6},
1169         doi = {10.1017/S0956796800001817},
1170         number = {3},
1171         journal = {Journal of Functional Programming},
1172         author = {Läufer, Konstantin},
1173         year = {1996},
1174         note = {Publisher: Cambridge University Press},
1175         pages = {485--518},
1176         file = {Läufer - 1996 - Type classes with existential types.pdf:/home/mrl/.local/share/zotero/storage/FG73PZJE/Läufer - 1996 - Type classes with existential types.pdf:application/pdf},
1177 }
1178
1179 @incollection{hinze_fun_2003,
1180         address = {Palgrave},
1181         series = {Cornerstones of {Computing}},
1182         title = {Fun {With} {Phantom} {Types}},
1183         isbn = {978-0-333-99285-2},
1184         booktitle = {The {Fun} of {Programming}},
1185         publisher = {Bloomsbury Publishing},
1186         author = {Hinze, Ralf},
1187         editor = {Gibbons, Jeremy and de Moor, Oege},
1188         year = {2003},
1189         pages = {245--262},
1190 }
1191
1192 @inproceedings{boulton_experience_1992,
1193         address = {North-Holland},
1194         title = {Experience with embedding hardware description languages in {HOL}},
1195         volume = {10},
1196         isbn = {0-444-89686-4},
1197         abstract = {The semantics of hardware description languages can be represented in higher order logic. This provides a formal de nition that is suitable for machine processing. Experiments are in progress at Cambridge to see whether this method can be the basis of practical tools based on the HOL theorem-proving assistant. Three languages are being investigated: ELLA, Silage and VHDL. The approaches taken for these languages are compared and current progress on building semantically-based theorem-proving tools is discussed.},
1198         language = {en},
1199         booktitle = {{IFIP} {TC10}/{WG}},
1200         publisher = {Elsevier},
1201         author = {Boulton, Richard and Gordon, Andrew and Gordon, Mike and Harrison, John and Herbert, John and Tassel, John Van},
1202         editor = {Stavridou, Victoria and Melham, Thomas F. and Boute, Raymond T.},
1203         year = {1992},
1204         note = {event-place: Nijmegen, NL},
1205         pages = {129--156},
1206         file = {Boulton et al. - Experience with embedding hardware description lan.pdf:/home/mrl/.local/share/zotero/storage/USAAA6WM/Boulton et al. - Experience with embedding hardware description lan.pdf:application/pdf},
1207 }
1208
1209 @inproceedings{terei_safe_2012,
1210         address = {New York, NY, USA},
1211         series = {Haskell '12},
1212         title = {Safe {Haskell}},
1213         isbn = {978-1-4503-1574-6},
1214         doi = {10.1145/2364506.2364524},
1215         abstract = {Though Haskell is predominantly type-safe, implementations contain a few loopholes through which code can bypass typing and module encapsulation. This paper presents Safe Haskell, a language extension that closes these loopholes. Safe Haskell makes it possible to confine and safely execute untrusted, possibly malicious code. By strictly enforcing types, Safe Haskell allows a variety of different policies from API sandboxing to information-flow control to be implemented easily as monads. Safe Haskell is aimed to be as unobtrusive as possible. It enforces properties that programmers tend to meet already by convention. We describe the design of Safe Haskell and an implementation (currently shipping with GHC) that infers safety for code that lies in a safe subset of the language. We use Safe Haskell to implement an online Haskell interpreter that can securely execute arbitrary untrusted code with no overhead. The use of Safe Haskell greatly simplifies this task and allows the use of a large body of existing code and tools.},
1216         booktitle = {Proceedings of the 2012 {Haskell} {Symposium}},
1217         publisher = {ACM},
1218         author = {Terei, David and Marlow, Simon and Peyton Jones, Simon and Mazières, David},
1219         year = {2012},
1220         note = {event-place: Copenhagen, Denmark},
1221         keywords = {haskell, security, type safety},
1222         pages = {137--148},
1223         file = {2364506.2364524.pdf:/home/mrl/.local/share/zotero/storage/5SMB272R/2364506.2364524.pdf:application/pdf},
1224 }
1225
1226 @techreport{leijen_parsec_2001,
1227         address = {Utrecht},
1228         title = {Parsec: {Direct} {Style} {Monadic} {Parser} {Combinators} {For} {The} {Real} {World}},
1229         language = {en},
1230         number = {UU-CS-2001-27},
1231         institution = {Universiteit Utrecht},
1232         author = {Leijen, Daan and Meijer, Erik},
1233         year = {2001},
1234         pages = {22},
1235         file = {Leijen - Parsec Direct Style Monadic Parser Combinators Fo.pdf:/home/mrl/.local/share/zotero/storage/J78G3FZ2/Leijen - Parsec Direct Style Monadic Parser Combinators Fo.pdf:application/pdf},
1236 }
1237
1238 @inproceedings{gibbons_folding_2014,
1239         address = {New York, NY, USA},
1240         series = {{ICFP} '14},
1241         title = {Folding {Domain}-{Specific} {Languages}: {Deep} and {Shallow} {Embeddings} ({Functional} {Pearl})},
1242         isbn = {978-1-4503-2873-9},
1243         doi = {10.1145/2628136.2628138},
1244         abstract = {A domain-specific language can be implemented by embedding within a general-purpose host language. This embedding may be deep or shallow, depending on whether terms in the language construct syntactic or semantic representations. The deep and shallow styles are closely related, and intimately connected to folds; in this paper, we explore that connection.},
1245         booktitle = {Proceedings of the 19th {ACM} {SIGPLAN} {International} {Conference} on {Functional} {Programming}},
1246         publisher = {ACM},
1247         author = {Gibbons, Jeremy and Wu, Nicolas},
1248         year = {2014},
1249         note = {event-place: Gothenburg, Sweden},
1250         keywords = {domain-specific languages, deep and shallow embedding, folds},
1251         pages = {339--347},
1252         file = {Gibbons and Wu - 2014 - Folding Domain-Specific Languages Deep and Shallo.pdf:/home/mrl/.local/share/zotero/storage/6WNWSLFJ/Gibbons and Wu - 2014 - Folding Domain-Specific Languages Deep and Shallo.pdf:application/pdf},
1253 }
1254
1255 @inproceedings{oliveira_typecase_2005,
1256         address = {New York, NY, USA},
1257         series = {Haskell '05},
1258         title = {{TypeCase}: {A} {Design} {Pattern} for {Type}-{Indexed} {Functions}},
1259         isbn = {1-59593-071-X},
1260         doi = {10.1145/1088348.1088358},
1261         abstract = {A type-indexed function is a function that is defined for each member of some family of types. Haskell's type class mechanism provides collections of open type-indexed functions, in which the indexing family can be extended by defining a new type class instance but the collection of functions is fixed. The purpose of this paper is to present TypeCase: a design pattern that allows the definition of closed type-indexed functions, in which the index family is fixed but the collection of functions is extensible. It is inspired by Cheney and Hinze's work on lightweight approaches to generic programming. We generalise their techniques as a design pattern. Furthermore, we show that type-indexed functions with type-indexed types, and consequently generic functions with generic types, can also be encoded in a lightweight manner, thereby overcoming one of the main limitations of the lightweight approaches.},
1262         booktitle = {Proceedings of the 2005 {ACM} {SIGPLAN} {Workshop} on {Haskell}},
1263         publisher = {ACM},
1264         author = {Oliveira, Bruno C. d. S. and Gibbons, Jeremy},
1265         year = {2005},
1266         note = {event-place: Tallinn, Estonia},
1267         keywords = {generic programming, type classes, type-indexed functions},
1268         pages = {98--109},
1269         file = {Oliveira and Gibbons - 2005 - TypeCase A Design Pattern for Type-Indexed Functi.pdf:/home/mrl/.local/share/zotero/storage/RBKEZKHN/Oliveira and Gibbons - 2005 - TypeCase A Design Pattern for Type-Indexed Functi.pdf:application/pdf},
1270 }
1271
1272 @inproceedings{odersky_putting_1996,
1273         address = {New York, NY, USA},
1274         series = {{POPL} '96},
1275         title = {Putting {Type} {Annotations} to {Work}},
1276         isbn = {0-89791-769-3},
1277         doi = {10.1145/237721.237729},
1278         abstract = {We study an extension of the Hindley/Milner system with explicit type scheme annotations and type declarations. The system can express polymorphic function arguments, user-defined data types with abstract components, and structure types with polymorphic fields. More generally, all programs of the polymorphic lambda calculus can be encoded by a translation between typing derivations. We show that type reconstruction in this system can be reduced to the decidable problem of first-order unification under a mixed prefix.},
1279         booktitle = {Proceedings of the 23rd {ACM} {SIGPLAN}-{SIGACT} {Symposium} on {Principles} of {Programming} {Languages}},
1280         publisher = {ACM},
1281         author = {Odersky, Martin and Läufer, Konstantin},
1282         year = {1996},
1283         note = {event-place: St. Petersburg Beach, Florida, USA},
1284         pages = {54--67},
1285         file = {Odersky and Läufer - 1996 - Putting Type Annotations to Work.pdf:/home/mrl/.local/share/zotero/storage/WC37TU5H/Odersky and Läufer - 1996 - Putting Type Annotations to Work.pdf:application/pdf},
1286 }
1287
1288 @inproceedings{najd_everything_2016,
1289         address = {New York, NY, USA},
1290         series = {{PEPM} '16},
1291         title = {Everything {Old} is {New} {Again}: {Quoted} {Domain}-{Specific} {Languages}},
1292         isbn = {978-1-4503-4097-7},
1293         doi = {10.1145/2847538.2847541},
1294         abstract = {We describe a new approach to implementing Domain-Specific Languages(DSLs), called Quoted DSLs (QDSLs), that is inspired by two old ideas:quasi-quotation, from McCarthy's Lisp of 1960, and the subformula principle of normal proofs, from Gentzen's natural deduction of 1935. QDSLs reuse facilities provided for the host language, since host and quoted terms share the same syntax, type system, and normalisation rules. QDSL terms are normalised to a canonical form, inspired by the subformula principle, which guarantees that one can use higher-order types in the source while guaranteeing first-order types in the target, and enables using types to guide fusion. We test our ideas by re-implementing Feldspar, which was originally implemented as an Embedded DSL (EDSL), as a QDSL; and we compare the QDSL and EDSL variants. The two variants produce identical code.},
1295         booktitle = {Proceedings of the 2016 {ACM} {SIGPLAN} {Workshop} on {Partial} {Evaluation} and {Program} {Manipulation}},
1296         publisher = {ACM},
1297         author = {Najd, Shayan and Lindley, Sam and Svenningsson, Josef and Wadler, Philip},
1298         year = {2016},
1299         note = {event-place: St. Petersburg, FL, USA},
1300         keywords = {EDSL, domain-specific language, DSL, embedded language, normalisation, QDSL, quotation, subformula principle},
1301         pages = {25--36},
1302         file = {Najd et al. - 2016 - Everything Old is New Again Quoted Domain-Specifi.pdf:/home/mrl/.local/share/zotero/storage/NZJW5ZVF/Najd et al. - 2016 - Everything Old is New Again Quoted Domain-Specifi.pdf:application/pdf},
1303 }
1304
1305 @article{carette_finally_2009,
1306         title = {Finally tagless, partially evaluated: {Tagless} staged interpreters for simpler typed languages},
1307         volume = {19},
1308         doi = {10.1017/S0956796809007205},
1309         number = {5},
1310         journal = {Journal of Functional Programming},
1311         author = {Carette, Jacques and Kiselyov, Oleg and Shan, Chung-Chieh},
1312         year = {2009},
1313         note = {Publisher: Cambridge University Press},
1314         pages = {509--543},
1315         file = {CARETTE et al. - 2009 - Finally tagless, partially evaluated Tagless stag.pdf:/home/mrl/.local/share/zotero/storage/T8C8VMHP/CARETTE et al. - 2009 - Finally tagless, partially evaluated Tagless stag.pdf:application/pdf},
1316 }
1317
1318 @inproceedings{leijen_domain_2000,
1319         address = {New York, NY, USA},
1320         series = {{DSL} '99},
1321         title = {Domain {Specific} {Embedded} {Compilers}},
1322         isbn = {1-58113-255-7},
1323         doi = {10.1145/331960.331977},
1324         abstract = {Domain-specific embedded languages (DSELs) expressed in higher-order, typed (HOT) languages provide a composable framework for domain-specific abstractions. Such a framework is of greater utility than a collection of stand-alone domain-specific languages. Usually, embedded domain specific languages are build on top of a set of domain specific primitive functions that are ultimately implemented using some form of foreign function call. We sketch a general design pattern/or embedding client-server style services into Haskell using a domain specific embedded compiler for the server's source language. In particular we apply this idea to implement Haskell/DB, a domain specific embdedded compiler that dynamically generates of SQL queries from monad comprehensions, which are then executed on an arbitrary ODBC database server.},
1325         booktitle = {Proceedings of the 2nd {Conference} on {Domain}-{Specific} {Languages}},
1326         publisher = {ACM},
1327         author = {Leijen, Daan and Meijer, Erik},
1328         year = {2000},
1329         note = {event-place: Austin, Texas, USA},
1330         pages = {109--122},
1331         file = {Leijen and Meijer - 2000 - Domain Specific Embedded Compilers.pdf:/home/mrl/.local/share/zotero/storage/YHPF2VZ6/Leijen and Meijer - 2000 - Domain Specific Embedded Compilers.pdf:application/pdf},
1332 }
1333
1334 @techreport{plasmeijer_clean_2021,
1335         address = {Nijmegen},
1336         title = {Clean {Language} {Report} version 3.1},
1337         urldate = {2021-12-22},
1338         institution = {Institute for Computing and Information Sciences},
1339         author = {Plasmeijer, Rinus and van Eekelen, Marko and van Groningen, John},
1340         month = dec,
1341         year = {2021},
1342         pages = {127},
1343         file = {CleanLanguageReport.pdf:/home/mrl/.local/share/zotero/storage/I2SDRIH6/CleanLanguageReport.pdf:application/pdf},
1344 }
1345
1346 @incollection{kiselyov_typed_2012,
1347         address = {Berlin, Heidelberg},
1348         title = {Typed {Tagless} {Final} {Interpreters}},
1349         isbn = {978-3-642-32202-0},
1350         abstract = {The so-called `typed tagless final' approach of [6] has collected and polished a number of techniques for representing typed higher-order languages in a typed metalanguage, along with type-preserving interpretation, compilation and partial evaluation. The approach is an alternative to the traditional, or `initial' encoding of an object language as a (generalized) algebraic data type. Both approaches permit multiple interpretations of an expression, to evaluate it, pretty-print, etc. The final encoding represents all and only typed object terms without resorting to generalized algebraic data types, dependent or other fancy types. The final encoding lets us add new language forms and interpretations without breaking the existing terms and interpreters.},
1351         booktitle = {Generic and {Indexed} {Programming}: {International} {Spring} {School}, {SSGIP} 2010, {Oxford}, {UK}, {March} 22-26, 2010, {Revised} {Lectures}},
1352         publisher = {Springer Berlin Heidelberg},
1353         author = {Kiselyov, Oleg},
1354         editor = {Gibbons, Jeremy},
1355         year = {2012},
1356         doi = {10.1007/978-3-642-32202-0_3},
1357         pages = {130--174},
1358         file = {Kiselyov - 2012 - Typed Tagless Final Interpreters.pdf:/home/mrl/.local/share/zotero/storage/9NBYZLRP/Kiselyov - 2012 - Typed Tagless Final Interpreters.pdf:application/pdf},
1359 }
1360
1361 @inproceedings{nocker_concurrent_1991,
1362         address = {Berlin, Heidelberg},
1363         title = {Concurrent clean},
1364         isbn = {978-3-540-47472-2},
1365         abstract = {Concurrent Clean is an experimental, lazy, higher-order parallel functional programming language based on term graph rewriting. An important difference with other languages is that in Clean graphs are manipulated and not terms. This can be used by the programmer to control communication and sharing of computation. Cyclic structures can be defined. Concurrent Clean furthermore allows to control the (parallel) order of evaluation to make efficient evaluation possible. With help of sequential annotations the default lazy evaluation can be locally changed into eager evaluation. The language enables the definition of partially strict data structures which make a whole new class of algorithms feasible in a functional language. A powerful and fast strictness analyser is incorporated in the system. The quality of the code generated by the Clean compiler has been greatly improved such that it is one of the best code generators for a lazy functional language. Two very powerful parallel annotations enable the programmer to define concurrent functional programs with arbitrary process topologies. Concurrent Clean is set up in such a way that the efficiency achieved for the sequential case can largely be maintained for a parallel implementation on loosely coupled parallel machine architectures.},
1366         booktitle = {{PARLE} '91 {Parallel} {Architectures} and {Languages} {Europe}},
1367         publisher = {Springer Berlin Heidelberg},
1368         author = {Nöcker, E. G. J. M. H. and Smetsers, J. E. W. and van Eekelen, M. C. J. D. and Plasmeijer, M. J.},
1369         editor = {Aarts, Emile H. L. and van Leeuwen, Jan and Rem, Martin},
1370         year = {1991},
1371         pages = {202--219},
1372         file = {Nöcker et al. - 1991 - Concurrent clean.pdf:/home/mrl/.local/share/zotero/storage/XHTNR7BR/Nöcker et al. - 1991 - Concurrent clean.pdf:application/pdf},
1373 }
1374
1375 @inproceedings{staps_lazy_2019,
1376         address = {New York, NY, USA},
1377         series = {{IFL} '19},
1378         title = {Lazy {Interworking} of {Compiled} and {Interpreted} {Code} for {Sandboxing} and {Distributed} {Systems}},
1379         isbn = {978-1-4503-7562-7},
1380         doi = {10.1145/3412932.3412941},
1381         abstract = {More and more applications rely on the safe execution of code unknown at compile-time, for example in the implementation of web browsers and plugin systems. Furthermore, these applications usually require some form of communication between the added code and its embedder, and hence a communication channel must be set up in which values are serialized and deserialized. This paper shows that in a functional programming language we can solve these two problems at once, if we realize that the execution of extra code is nothing more than the deserialization of a value which happens to be a function. To demonstrate this, we describe the implementation of a serialization library for the language Clean, which internally uses an interpreter to evaluate added code in a separate, sandboxed environment. Remarkable is that despite the conceptual asymmetry between "host" and "interpreter", lazy interworking must be implemented in a highly symmetric fashion, much akin to distributed systems. The library interworks on a low level with the native Clean program, but has been implemented without any changes to the native runtime system. It can therefore easily be ported to other programming languages.We can use the same technique in the context of the web, where we want to be able to share possibly lazy values between a server and a client. In this case the interpreter runs in WebAssembly in the browser and communicates seamlessly with the server, written in Clean. We use this in the iTasks web framework to handle communication and offload computations to the client to reduce stress on the server-side. Previously, this framework cross-compiled the Clean source code to JavaScript and used JSON for communication. The interpreter has a more predictable and better performance, and integration is much simpler because it interworks on a lower level with the web server.},
1382         booktitle = {Proceedings of the 31st {Symposium} on {Implementation} and {Application} of {Functional} {Languages}},
1383         publisher = {ACM},
1384         author = {Staps, Camil and van Groningen, John and Plasmeijer, Rinus},
1385         year = {2019},
1386         note = {event-place: Singapore, Singapore},
1387         keywords = {functional programming, interpreters, laziness, sandboxing, web-assembly},
1388         file = {Staps et al. - 2019 - Lazy Interworking of Compiled and Interpreted Code.pdf:/home/mrl/.local/share/zotero/storage/LGS69CH8/Staps et al. - 2019 - Lazy Interworking of Compiled and Interpreted Code.pdf:application/pdf},
1389 }
1390
1391 @incollection{mernik_extensible_2013,
1392         address = {Hershey, PA, USA},
1393         title = {Extensible {Languages}: {Blurring} the {Distinction} between {DSL} and {GPL}},
1394         isbn = {978-1-4666-2092-6},
1395         abstract = {Out of a concern for focus and concision, domain-specific languages (DSLs) are usually very different from general purpose programming languages (GPLs), both at the syntactic and the semantic levels. One approach to DSL implementation is to write a full language infrastructure, including parser, interpreter, or even compiler. Another approach however, is to ground the DSL into an extensible GPL, giving you control over its own syntax and semantics. The DSL may then be designed merely as an extension to the original GPL, and its implementation may boil down to expressing only the differences with it. The task of DSL implementation is hence considerably eased. The purpose of this chapter is to provide a tour of the features that make a GPL extensible, and to demonstrate how, in this context, the distinction between DSL and GPL can blur, sometimes to the point of complete disappearance.},
1396         booktitle = {Formal and {Practical} {Aspects} of {Domain}-{Specific} {Languages}: {Recent} {Developments}},
1397         publisher = {IGI Global},
1398         author = {Verna, Didier},
1399         editor = {Mernik, Marjan},
1400         year = {2013},
1401         doi = {10.4018/978-1-4666-2092-6.ch001},
1402         pages = {1--31},
1403 }
1404
1405 @inproceedings{hudak_modular_1998,
1406         title = {Modular domain specific languages and tools},
1407         doi = {10.1109/ICSR.1998.685738},
1408         booktitle = {Proceedings. {Fifth} {International} {Conference} on {Software} {Reuse} ({Cat}. {No}.{98TB100203})},
1409         author = {Hudak, P.},
1410         year = {1998},
1411         pages = {134--142},
1412         file = {Hudak - 1998 - Modular domain specific languages and tools.pdf:/home/mrl/.local/share/zotero/storage/JX7KZ2ST/Hudak - 1998 - Modular domain specific languages and tools.pdf:application/pdf},
1413 }
1414
1415 @book{fowler_domain_2010,
1416         edition = {1st},
1417         title = {Domain {Specific} {Languages}},
1418         isbn = {0-321-71294-3},
1419         abstract = {Designed as a wide-ranging guide to Domain Specific Languages (DSLs) and how to approach building them, this book covers a variety of different techniques available for DSLs. The goal is to provide readers with enough information to make an informed choice about whether or not to use a DSL and what kinds of DSL techniques to employ. Part I is a 150-page narrative overview that gives you a broad understanding of general principles. The reference material in Parts II through VI provides the details and examples you willneed to get started using the various techniques discussed. Both internal and external DSL topics are covered, in addition to alternative computational models and code generation. Although the general principles and patterns presented can be used with whatever programming language you happen to be using, most of the examples are in Java or C\#.},
1420         publisher = {Addison-Wesley Professional},
1421         author = {Fowler, Martin},
1422         year = {2010},
1423         file = {Fowler - 2010 - Domain-specific languages.pdf:/home/mrl/.local/share/zotero/storage/YYMYXTZ5/Fowler - 2010 - Domain-specific languages.pdf:application/pdf},
1424 }
1425
1426 @misc{lewis_speech_1985,
1427         address = {Washington, D.C.},
1428         type = {Speech},
1429         title = {Speech},
1430         url = {http://www.chetansharma.com/correcting-the-iot-history/},
1431         author = {Lewis, Peter T.},
1432         month = sep,
1433         year = {1985},
1434 }
1435
1436 @article{weiser_computer_1991,
1437         title = {The {Computer} for the 21 st {Century}},
1438         volume = {265},
1439         language = {en},
1440         number = {3},
1441         journal = {Scientific American},
1442         author = {Weiser, Mark},
1443         month = sep,
1444         year = {1991},
1445         pages = {94--105},
1446         file = {Weiser - 1991 - The Computer for the 21 st Century.pdf:/home/mrl/.local/share/zotero/storage/N5456M2M/Weiser - 1991 - The Computer for the 21 st Century.pdf:application/pdf},
1447 }
1448
1449 @misc{evans_internet_2011,
1450         title = {The {Internet} of {Things}: {How} the {Next} {Evolution} of the {Internet} {Is} {Changing} {Everything}},
1451         url = {https://www.cisco.com/c/dam/en_us/about/ac79/docs/innov/IoT_IBSG_0411FINAL.pdf},
1452         language = {en},
1453         publisher = {Cisco Internet Business Solutions Group (IBSG)},
1454         author = {Evans, Dave},
1455         month = apr,
1456         year = {2011},
1457         file = {Evans - 2011 - How the Next Evolution of the Internet Is Changing.pdf:/home/mrl/.local/share/zotero/storage/32YXCM6P/Evans - 2011 - How the Next Evolution of the Internet Is Changing.pdf:application/pdf},
1458 }
1459
1460 @inproceedings{ireland_classification_2009,
1461         address = {Cancun, Mexico},
1462         title = {A {Classification} of {Object}-{Relational} {Impedance} {Mismatch}},
1463         isbn = {978-0-7695-3550-0},
1464         doi = {10.1109/DBKDA.2009.11},
1465         booktitle = {First {International} {Conference} on {Advances} in {Databases}, {Knowledge}, and {Data} {Applications}},
1466         publisher = {IEEE},
1467         author = {Ireland, Christopher and Bowers, David and Newton, Michael and Waugh, Kevin},
1468         year = {2009},
1469         pages = {36--43},
1470 }
1471
1472 @inproceedings{steenvoorden_tophat_2019,
1473         address = {New York, NY, USA},
1474         series = {{PPDP} '19},
1475         title = {{TopHat}: {A} {Formal} {Foundation} for {Task}-{Oriented} {Programming}},
1476         isbn = {978-1-4503-7249-7},
1477         doi = {10.1145/3354166.3354182},
1478         abstract = {Software that models how people work is omnipresent in today's society. Current languages and frameworks often focus on usability by non-programmers, sacrificing flexibility and high level abstraction. Task-oriented programming (TOP) is a programming paradigm that aims to provide the desired level of abstraction while still being expressive enough to describe real world collaboration. It prescribes a declarative programming style to specify multi-user workflows. Workflows can be higher-order. They communicate through typed values on a local and global level. Such specifications can be turned into interactive applications for different platforms, supporting collaboration during execution. TOP has been around for more than a decade, in the forms of iTasks and mTasks, which are tailored for real-world usability. So far, it has not been given a formalisation which is suitable for formal reasoning.In this paper we give a description of the TOP paradigm and then decompose its rich features into elementary language elements, which makes them suitable for formal treatment. We use the simply typed lambda-calculus, extended with pairs and references, as a base language. On top of this language, we develop TopHat, a language for modular interactive workflows. We describe TopHat by means of a layered semantics. These layers consist of multiple big-step evaluations on expressions, and two labelled transition systems, handling user inputs.With TopHat we prepare a way to formally reason about TOP languages and programs. This approach allows for comparison with other work in the field. We have implemented the semantic rules of TopHat in Haskell, and the task layer on top of the iTasks framework. This shows that our approach is feasible, and lets us demonstrate the concepts by means of illustrative case studies. TOP has been applied in projects with the Dutch coast guard, tax office, and navy. Our work matters because formal program verification is important for mission-critical software, especially for systems with concurrency.},
1479         booktitle = {Proceedings of the 21st {International} {Symposium} on {Principles} and {Practice} of {Declarative} {Programming}},
1480         publisher = {ACM},
1481         author = {Steenvoorden, Tim and Naus, Nico and Klinik, Markus},
1482         year = {2019},
1483         note = {event-place: Porto, Portugal},
1484         file = {Steenvoorden et al. - 2019 - TopHat A Formal Foundation for Task-Oriented Prog.pdf:/home/mrl/.local/share/zotero/storage/E9W4WKZC/Steenvoorden et al. - 2019 - TopHat A Formal Foundation for Task-Oriented Prog.pdf:application/pdf},
1485 }
1486
1487 @incollection{koopman_type-safe_2019,
1488         address = {Cham},
1489         title = {Type-{Safe} {Functions} and {Tasks} in a {Shallow} {Embedded} {DSL} for {Microprocessors}},
1490         isbn = {978-3-030-28346-9},
1491         abstract = {The Internet of Things, IoT, brings us large amounts of connected computing devices that are equipped with dedicated sensors and actuators. These computing devices are typically driven by a cheap microprocessor system with a relatively slow processor and a very limited amount of memory. Due to the special input-output capabilities of IoT devices and their connections it is very attractive to execute (parts of) programs on these microcomputers.},
1492         booktitle = {Central {European} {Functional} {Programming} {School}: 6th {Summer} {School}, {CEFP} 2015, {Budapest}, {Hungary}, {July} 6–10, 2015, {Revised} {Selected} {Papers}},
1493         publisher = {Springer International Publishing},
1494         author = {Koopman, Pieter and Plasmeijer, Rinus},
1495         editor = {Zsók, Viktória and Porkoláb, Zoltán and Horváth, Zoltán},
1496         year = {2019},
1497         doi = {10.1007/978-3-030-28346-9_8},
1498         pages = {283--340},
1499         file = {Koopman and Plasmeijer - 2019 - Type-Safe Functions and Tasks in a Shallow Embedde.pdf:/home/mrl/.local/share/zotero/storage/UY2DY4EJ/Koopman and Plasmeijer - 2019 - Type-Safe Functions and Tasks in a Shallow Embedde.pdf:application/pdf},
1500 }
1501
1502 @techreport{cheney_first-class_2003,
1503         title = {First-class phantom types},
1504         url = {https://ecommons.cornell.edu/handle/1813/5614},
1505         number = {TR2003-1901},
1506         urldate = {2017-05-15},
1507         institution = {Cornell University},
1508         author = {Cheney, James and Hinze, Ralf},
1509         year = {2003},
1510         file = {Cheney and Hinze - 2003 - First-class phantom types.pdf:/home/mrl/.local/share/zotero/storage/IBKGCFG2/Cheney and Hinze - 2003 - First-class phantom types.pdf:application/pdf},
1511 }
1512
1513 @article{mitchell_abstract_1988,
1514         title = {Abstract {Types} {Have} {Existential} {Type}},
1515         volume = {10},
1516         issn = {0164-0925},
1517         doi = {10.1145/44501.45065},
1518         abstract = {Abstract data type declarations appear in typed programming languages like Ada, Alphard, CLU and ML. This form of declaration binds a list of identifiers to a type with associated operations, a composite “value” we call a data algebra. We use a second-order typed lambda calculus SOL to show how data algebras may be given types, passed as parameters, and returned as results of function calls. In the process, we discuss the semantics of abstract data type declarations and review a connection between typed programming languages and constructive logic.},
1519         number = {3},
1520         journal = {ACM Trans. Program. Lang. Syst.},
1521         author = {Mitchell, John C. and Plotkin, Gordon D.},
1522         month = jul,
1523         year = {1988},
1524         note = {Place: New York, NY, USA
1525 Publisher: Association for Computing Machinery},
1526         pages = {470--502},
1527         file = {Mitchell and Plotkin - 1988 - Abstract types have existential type.pdf:/home/mrl/.local/share/zotero/storage/QXDE5H7C/Mitchell and Plotkin - 1988 - Abstract types have existential type.pdf:application/pdf},
1528 }
1529
1530 @inproceedings{baars_typing_2002,
1531         address = {New York, NY, USA},
1532         series = {{ICFP} '02},
1533         title = {Typing {Dynamic} {Typing}},
1534         isbn = {1-58113-487-8},
1535         doi = {10.1145/581478.581494},
1536         abstract = {Even when programming in a statically typed language we every now and then encounter statically untypable values; such values result from interpreting values or from communicating with the outside world. To cope with this problem most languages include some form of dynamic types. It may be that the core language has been explicitly extended with such a type, or that one is allowed to live dangerously by using functions like unsafeCoerce. We show how, by a careful use of existentially and universally quantified types, one may achievem the same effect, without extending the language with new or unsafe features. The techniques explained are universally applicable, provided the core language is expressive enough; this is the case for the common implementations of Haskell. The techniques are used in the description of a type checking compiler that, starting from an expression term, constructs a typed function representing the semantics of that expression. In this function the overhead associated with the type checking is only once being paid for; in this sense we have thus achieved static type checking.},
1537         booktitle = {Proceedings of the {Seventh} {ACM} {SIGPLAN} {International} {Conference} on {Functional} {Programming}},
1538         publisher = {ACM},
1539         author = {Baars, Arthur I. and Swierstra, S. Doaitse},
1540         year = {2002},
1541         note = {event-place: Pittsburgh, PA, USA},
1542         keywords = {coercions, dynamic typing, Haskell, Leibnitz' rule, quantified types, static typing, type equality, typed interpreters},
1543         pages = {157--166},
1544         file = {Baars and Swierstra - 2002 - Typing dynamic typing.pdf:/home/mrl/.local/share/zotero/storage/QSGVSTM4/Baars and Swierstra - 2002 - Typing dynamic typing.pdf:application/pdf},
1545 }
1546
1547 @inproceedings{young_adding_2021,
1548         address = {Berlin, Heidelberg},
1549         title = {On {Adding} {Pattern} {Matching} to {Haskell}-{Based} {Deeply} {Embedded} {Domain} {Specific} {Languages}},
1550         isbn = {978-3-030-67437-3},
1551         doi = {10.1007/978-3-030-67438-0_2},
1552         abstract = {Capturing control flow is the Achilles heel of Haskell-based deeply embedded domain specific languages. Rather than use the builtin control flow mechanisms, artificial control flow combinators are used instead. However, capturing traditional control flow in a deeply embedded domain specific language would support the writing of programs in a natural style by allowing the programmer to use the constructs that are already builtin to the base language, such as pattern matching and recursion. In this paper, we expand the capabilities of Haskell-based deep embeddings with a compiler extension for reifying conditionals and pattern matching. With this new support, the subset of Haskell that we use for expressing deeply embedded domain specific languages can be cleaner, Haskell-idiomatic, and more declarative in nature.},
1553         booktitle = {Practical {Aspects} of {Declarative} {Languages}: 23rd {International} {Symposium}, {PADL} 2021, {Copenhagen}, {Denmark}, {January} 18-19, 2021, {Proceedings}},
1554         publisher = {Springer-Verlag},
1555         author = {Young, David and Grebe, Mark and Gill, Andy},
1556         year = {2021},
1557         note = {event-place: Copenhagen, Denmark},
1558         pages = {20--36},
1559         file = {Young et al. - 2021 - On Adding Pattern Matching to Haskell-Based Deeply.pdf:/home/mrl/.local/share/zotero/storage/XRYWKWPT/Young et al. - 2021 - On Adding Pattern Matching to Haskell-Based Deeply.pdf:application/pdf},
1560 }
1561
1562 @incollection{hinze_generic_2003,
1563         address = {Berlin, Heidelberg},
1564         title = {Generic {Haskell}: {Practice} and {Theory}},
1565         isbn = {978-3-540-45191-4},
1566         abstract = {Generic Haskell is an extension of Haskell that supports the construction of generic programs. These lecture notes describe the basic constructs of Generic Haskell and highlight the underlying theory.},
1567         booktitle = {Generic {Programming}: {Advanced} {Lectures}},
1568         publisher = {Springer Berlin Heidelberg},
1569         author = {Hinze, Ralf and Jeuring, Johan},
1570         editor = {Backhouse, Roland and Gibbons, Jeremy},
1571         year = {2003},
1572         doi = {10.1007/978-3-540-45191-4_1},
1573         pages = {1--56},
1574         file = {Hinze and Jeuring - Generic Haskell practice and theory.pdf:/home/mrl/.local/share/zotero/storage/QDRNI5VB/Hinze and Jeuring - Generic Haskell practice and theory.pdf:application/pdf},
1575 }
1576
1577 @article{alhirabi_security_2021,
1578         title = {Security and {Privacy} {Requirements} for the {Internet} of {Things}: {A} {Survey}},
1579         volume = {2},
1580         issn = {2691-1914},
1581         doi = {10.1145/3437537},
1582         abstract = {The design and development process for internet of things (IoT) applications is more complicated than that for desktop, mobile, or web applications. First, IoT applications require both software and hardware to work together across many different types of nodes with different capabilities under different conditions. Second, IoT application development involves different types of software engineers such as desktop, web, embedded, and mobile to work together. Furthermore, non-software engineering personnel such as business analysts are also involved in the design process. In addition to the complexity of having multiple software engineering specialists cooperating to merge different hardware and software components together, the development process requires different software and hardware stacks to be integrated together (e.g., different stacks from different companies such as Microsoft Azure and IBM Bluemix). Due to the above complexities, non-functional requirements (such as security and privacy, which are highly important in the context of the IoT) tend to be ignored or treated as though they are less important in the IoT application development process. This article reviews techniques, methods, and tools to support security and privacy requirements in existing non-IoT application designs, enabling their use and integration into IoT applications. This article primarily focuses on design notations, models, and languages that facilitate capturing non-functional requirements (i.e., security and privacy). Our goal is not only to analyse, compare, and consolidate the empirical research but also to appreciate their findings and discuss their applicability for the IoT.},
1583         number = {1},
1584         journal = {ACM Trans. Internet Things},
1585         author = {Alhirabi, Nada and Rana, Omer and Perera, Charith},
1586         month = feb,
1587         year = {2021},
1588         note = {Place: New York, NY, USA
1589 Publisher: Association for Computing Machinery},
1590         keywords = {Internet of Things, design principles, non functional requirements, notation, software design tools, software engineering},
1591         file = {Alhirabi et al. - 2021 - Security and Privacy Requirements for the Internet.pdf:/home/mrl/.local/share/zotero/storage/7UN4IF62/Alhirabi et al. - 2021 - Security and Privacy Requirements for the Internet.pdf:text/html},
1592 }
1593
1594 @inproceedings{torrano_strictness_2005,
1595         address = {Bristol, UK},
1596         series = {Trends in {Functional} {Programming}},
1597         title = {Strictness {Analysis} and let-to-case {Transformation} using {Template} {Haskell}},
1598         volume = {6},
1599         isbn = {978-1-84150-176-5},
1600         booktitle = {Revised {Selected} {Papers} from the {Sixth} {Symposium} on {Trends} in {Functional} {Programming}, {TFP} 2005, {Tallinn}, {Estonia}, 23-24 {September} 2005},
1601         publisher = {Intellect},
1602         author = {Torrano, Carmen and Segura, Clara},
1603         editor = {Eekelen, Marko C. J. D. van},
1604         year = {2005},
1605         note = {event-place: Talinn, Estonia},
1606         pages = {429--442},
1607         file = {Torrano and Segura - Strictness Analysis and let-to-case Transformation.pdf:/home/mrl/.local/share/zotero/storage/RIYW9WFT/Torrano and Segura - Strictness Analysis and let-to-case Transformation.pdf:application/pdf},
1608 }
1609
1610 @inproceedings{polak_automatic_2006,
1611         address = {Bristol, UK},
1612         series = {Trends in {Functional} {Programming}},
1613         title = {Automatic {Graphical} {User} {Interface} {Form} {Generation} {Using} {Template} {Haskell}},
1614         volume = {7},
1615         isbn = {978-1-84150-188-8},
1616         booktitle = {Revised {Selected} {Papers} from the {Seventh} {Symposium} on {Trends} in {Functional} {Programming}, {TFP} 2006, {Nottingham}, {United} {Kingdom}, 19-21 {April} 2006},
1617         publisher = {Intellect},
1618         author = {Polak, Gracjan and Jarosz, Janusz},
1619         editor = {Nilsson, Henrik},
1620         year = {2006},
1621         note = {event-place: Nottingham, UK},
1622         pages = {1--11},
1623         file = {Polak and Jarosz - Automatic Graphical User Interface Form Generation.pdf:/home/mrl/.local/share/zotero/storage/8VK3D8JQ/Polak and Jarosz - Automatic Graphical User Interface Form Generation.pdf:application/pdf},
1624 }
1625
1626 @inproceedings{koopman_executable_2011,
1627         address = {Berlin, Heidelberg},
1628         title = {An {Executable} and {Testable} {Semantics} for {iTasks}},
1629         isbn = {978-3-642-24452-0},
1630         abstract = {The iTask system is an easy to use combinator library for specifying dynamic data dependent workflows in a very flexible way. The specified workflows are executed as a multi-user web-application. The implementation of the iTask system is fairly complicated. Hence we cannot use it for reasoning about the semantics of workflows in the iTask system. In this paper we define an executable semantics that specifies how workflows react on events generated by the workers executing them. The semantics is used to explain iTask and to reason about iTask. Based on this semantics we define a mathematical notion of equivalence of tasks and show how this equivalence for tasks can be approximated automatically. Advantages of this executable semantics are: it is easy to validate the semantics by interactive simulation; properties of the semantics can be tested by our model-based test system Gþinspace∀þinspacest. Gþinspace∀þinspacest can test a large number of properties within seconds. These tests appeared to be a good indication about the consistency of the specified semantics and equivalence relation for tasks. The automatic testing of properties was very helpful in the development of the semantics. The contribution of this paper is a semantics for iTask as well as the method used to construct this operational semantics.},
1631         booktitle = {Implementation and {Application} of {Functional} {Languages}},
1632         publisher = {Springer Berlin Heidelberg},
1633         author = {Koopman, Pieter and Plasmeijer, Rinus and Achten, Peter},
1634         editor = {Scholz, Sven-Bodo and Chitil, Olaf},
1635         year = {2011},
1636         pages = {212--232},
1637         file = {Koopman et al. - 2011 - An Executable and Testable Semantics for iTasks.pdf:/home/mrl/.local/share/zotero/storage/6LFA9MNU/Koopman et al. - 2011 - An Executable and Testable Semantics for iTasks.pdf:application/pdf},
1638 }
1639
1640 @phdthesis{antonova_mtask_2022,
1641         address = {Nijmegen},
1642         type = {Bachelor's {Thesis}},
1643         title = {{mTask} {Semantics} and its {Comparison} to {TopHat}},
1644         language = {en},
1645         school = {Radboud University},
1646         author = {Antonova, Elina},
1647         year = {2022},
1648         file = {Crooijmans - 2021 - Reducing the Power Consumption of IoT Devices in T.pdf:/home/mrl/.local/share/zotero/storage/YIEQ97KK/Crooijmans - 2021 - Reducing the Power Consumption of IoT Devices in T.pdf:application/pdf},
1649 }
1650
1651 @inproceedings{lijnse_capturing_2011,
1652         address = {Lisbon, Portugal},
1653         title = {Capturing the {Netherlands} {Coast} {Guard}'s {SAR} {Workflow} with {iTasks}},
1654         language = {en},
1655         booktitle = {Proceedings of the 8th {International} {ISCRAM} {Conference}},
1656         author = {Lijnse, Bas and Nanne, Ruud and Jansen, Jan Martin and Plasmeijer, Rinus},
1657         year = {2011},
1658         pages = {10},
1659         file = {Lijnse et al. - 2011 - Capturing the Netherlands Coast Guard's SAR Workfl.pdf:/home/mrl/.local/share/zotero/storage/46DHR55I/Lijnse et al. - 2011 - Capturing the Netherlands Coast Guard's SAR Workfl.pdf:application/pdf},
1660 }
1661
1662 @misc{wadler_expression_1998,
1663         title = {The expression problem},
1664         url = {https://homepages.inf.ed.ac.uk/wadler/papers/expression/expression.txt},
1665         language = {en},
1666         urldate = {2021-02-24},
1667         author = {Wadler, Philip},
1668         month = nov,
1669         year = {1998},
1670         note = {e-mail message, accessed on 2021-02-24},
1671 }
1672
1673 @misc{margaret_deuter_rhapsody_2015,
1674         address = {Oxford},
1675         edition = {Ninth edition},
1676         title = {Rhapsody},
1677         journal = {Oxford Advanced Learner's Dictionary of Current English},
1678         publisher = {Oxford University Press},
1679         author = {{A S Hornby}},
1680         editor = {{Margaret Deuter} and {Jennifer Bradbery} and {Joanna Turnbull}},
1681         year = {2015},
1682 }
1683
1684 @misc{wikipedia_contributors_rhapsody_2022,
1685         title = {Rhapsody (music) — {Wikipedia}, {The} {Free} {Encyclopedia}},
1686         url = {https://en.wikipedia.org/w/index.php?title=Rhapsody_(music)\&oldid=1068385257},
1687         urldate = {2022-09-06},
1688         journal = {Wikipedia},
1689         author = {{Wikipedia contributors}},
1690         year = {2022},
1691         note = {accessed on: 2022-09-06},
1692 }
1693
1694 @incollection{backus_introduction_1990,
1695         address = {USA},
1696         title = {An {Introduction} to the {Programming} {Language} {FL}},
1697         isbn = {0-201-17236-4},
1698         booktitle = {Research {Topics} in {Functional} {Programming}},
1699         publisher = {Addison-Wesley Longman Publishing Co., Inc.},
1700         author = {Backus, John and Williams, John H. and Wimmers, Edward L.},
1701         year = {1990},
1702         pages = {219--247},
1703 }
1704
1705 @article{achten_ins_1995,
1706         title = {The ins and outs of {Clean} {I}/{O}},
1707         volume = {5},
1708         doi = {10.1017/S0956796800001258},
1709         number = {1},
1710         journal = {Journal of Functional Programming},
1711         author = {Achten, Peter and Plasmeijer, Rinus},
1712         year = {1995},
1713         note = {Publisher: Cambridge University Press},
1714         pages = {81--110},
1715 }
1716
1717 @inproceedings{peyton_jones_imperative_1993,
1718         address = {New York, NY, USA},
1719         series = {{POPL} '93},
1720         title = {Imperative {Functional} {Programming}},
1721         isbn = {0-89791-560-7},
1722         doi = {10.1145/158511.158524},
1723         abstract = {We present a new model, based on monads, for performing input/output in a non-strict, purely functional language. It is composable, extensible, efficient, requires no extensions to the type system, and extends smoothly to incorporate mixed-language working and in-place array updates.},
1724         booktitle = {Proceedings of the 20th {ACM} {SIGPLAN}-{SIGACT} {Symposium} on {Principles} of {Programming} {Languages}},
1725         publisher = {ACM},
1726         author = {Peyton Jones, Simon and Wadler, Philip},
1727         year = {1993},
1728         note = {event-place: Charleston, South Carolina, USA},
1729         pages = {71--84},
1730         file = {Peyton Jones and Wadler - 1993 - Imperative Functional Programming.pdf:/home/mrl/.local/share/zotero/storage/9DQ5V3N3/Peyton Jones and Wadler - 1993 - Imperative Functional Programming.pdf:application/pdf},
1731 }
1732
1733 @inproceedings{achten_high_1993,
1734         address = {London},
1735         title = {High {Level} {Specification} of {I}/{O} in {Functional} {Languages}},
1736         isbn = {978-1-4471-3215-8},
1737         abstract = {The interface with the outside world has always been one of the weakest points of functional languages. It is not easy to incorporate I/O without being allowed to do side-effects. Furthermore, functional languages allow redexes to be evaluated in any order while I/O generally has to be performed in a very specific order. In this paper we present a new solution for the I/O problem which we have incorporated in the language Concurrent Clean. Concurrent Clean offers a linear type system called Unique Types. It makes it possible to define functions with side-effects without violating the functional semantics. Now it is possible to change any object in the world in the way we wanted: e.g. arrays can be updated in-situ, arbitrary file manipulation is possible. We have used this powerful tool among others to create a library for window based I/O. Using an explicit environment passing scheme provides a high-level and elegant functional specification method for I/O, called Event I/O. Now the specification of I/O has become one of the strengths of functional languages: interactive programs written in Concurrent Clean are concise, easy to write and comprehend as well as efficient. The presented solution can in principle be applied for any other functional language as well provided that it actually uses graph rewriting semantics in the implementation.},
1738         booktitle = {Functional {Programming}, {Glasgow} 1992},
1739         publisher = {Springer London},
1740         author = {Achten, Peter and van Groningen, John and Plasmeijer, Rinus},
1741         editor = {Launchbury, John and Sansom, Patrick},
1742         year = {1993},
1743         pages = {1--17},
1744         file = {Achten et al. - 1993 - High Level Specification of IO in Functional Lang.pdf:/home/mrl/.local/share/zotero/storage/4QVH7AYC/Achten et al. - 1993 - High Level Specification of IO in Functional Lang.pdf:application/pdf},
1745 }
1746
1747 @inproceedings{pickering_staged_2020,
1748         address = {New York, NY, USA},
1749         series = {Haskell 2020},
1750         title = {Staged {Sums} of {Products}},
1751         isbn = {978-1-4503-8050-8},
1752         doi = {10.1145/3406088.3409021},
1753         abstract = {Generic programming libraries have historically traded efficiency in return for convenience, and the generics-sop library is no exception. It offers a simple, uniform, representation of all datatypes precisely as a sum of products, making it easy to write generic functions. We show how to finally make generics-sop fast through the use of staging with Typed Template Haskell.},
1754         booktitle = {Proceedings of the 13th {ACM} {SIGPLAN} {International} {Symposium} on {Haskell}},
1755         publisher = {ACM},
1756         author = {Pickering, Matthew and Löh, Andres and Wu, Nicolas},
1757         year = {2020},
1758         note = {event-place: Virtual Event, USA},
1759         keywords = {generic programming, staging},
1760         pages = {122--135},
1761         file = {Pickering et al. - 2020 - Staged Sums of Products.pdf:/home/mrl/.local/share/zotero/storage/Q6ZWX4YP/Pickering et al. - 2020 - Staged Sums of Products.pdf:application/pdf},
1762 }
1763
1764 @article{xie_staging_2022,
1765         title = {Staging with {Class}: {A} {Specification} for {Typed} {Template} {Haskell}},
1766         volume = {6},
1767         doi = {10.1145/3498723},
1768         abstract = {Multi-stage programming using typed code quotation is an established technique for writing optimizing code generators with strong type-safety guarantees. Unfortunately, quotation in Haskell interacts poorly with type classes, making it difficult to write robust multi-stage programs. We study this unsound interaction and propose a resolution, staged type class constraints, which we formalize in a source calculus $\lambda$⇒ that elaborates into an explicit core calculus F. We show type soundness of both calculi, establishing that well-typed, well-staged source programs always elaborate to well-typed, well-staged core programs, and prove beta and eta rules for code quotations. Our design allows programmers to incorporate type classes into multi-stage programs with confidence. Although motivated by Haskell, it is also suitable as a foundation for other languages that support both overloading and quotation.},
1769         number = {POPL},
1770         journal = {Proc. ACM Program. Lang.},
1771         author = {Xie, Ningning and Pickering, Matthew and Löh, Andres and Wu, Nicolas and Yallop, Jeremy and Wang, Meng},
1772         month = jan,
1773         year = {2022},
1774         note = {Place: New York, NY, USA
1775 Publisher: Association for Computing Machinery},
1776         keywords = {Staging, Type Classes, Typed Template Haskell},
1777         file = {Xie et al. - 2022 - Staging with Class A Specification for Typed Temp.pdf:/home/mrl/.local/share/zotero/storage/QGDB5YHR/Xie et al. - 2022 - Staging with Class A Specification for Typed Temp.pdf:application/pdf},
1778 }
1779
1780 @article{rhiger_type-safe_2009,
1781         title = {Type-safe pattern combinators},
1782         volume = {19},
1783         doi = {10.1017/S0956796808007089},
1784         number = {2},
1785         journal = {Journal of Functional Programming},
1786         author = {Rhiger, Morten},
1787         year = {2009},
1788         note = {Publisher: Cambridge University Press},
1789         pages = {145--156},
1790         file = {RHIGER - 2009 - Type-safe pattern combinators.pdf:/home/mrl/.local/share/zotero/storage/D4N7PGBS/RHIGER - 2009 - Type-safe pattern combinators.pdf:application/pdf},
1791 }
1792
1793 @inproceedings{de_vries_true_2014,
1794         address = {New York, NY, USA},
1795         series = {{WGP} '14},
1796         title = {True {Sums} of {Products}},
1797         isbn = {978-1-4503-3042-8},
1798         doi = {10.1145/2633628.2633634},
1799         abstract = {We introduce the sum-of-products (SOP) view for datatype-generic programming (in Haskell). While many of the libraries that are commonly in use today represent datatypes as arbitrary combinations of binary sums and products, SOP reflects the structure of datatypes more faithfully: each datatype is a single n-ary sum, where each component of the sum is a single n-ary product. This representation turns out to be expressible accurately in GHC with today's extensions. The resulting list-like structure of datatypes allows for the definition of powerful high-level traversal combinators, which in turn encourage the definition of generic functions in a compositional and concise style. A major plus of the SOP view is that it allows to separate function-specific metadata from the main structural representation and recombining this information later.},
1800         booktitle = {Proceedings of the 10th {ACM} {SIGPLAN} {Workshop} on {Generic} {Programming}},
1801         publisher = {ACM},
1802         author = {de Vries, Edsko and Löh, Andres},
1803         year = {2014},
1804         note = {event-place: Gothenburg, Sweden},
1805         keywords = {lenses, datatype-generic programming, generic views, json, metadata, sums of products, universes},
1806         pages = {83--94},
1807         file = {de Vries and Löh - 2014 - True Sums of Products.pdf:/home/mrl/.local/share/zotero/storage/QHT5IPQA/de Vries and Löh - 2014 - True Sums of Products.pdf:application/pdf},
1808 }
1809
1810 @article{willis_staged_2020,
1811         title = {Staged {Selective} {Parser} {Combinators}},
1812         volume = {4},
1813         doi = {10.1145/3409002},
1814         abstract = {Parser combinators are a middle ground between the fine control of hand-rolled parsers and the high-level almost grammar-like appearance of parsers created via parser generators. They also promote a cleaner, compositional design for parsers. Historically, however, they cannot match the performance of their counterparts. This paper describes how to compile parser combinators into parsers of hand-written quality. This is done by leveraging the static information present in the grammar by representing it as a tree. However, in order to exploit this information, it will be necessary to drop support for monadic computation since this generates dynamic structure. Selective functors can help recover lost functionality in the absence of monads, and the parser tree can be partially evaluated with staging. This is implemented in a library called Parsley.},
1815         number = {ICFP},
1816         journal = {Proc. ACM Program. Lang.},
1817         author = {Willis, Jamie and Wu, Nicolas and Pickering, Matthew},
1818         month = aug,
1819         year = {2020},
1820         note = {Place: New York, NY, USA
1821 Publisher: Association for Computing Machinery},
1822         keywords = {combinators, meta-programming, parsers},
1823         file = {Willis et al. - 2020 - Staged Selective Parser Combinators.pdf:/home/mrl/.local/share/zotero/storage/RCD842QK/Willis et al. - 2020 - Staged Selective Parser Combinators.pdf:application/pdf},
1824 }
1825
1826 @inproceedings{pickering_multi-stage_2019,
1827         address = {New York, NY, USA},
1828         series = {Haskell 2019},
1829         title = {Multi-{Stage} {Programs} in {Context}},
1830         isbn = {978-1-4503-6813-1},
1831         doi = {10.1145/3331545.3342597},
1832         abstract = {Cross-stage persistence is an essential aspect of multi-stage programming that allows a value defined in one stage to be available in another. However, difficulty arises when implicit information held in types, type classes and implicit parameters needs to be persisted. Without a careful treatment of such implicit information—which are pervasive in Haskell—subtle yet avoidable bugs lurk beneath the surface. This paper demonstrates that in multi-stage programming care must be taken when representing quoted terms so that important implicit information is kept in context and not discarded. The approach is formalised with a type-system, and an implementation in GHC is presented that fixes problems of the previous incarnation.},
1833         booktitle = {Proceedings of the 12th {ACM} {SIGPLAN} {International} {Symposium} on {Haskell}},
1834         publisher = {ACM},
1835         author = {Pickering, Matthew and Wu, Nicolas and Kiss, Csongor},
1836         year = {2019},
1837         note = {event-place: Berlin, Germany},
1838         keywords = {metaprogramming, staging, implicits},
1839         pages = {71--84},
1840         file = {Pickering et al. - 2019 - Multi-Stage Programs in Context.pdf:/home/mrl/.local/share/zotero/storage/3EW7FM44/Pickering et al. - 2019 - Multi-Stage Programs in Context.pdf:application/pdf},
1841 }
1842
1843 @article{pickering_specification_2021,
1844         title = {A {Specification} for {Typed} {Template} {Haskell}},
1845         volume = {abs/2112.03653},
1846         doi = {10.48550/arXiv.2112.03653},
1847         journal = {CoRR},
1848         author = {Pickering, Matthew and Löh, Andres and Wu, Nicolas},
1849         year = {2021},
1850         note = {arXiv: 2112.03653},
1851         file = {Pickering et al. - 2021 - A Specification for Typed Template Haskell.pdf:/home/mrl/.local/share/zotero/storage/YBTN4DLK/Pickering et al. - 2021 - A Specification for Typed Template Haskell.pdf:application/pdf},
1852 }
1853
1854 @book{steenvoorden_tophat_2022,
1855         address = {Nijmegen},
1856         title = {{TopHat}: {Task}-{Oriented} {Programming} with {Style}},
1857         isbn = {978-94-6458-595-7},
1858         shorttitle = {{TopHat}: {TOP} with {Style}},
1859         language = {English},
1860         publisher = {UB Nijmegen},
1861         author = {Steenvoorden, Tim},
1862         year = {2022},
1863         file = {Steenvoorden - 2022 - TopHat Task-Oriented Programming with Style.pdf:/home/mrl/.local/share/zotero/storage/ZV8IT9J5/Steenvoorden - 2022 - TopHat Task-Oriented Programming with Style.pdf:application/pdf},
1864 }
1865
1866 @inproceedings{folmer_high-level_2022,
1867         address = {Cham},
1868         title = {High-{Level} {Synthesis} of {Digital} {Circuits} from {Template} {Haskell} and {SDF}-{AP}},
1869         isbn = {978-3-031-15074-6},
1870         abstract = {Functional languages as input specifications for HLS-tools allow to specify data dependencies but do not contain a notion of time nor execution order. In this paper, we propose a method to add this notion to the functional description using the dataflow model SDF-AP. SDF-AP consists of patterns that express consumption and production that we can use to enforce resource usage. We created an HLS-tool that can synthesize parallel hardware, both data and control path, based on the repetition, expressed in Higher-Order Functions, combined with specified SDF-AP patterns.},
1871         booktitle = {Embedded {Computer} {Systems}: {Architectures}, {Modeling}, and {Simulation}},
1872         publisher = {Springer International Publishing},
1873         author = {Folmer, H. H. and Groote, R. de and Bekooij, M. J. G.},
1874         editor = {Orailoglu, Alex and Reichenbach, Marc and Jung, Matthias},
1875         year = {2022},
1876         pages = {3--27},
1877         file = {Folmer et al. - 2022 - High-Level Synthesis of Digital Circuits from Temp.pdf:/home/mrl/.local/share/zotero/storage/5JSW6MAL/Folmer et al. - 2022 - High-Level Synthesis of Digital Circuits from Temp.pdf:application/pdf},
1878 }
1879
1880 @article{materzok_generating_2022,
1881         title = {Generating {Circuits} with {Generators}},
1882         volume = {6},
1883         doi = {10.1145/3549821},
1884         abstract = {The most widely used languages and methods used for designing digital hardware fall into two rough categories. One of them, register transfer level (RTL), requires specifying each and every component in the designed circuit. This gives the designer full control, but burdens the designer with many trivial details. The other, the high-level synthesis (HLS) method, allows the designer to abstract the details of hardware away and focus on the problem being solved. This method however cannot be used for a class of hardware design problems because the circuit's clock is also abstracted away. We present YieldFSM, a hardware description language that uses the generator abstraction to represent clock-level timing in a digital circuit. It represents a middle ground between the RTL and HLS approaches: the abstraction level is higher than in RTL, but thanks to explicit information about clock-level timing, it can be used in applications where RTL is traditionally used. We also present the YieldFSM compiler, which uses methods developed by the functional programming community – including continuation-passsing style translation and defunctionalization – to translate YieldFSM programs to Mealy machines. It is implemented using Template Haskell and the Clash functional hardware description language. We show that this approach leads to short and conceptually simple hardware descriptions.},
1885         number = {ICFP},
1886         journal = {Proc. ACM Program. Lang.},
1887         author = {Materzok, Marek},
1888         month = aug,
1889         year = {2022},
1890         note = {Place: New York, NY, USA
1891 Publisher: Association for Computing Machinery},
1892         keywords = {circuit synthesis, generators, hardware description languages},
1893         file = {Materzok - 2022 - Generating Circuits with Generators.pdf:/home/mrl/.local/share/zotero/storage/LH4Q8J73/Materzok - 2022 - Generating Circuits with Generators.pdf:application/pdf},
1894 }
1895
1896 @article{egi_embedding_2022,
1897         title = {Embedding {Non}-linear {Pattern} {Matching} with {Backtracking} for {Non}-free {Data} {Types} into {Haskell}},
1898         volume = {40},
1899         issn = {1882-7055},
1900         doi = {10.1007/s00354-022-00177-z},
1901         abstract = {Pattern matching is an important language construct for data abstraction. Many pattern-match extensions have been developed for extending the range of data types to which pattern matching is applicable. Among them, the pattern-match system proposed by Egi and Nishiwaki features practical pattern matching for non-free data types by providing a user-customizable non-linear pattern-match facility with backtracking. However, they implemented their proposal only in dynamically typed programming languages, and there were no proposals that allow programmers to benefit from both static type systems and expressive pattern matching. This paper proposes a method for implementing this pattern-match facility by meta-programming in Haskell. There are two technical challenges: (i) we need to design a set of typing rules for the pattern-match facility; (ii) we need to embed these typing rules in Haskell to make types of the pattern-match expressions inferable by the Haskell type system. We propose a set of typing rules and show that several GHC extensions, such as multi-parameter type classes, datatype promotion, GADTs, existential types, and view patterns, play essential roles for embedding these typing rules into Haskell. The implementation has already been distributed as a Haskell library miniEgison via Hackage.},
1902         number = {2},
1903         journal = {New Generation Computing},
1904         author = {Egi, Satoshi and Kawata, Akira and Kori, Mayuko and Ogawa, Hiromi},
1905         month = jul,
1906         year = {2022},
1907         pages = {481--506},
1908         file = {Egi et al. - 2022 - Embedding Non-linear Pattern Matching with Backtra.pdf:/home/mrl/.local/share/zotero/storage/PXT9L9Z4/Egi et al. - 2022 - Embedding Non-linear Pattern Matching with Backtra.pdf:application/pdf},
1909 }
1910
1911 @inproceedings{blanchette_liquid_2022,
1912         address = {New York, NY, USA},
1913         series = {Haskell 2022},
1914         title = {Liquid {Proof} {Macros}},
1915         isbn = {978-1-4503-9438-3},
1916         doi = {10.1145/3546189.3549921},
1917         abstract = {Liquid Haskell is a popular verifier for Haskell programs, leveraging the power of SMT solvers to ease users' burden of proof. However, this power does not come without a price: convincing Liquid Haskell that a program is correct often necessitates giving hints to the underlying solver, which can be a tedious and verbose process that sometimes requires intricate knowledge of Liquid Haskell's inner workings. In this paper, we present Liquid Proof Macros, an extensible metaprogramming technique and framework for simplifying the development of Liquid Haskell proofs. We describe how to leverage Template Haskell to generate Liquid Haskell proof terms, via a tactic-inspired DSL interface for more concise and user-friendly proofs, and we demonstrate the capabilities of this framework by automating a wide variety of proofs from an existing Liquid Haskell benchmark.},
1918         booktitle = {Proceedings of the 15th {ACM} {SIGPLAN} {International} {Haskell} {Symposium}},
1919         publisher = {ACM},
1920         author = {Blanchette, Henry and Vazou, Niki and Lampropoulos, Leonidas},
1921         year = {2022},
1922         note = {event-place: Ljubljana, Slovenia},
1923         keywords = {Liquid Haskell, Proof Macros, Tactics},
1924         pages = {27--38},
1925         file = {Blanchette et al. - 2022 - Liquid Proof Macros.pdf:/home/mrl/.local/share/zotero/storage/YXPCWQNI/Blanchette et al. - 2022 - Liquid Proof Macros.pdf:application/pdf},
1926 }
1927
1928 @phdthesis{baaij_digital_2015,
1929         address = {Netherlands},
1930         type = {{PhD} {Thesis}},
1931         title = {Digital circuit in {C$\lambda$aSH}: functional specifications and type-directed synthesis},
1932         abstract = {Over the last three decades, the number of transistors used in microchips has increased by three orders of magnitude, from millions to billions. The productivity of the designers, however, lags behind. Managing to implement complex algorithms, while keeping non-functional properties within desired bounds, and thoroughly verifying the design against its specification, are the main difficulties in circuit design. As a motivation for our work we make a qualitative analysis of the tools available to circuit designers. Here we see that progress has been slow, and that the same techniques have been used for over 20 years. We claim that functional languages can be used to raise the abstraction level in circuit design. Especially higher-order functional languages, where functions are first-class and can be manipulated by other functions, offer a single abstraction mechanism that can capture many design patterns. This thesis explores the idea of using the functional language Haskell directly as a hardware specification language, and move beyond the limitations of embedded languages. Additionally, we can use normal functions from existing Haskell libraries to model the behaviour of our circuits. This thesis describes the inner workings of our C$\lambda$aSH compiler, which translates the aforementioned circuit descriptions written in Haskell to low-level descriptions in VHDL. The challenge then becomes the reduction of the higher-level abstractions in the descriptions to a form where synthesis is feasible. This thesis describes a term rewrite system (with bound variables) to achieve this reduction. We prove that this term rewrite system always reduces a polymorphic, higher-order circuit description to a synthesisable variant. Even when descriptions use high-level abstractions, the C$\lambda$aSH compiler can synthesize efficient circuits. Case studies show that circuits designed in Haskell, and synthesized with the C?aSH compiler, are on par with hand-written VHDL, in both area and gate propagation delay. This thesis thus shows the merits of using a modern functional language for circuit design. The advanced type system and higher-order functions allow us to design circuits that have the desired property of being correct-by-construction. Finally, our synthesis approach enables us to derive efficient circuits from descriptions that use high-level abstractions.},
1933         language = {Undefined},
1934         school = {University of Twente},
1935         author = {Baaij, C. P. R.},
1936         month = jan,
1937         year = {2015},
1938         doi = {10.3990/1.9789036538039},
1939         note = {ISBN: 978-90-365-3803-9},
1940         keywords = {Haskell, Digital Circuits, EC Grant Agreement nr.: FP7/248465, EC Grant Agreement nr.: FP7/610686, EWI-23939, FPGA, Functional Programming, Hardware, IR-93962, Lambda calculus, METIS-308711, Rewrite Systems},
1941         file = {Baaij - 2015 - Digital circuit in C$\lambda$aSH functional specification.pdf:/home/mrl/.local/share/zotero/storage/MYJ33ISL/Baaij - 2015 - Digital circuit in C$\lambda$aSH functional specification.pdf:application/pdf},
1942 }
1943
1944 @inproceedings{mcdonell_embedded_2022,
1945         address = {New York, NY, USA},
1946         series = {Haskell 2022},
1947         title = {Embedded {Pattern} {Matching}},
1948         isbn = {978-1-4503-9438-3},
1949         doi = {10.1145/3546189.3549917},
1950         abstract = {Haskell is a popular choice for hosting deeply embedded languages. A recurring challenge for these embeddings is how to seamlessly integrate user defined algebraic data types. In particular, one important, convenient, and expressive feature for creating and inspecting data—pattern matching—is not directly available on embedded terms. We present a novel technique, embedded pattern matching, which enables a natural and user friendly embedding of user defined algebraic data types into the embedded language, and allows programmers to pattern match on terms in the embedded language in much the same way they would in the host language.},
1951         booktitle = {Proceedings of the 15th {ACM} {SIGPLAN} {International} {Haskell} {Symposium}},
1952         publisher = {ACM},
1953         author = {McDonell, Trevor L. and Meredith, Joshua D. and Keller, Gabriele},
1954         year = {2022},
1955         note = {event-place: Ljubljana, Slovenia},
1956         keywords = {Haskell, algebraic data types, embedded languages, pattern matching},
1957         pages = {123--136},
1958         file = {2108.13114.pdf:/home/mrl/.local/share/zotero/storage/AJAT8AXI/2108.13114.pdf:application/pdf},
1959 }
1960
1961 @phdthesis{krishnamurthi_linguistic_2001,
1962         address = {Houston, USA},
1963         type = {{PhD} {Thesis}},
1964         title = {Linguistic reuse},
1965         school = {Rice University},
1966         author = {Krishnamurthi, Shriram},
1967         year = {2001},
1968         file = {Krishnamurthi - 2001 - Linguistic reuse.PDF:/home/mrl/.local/share/zotero/storage/LSKHFPIS/Krishnamurthi - 2001 - Linguistic reuse.PDF:application/pdf},
1969 }
1970
1971 @misc{ashton_internet_1999,
1972         address = {London, UK},
1973         type = {Presentation},
1974         title = {Internet of {Things}},
1975         author = {Ashton, Kevin},
1976         year = {1999},
1977         note = {Presentation at Proctor \& Gamble},
1978 }
1979
1980 @article{ashton_that_2009,
1981         title = {That ‘{Internet} of {Things}’ {Thing}},
1982         volume = {22},
1983         number = {7},
1984         journal = {RFID journal},
1985         author = {Ashton, Kevin},
1986         year = {2009},
1987         note = {Publisher: Hauppauge, New York},
1988         pages = {97--114},
1989         file = {Ashton - 2009 - That ‘Internet of Things’ Thing.pdf:/home/mrl/.local/share/zotero/storage/SJ33G6VR/Ashton - 2009 - That ‘Internet of Things’ Thing.pdf:application/pdf},
1990 }
1991
1992 @phdthesis{van_gemert_task_2022,
1993         address = {Nijmegen},
1994         type = {Bachelor's {Thesis}},
1995         title = {Task {Oriented} {Programming} in {LUA}},
1996         language = {en},
1997         school = {Radboud University},
1998         author = {van Gemert, Dante},
1999         year = {2022},
2000         file = {van Gemert - 2022 - Task Oriented Programming in LUA.pdf:/home/mrl/.local/share/zotero/storage/UQHAWT83/van Gemert - 2022 - Task Oriented Programming in LUA.pdf:application/pdf},
2001 }
2002
2003 @misc{lijnse_toppyt_2022,
2004         title = {Toppyt},
2005         url = {https://gitlab.com/baslijnse/toppyt},
2006         urldate = {2022-10-07},
2007         author = {Lijnse, Bas},
2008         year = {2022},
2009 }
2010
2011 @article{kiselyov_implementing_2011,
2012         title = {Implementing {Explicit} and {Finding} {Implicit} {Sharing} in {Embedded} {DSLs}},
2013         volume = {66},
2014         doi = {10.4204/eptcs.66.11},
2015         journal = {Electronic Proceedings in Theoretical Computer Science},
2016         author = {Kiselyov, Oleg},
2017         month = sep,
2018         year = {2011},
2019         note = {Publisher: Open Publishing Association},
2020         pages = {210--225},
2021 }
2022
2023 @article{sun_compositional_2022,
2024         title = {Compositional {Embeddings} of {Domain}-{Specific} {Languages}},
2025         volume = {6},
2026         doi = {10.1145/3563294},
2027         language = {en},
2028         number = {OOPSLA2},
2029         journal = {Proc. ACM Program. Lang.},
2030         author = {Sun, Yaozhu and Dhandhania, Utkarsh and Oliveira, Bruno C. d. S.},
2031         year = {2022},
2032         pages = {34},
2033         file = {Sun and Dhandhania - Compositional Embeddings of Domain-Specific Langua.pdf:/home/mrl/.local/share/zotero/storage/Y4GADQFP/Sun and Dhandhania - Compositional Embeddings of Domain-Specific Langua.pdf:application/pdf},
2034 }
2035
2036 @misc{lubbers_htask_2022,
2037         title = {{hTask}},
2038         url = {https://gitlab.com/mlubbers/acsds},
2039         urldate = {2022-10-07},
2040         author = {Lubbers, Mart},
2041         year = {2022},
2042 }
2043
2044 @article{nizetic_internet_2020,
2045         title = {Internet of {Things} ({IoT}): {Opportunities}, issues and challenges towards a smart and sustainable future},
2046         volume = {274},
2047         issn = {0959-6526},
2048         doi = {https://doi.org/10.1016/j.jclepro.2020.122877},
2049         abstract = {The rapid development and implementation of smart and IoT (Internet of Things) based technologies have allowed for various possibilities in technological advancements for different aspects of life. The main goal of IoT technologies is to simplify processes in different fields, to ensure a better efficiency of systems (technologies or specific processes) and finally to improve life quality. Sustainability has become a key issue for population where the dynamic development of IoT technologies is bringing different useful benefits, but this fast development must be carefully monitored and evaluated from an environmental point of view to limit the presence of harmful impacts and ensure the smart utilization of limited global resources. Significant research efforts are needed in the previous sense to carefully investigate the pros and cons of IoT technologies. This review editorial is partially directed on the research contributions presented at the 4th International Conference on Smart and Sustainable Technologies held in Split and Bol, Croatia, in 2019 (SpliTech 2019) as well as on recent findings from literature. The SpliTech2019 conference was a valuable event that successfully linked different engineering professions, industrial experts and finally researchers from academia. The focus of the conference was directed towards key conference tracks such as Smart City, Energy/Environment, e-Health and Engineering Modelling. The research presented and discussed at the SpliTech2019 conference helped to understand the complex and intertwined effects of IoT technologies on societies and their potential effects on sustainability in general. Various application areas of IoT technologies were discussed as well as the progress made. Four main topical areas were discussed in the herein editorial, i.e. latest advancements in the further fields: (i) IoT technologies in Sustainable Energy and Environment, (ii) IoT enabled Smart City, (iii) E-health – Ambient assisted living systems (iv) IoT technologies in Transportation and Low Carbon Products. The main outcomes of the review introductory article contributed to the better understanding of current technological progress in IoT application areas as well as the environmental implications linked with the increased application of IoT products.},
2050         journal = {Journal of Cleaner Production},
2051         author = {Nižetić, Sandro and Šolić, Petar and González-de-Artaza, Diego López-de-Ipiña and Patrono, Luigi},
2052         year = {2020},
2053         keywords = {IoT, Energy, Environment, Smart city, SpliTech2020, Sustainability},
2054         pages = {122877},
2055 }
2056
2057 @article{shi_edge_2016,
2058         title = {Edge {Computing}: {Vision} and {Challenges}},
2059         volume = {3},
2060         doi = {10.1109/JIOT.2016.2579198},
2061         number = {5},
2062         journal = {IEEE Internet of Things Journal},
2063         author = {Shi, Weisong and Cao, Jie and Zhang, Quan and Li, Youhuizi and Xu, Lanyu},
2064         year = {2016},
2065         pages = {637--646},
2066         file = {Shi et al. - 2016 - Edge Computing Vision and Challenges.pdf:/home/mrl/.local/share/zotero/storage/3F2LDVWM/Shi et al. - 2016 - Edge Computing Vision and Challenges.pdf:application/pdf},
2067 }
2068
2069 @article{sanchez-iborra_tinyml-enabled_2020,
2070         title = {{TinyML}-{Enabled} {Frugal} {Smart} {Objects}: {Challenges} and {Opportunities}},
2071         volume = {20},
2072         doi = {10.1109/MCAS.2020.3005467},
2073         number = {3},
2074         journal = {IEEE Circuits and Systems Magazine},
2075         author = {Sanchez-Iborra, Ramon and Skarmeta, Antonio F.},
2076         year = {2020},
2077         pages = {4--18},
2078         file = {Sanchez-Iborra and Skarmeta - 2020 - TinyML-Enabled Frugal Smart Objects Challenges an.pdf:/home/mrl/.local/share/zotero/storage/G5DKVFE4/Sanchez-Iborra and Skarmeta - 2020 - TinyML-Enabled Frugal Smart Objects Challenges an.pdf:application/pdf},
2079 }
2080
2081 @inproceedings{koopman_dynamic_2021,
2082         address = {Cham},
2083         title = {Dynamic {Editors} for {Well}-{Typed} {Expressions}},
2084         isbn = {978-3-030-83978-9},
2085         abstract = {Interactive systems may require complex inputs. Domain experts prefer guidance in the construction of these inputs. An ideal system prevents errors and is flexible in the construction and changes of its input. The iTask system generates web-editors given any first-order algebraic data types. The generated web-editors are useful but have their limitations. It is not possible to combine type safety with overloaded operators and preventing unbounded or ill-typed identifiers is impossible. Using phantom types, generalized algebraic datatypes or functions solves the language problems, but they cannot be handled by the datatype generic system. Moreover, changing expressions can require re-entering large parts of the input. We present dynamic editors that can solve all those problems. The programmer specifies the elements of such an editor by functions. The system shows the applicable edit elements in a drop-down menu to the user. The dynamic editor is used recursively to create the arguments for the selected function. Dynamic editors are seamlessly integrated with the ordinary web-editors of the iTask system. The obtained editors guide the users to make correct and type-safe inputs. These editors can be very flexible as well without making strange abstract syntax trees.},
2086         booktitle = {Trends in {Functional} {Programming}},
2087         publisher = {Springer International Publishing},
2088         author = {Koopman, Pieter and Michels, Steffen and Plasmeijer, Rinus},
2089         editor = {Zsók, Viktória and Hughes, John},
2090         year = {2021},
2091         pages = {44--66},
2092         file = {978-3-030-83978-9_3.pdf:/home/mrl/.local/share/zotero/storage/6654TJL7/978-3-030-83978-9_3.pdf:application/pdf},
2093 }
2094
2095 @inproceedings{omar_hazelnut_2017,
2096         address = {New York, NY, USA},
2097         series = {{POPL} '17},
2098         title = {Hazelnut: {A} {Bidirectionally} {Typed} {Structure} {Editor} {Calculus}},
2099         isbn = {978-1-4503-4660-3},
2100         doi = {10.1145/3009837.3009900},
2101         abstract = {Structure editors allow programmers to edit the tree structure of a program directly. This can have cognitive benefits, particularly for novice and end-user programmers. It also simplifies matters for tool designers, because they do not need to contend with malformed program text. This paper introduces Hazelnut, a structure editor based on a small bidirectionally typed lambda calculus extended with holes and a cursor. Hazelnut goes one step beyond syntactic well-formedness: its edit actions operate over statically meaningful incomplete terms. Naïvely, this would force the programmer to construct terms in a rigid "outside-in" manner. To avoid this problem, the action semantics automatically places terms assigned a type that is inconsistent with the expected type inside a hole. This meaningfully defers the type consistency check until the term inside the hole is finished. Hazelnut is not intended as an end-user tool itself. Instead, it serves as a foundational account of typed structure editing. To that end, we describe how Hazelnut's rich metatheory, which we have mechanized using the Agda proof assistant, serves as a guide when we extend the calculus to include binary sum types. We also discuss various interpretations of holes, and in so doing reveal connections with gradual typing and contextual modal type theory, the Curry-Howard interpretation of contextual modal logic. Finally, we discuss how Hazelnut's semantics lends itself to implementation as an event-based functional reactive program. Our simple reference implementation is written using js\_of\_ocaml.},
2102         booktitle = {Proceedings of the 44th {ACM} {SIGPLAN} {Symposium} on {Principles} of {Programming} {Languages}},
2103         publisher = {ACM},
2104         author = {Omar, Cyrus and Voysey, Ian and Hilton, Michael and Aldrich, Jonathan and Hammer, Matthew A.},
2105         year = {2017},
2106         note = {event-place: Paris, France},
2107         keywords = {bidirectional type systems, gradual typing, mechanized metatheory, structure editors},
2108         pages = {86--99},
2109         file = {Omar et al. - 2017 - Hazelnut A Bidirectionally Typed Structure Editor.pdf:/home/mrl/.local/share/zotero/storage/4DNRBZ4H/Omar et al. - 2017 - Hazelnut A Bidirectionally Typed Structure Editor.pdf:application/pdf},
2110 }
2111
2112 @article{hester_batteries_2019,
2113         title = {Batteries {Not} {Included}},
2114         volume = {26},
2115         issn = {1528-4972},
2116         doi = {10.1145/3351474},
2117         abstract = {Getting things done amid frequent power failures, batteryless intermittent research is rethinking how we build computing systems and paving the way to a sustainable and scalable digital future. The next trillion devices might be a little weird.},
2118         number = {1},
2119         journal = {XRDS},
2120         author = {Hester, Josiah and Sorber, Jacob},
2121         month = sep,
2122         year = {2019},
2123         note = {Place: New York, NY, USA
2124 Publisher: Association for Computing Machinery},
2125         pages = {23--27},
2126         file = {Hester and Sorber - 2019 - Batteries Not Included.pdf:/home/mrl/.local/share/zotero/storage/LT53WV8K/Hester and Sorber - 2019 - Batteries Not Included.pdf:application/pdf},
2127 }
2128
2129 @incollection{management_association_evaluating_2014,
2130         address = {Hershey, PA, USA},
2131         title = {Evaluating the {Usability} of {Domain}-{Specific} {Languages}},
2132         isbn = {978-1-4666-4301-7},
2133         abstract = {Domain-Specific Languages (DSLs) can be regarded as User Interfaces (UIs) because they bridge the gap between the domain experts and the computation platforms. Usability of DSLs by domain experts is a key factor for their successful adoption. The few reports supporting improvement claims are persuasive, but mostly anecdotal. Systematic literature reviews show that evidences on the effects of the introduction of DSLs are actually very scarce. In particular, the evaluation of usability is often skipped, relaxed, or at least omitted from papers reporting the development of DSLs. The few exceptions mostly take place at the end of the development process, when fixing problems is already too expensive. A systematic approach, based on techniques for the experimental evaluation of UIs, should be used to assess suitability of new DSLs. This chapter presents a general experimental evaluation model, tailored for DSLs’ experimental evaluation, and instantiates it in several DSL’s evaluation examples.},
2134         booktitle = {Software {Design} and {Development}: {Concepts}, {Methodologies}, {Tools}, and {Applications}},
2135         publisher = {IGI Global},
2136         author = {Barišic, Ankica and Amaral, Vasco and Goulão, Miguel and Barroca, Bruno},
2137         editor = {Management Association, Information Resources},
2138         year = {2014},
2139         doi = {10.4018/978-1-4666-4301-7.ch098},
2140         pages = {2120--2141},
2141         file = {Barišic et al. - 2014 - Evaluating the Usability of Domain-Specific Langua.pdf:/home/mrl/.local/share/zotero/storage/ARTGSHZK/Barišic et al. - 2014 - Evaluating the Usability of Domain-Specific Langua.pdf:application/pdf},
2142 }
2143
2144 @article{van_der_aalst_workflow_2003,
2145         title = {Workflow {Patterns}},
2146         volume = {14},
2147         issn = {1573-7578},
2148         doi = {10.1023/A:1022883727209},
2149         abstract = {Differences in features supported by the various contemporary commercial workflow management systems point to different insights of suitability and different levels of expressive power. The challenge, which we undertake in this paper, is to systematically address workflow requirements, from basic to complex. Many of the more complex requirements identified, recur quite frequently in the analysis phases of workflow projects, however their implementation is uncertain in current products. Requirements for workflow languages are indicated through workflow patterns. In this context, patterns address business requirements in an imperative workflow style expression, but are removed from specific workflow languages. The paper describes a number of workflow patterns addressing what we believe identify comprehensive workflow functionality. These patterns provide the basis for an in-depth comparison of a number of commercially availablework flow management systems. As such, this paper can be seen as the academic response to evaluations made by prestigious consulting companies. Typically, these evaluations hardly consider the workflow modeling language and routing capabilities, and focus more on the purely technical and commercial aspects.},
2150         number = {1},
2151         journal = {Distributed and Parallel Databases},
2152         author = {van der Aalst, W.M.P. and ter Hofstede, A.H.M. and Kiepuszewski, B. and Barros, A.P.},
2153         month = jul,
2154         year = {2003},
2155         pages = {5--51},
2156         file = {van der Aalst et al. - 2003 - Workflow Patterns.pdf:/home/mrl/.local/share/zotero/storage/WXP2T4R7/van der Aalst et al. - 2003 - Workflow Patterns.pdf:application/pdf},
2157 }
2158
2159 @inproceedings{belwal_variable_2013,
2160         address = {New York, NY, USA},
2161         series = {{RACS} '13},
2162         title = {Variable {Voltage} {Scheduling} with the {Priority}-{Based} {Functional} {Reactive} {Programming} {Language}},
2163         isbn = {978-1-4503-2348-2},
2164         doi = {10.1145/2513228.2513271},
2165         abstract = {In this paper, we consider how energy consumption can be reduced in the Priority-based Functional Reactive Programming (P-FRP) execution model through the implementation of Dynamic Voltage and Frequency Scaling (DVFS), a technique for modifying circuit delays and altering the operating frequency of the CPU. Use of DVFS can have an impact on task execution time, which adversely affects the temporal guarantees required from the real-time scheduler. Most of the existing studies provide solutions which are suitable for the classical model of preemptive task scheduling. Tasks which are schedulable in the preemptive model cannot be guaranteed to be schedulable in P-FRP, since the abort-based preemptive approach often creates additional costs in terms of response times.},
2166         booktitle = {Proceedings of the 2013 {Research} in {Adaptive} and {Convergent} {Systems}},
2167         publisher = {ACM},
2168         author = {Belwal, Chaitanya and Cheng, Albert M. K. and Ras, J. and Wen, Yuanfeng},
2169         year = {2013},
2170         note = {event-place: Montreal, Quebec, Canada},
2171         keywords = {embedded system, real-time},
2172         pages = {440--445},
2173 }
2174
2175 @techreport{transforma_insights_current_2023,
2176         title = {Current {IoT} {Forecast} {Highlights}},
2177         url = {https://transformainsights.com/research/forecast/highlights},
2178         institution = {{{{{Transforma Insights}}}}},
2179         author = {{{{{Transforma Insights}}}}},
2180         month = jan,
2181         year = {2023},
2182         note = {accessed-on: 2023-01-19},
2183 }
2184
2185 @misc{top_software_viia_2023,
2186         title = {{VIIA} ({Vessel} {Information} {Integrating} {Application})},
2187         url = {https://www.top-software.nl/VIIA.html},
2188         urldate = {2023-02-06},
2189         author = {{TOP Software}},
2190         year = {2023},
2191 }
2192
2193 @article{hinze_derivable_2001,
2194         title = {Derivable {Type} {Classes}},
2195         volume = {41},
2196         issn = {1571-0661},
2197         doi = {https://doi.org/10.1016/S1571-0661(05)80542-0},
2198         abstract = {Generic programming allows you to write a function once, and use it many times at different types. A lot of good foundational work on generic programming has been done. The goal of this paper is to propose a practical way of supporting generic programming within the Haskell language, without radically changing the language or its type system. The key idea is to present generic programming as a richer language in which to write default method definitions in a class declaration. On the way, we came across a separate issue, concerning type-class overloading where higher kinds are involved. We propose a simple type-class system extension to allow the programmer to write richer contexts than is currently possible.},
2199         number = {1},
2200         journal = {Electronic Notes in Theoretical Computer Science},
2201         author = {Hinze, Ralf and Jones, Simon Peyton},
2202         year = {2001},
2203         pages = {5--35},
2204         file = {Hinze and Jones - 2001 - Derivable Type Classes.pdf:/home/mrl/.local/share/zotero/storage/33IF2HMZ/Hinze and Jones - 2001 - Derivable Type Classes.pdf:application/pdf},
2205 }