thesis.bib

   1 @inproceedings{lubbers_multitasking_2019,
   2         address = {Opatija, Croatia},
   3         title = {Multitasking on {Microcontrollers} using {Task} {Oriented} {Programming}},
   4         copyright = {All rights reserved},
   5         shorttitle = {Multitasking on {Microcontrollers} using {TOP}},
   6         doi = {10.23919/MIPRO.2019.8756711},
   7         booktitle = {2019 42nd {International} {Convention} on {Information} and {Communication} {Technology}, {Electronics} and {Microelectronics} ({MIPRO})},
   8         author = {Lubbers, M. and Koopman, P. and Plasmeijer, R.},
   9         month = may,
  10         year = {2019},
  11         pages = {1587--1592},
  12         file = {08756711.pdf:/home/mrl/.local/share/zotero/storage/4S44JZPK/08756711.pdf:application/pdf;mipro_2019_proceedings.pdf:/home/mrl/.local/share/zotero/storage/5FFJLMTG/mipro_2019_proceedings.pdf:application/pdf;03_4cows_5338.pdf:/home/mrl/.local/share/zotero/storage/3QJTF5HT/03_4cows_5338.pdf:application/pdf}
  13 }
  14
  15 @inproceedings{lubbers_task_2018,
  16         address = {Lowell, MA},
  17         title = {Task {Oriented} {Programming} and the {Internet} of {Things}},
  18         copyright = {All rights reserved},
  19         isbn = {978-1-4503-7143-8},
  20         doi = {10.1145/3310232.3310239},
  21         abstract = {In the omnipresent Internet of Things (IoT), tiny devices sense and alter the environment, process information and communicate with the world. These devices have limited amounts of processing power and memory. This imposes severe restrictions on their software and communication protocols. As a result, applications are composed of parts written in various programming languages that communicate in many different ways. This impedance mismatch hampers development and maintenance. In previous work we have shown how an IoT device can be programmed by defining an embedded Domain Specific Language (eDSL). In this paper we show how IoT tasks can be seemlessly integrated with a Task Oriented Programming (TOP) server such as iTasks. It allows the specification on a high-level of abstraction of arbitrary collaborations between human beings, large systems, and now also IoT devices. The implementation is made in three steps. First, there is an interface to connect devices dynamically to an iTasks server using various communication protocols. Next, we solve the communication problem between IoT devices and the server by porting Shared Data Sources (SDSs) from TOP. As a result, data can be shared, viewed and updated from the server or IoT device. Finally, we crack the maintenance problem by switching from generating fixed code for the IoT devices to dynamically shipping code. It makes it possible to run multiple tasks on an IoT device and to decide at runtime what tasks that should be.},
  22         language = {en},
  23         booktitle = {Proceedings of the 30th {Symposium} on the {Implementation} and {Application} of {Functional} {Programming} {Languages}},
  24         publisher = {ACM},
  25         author = {Lubbers, Mart and Koopman, Pieter and Plasmeijer, Rinus},
  26         year = {2018},
  27         pages = {83--94},
  28         file = {Lubbers et al. - 2018 - Task Oriented Programming and the Internet of Thin.pdf:/home/mrl/.local/share/zotero/storage/3E5KLI5V/Lubbers et al. - 2018 - Task Oriented Programming and the Internet of Thin.pdf:application/pdf}
  29 }
  30
  31 @mastersthesis{lubbers_task_2017,
  32         address = {Nijmegen},
  33         title = {Task {Oriented} {Programming} and the {Internet} of {Things}},
  34         copyright = {All rights reserved},
  35         shorttitle = {{TOP} and the {IoT}},
  36         school = {Radboud University},
  37         author = {Lubbers, Mart},
  38         year = {2017},
  39         file = {thesis.pdf:/home/mrl/.local/share/zotero/storage/M49MWHPX/thesis.pdf:application/pdf}
  40 }
  41
  42 @incollection{lubbers_writing_2019,
  43         address = {Cham},
  44         title = {Writing {Internet} of {Things} applications with {Task} {Oriented} {Programming}},
  45         abstract = {The Internet of Things (IOT) is growing fast. In 2018, there was approximately one connected device per person on earth and the number has been growing ever since. The devices interact with the environment via diﬀerent modalities at the same time using sensors and actuators making the programs parallel. Yet, writing this type of programs is diﬃcult because the devices have little computation power and memory, the platforms are heterogeneous and the languages are low level. Task Oriented Programming (TOP) is a novel declarative programming language paradigm that is used to express coordination of work, collaboration of users and systems, the distribution of shared data and the human computer interaction. The mTask language is a specialized, yet full-ﬂedged, multi-backend TOP language for IOT devices. With the bytecode interpretation backend and the integration with iTasks, tasks can be executed on the device dynamically. This means that —according to the current state of aﬀairs— tasks can be tailor-made at run time, compiled to device-agnostic bytecode and shipped to the device for interpretation. Tasks sent to the device are fully integrated in iTasks to allow every form of interaction with the tasks such as observation of the task value and interaction with Shared Data Sources (SDSs). The application is —server and devices— are programmed in a single language, albeit using two embedded Domain Speciﬁc Languages (EDSLs).},
  46         language = {en},
  47         booktitle = {Central {European} {Functional} {Programming} {School}: 8th {Summer} {School}, {CEFP} 2019, {Budapest}, {Hungary}, {July} 17–21, 2019, {Revised} {Selected} {Papers}},
  48         publisher = {Springer International Publishing},
  49         author = {Lubbers, Mart and Koopman, Pieter and Plasmeijer, Rinus},
  50         year = {2019},
  51         pages = {51},
  52         file = {Lubbers - Writing Internet of Things applications with Task .pdf:/home/mrl/.local/share/zotero/storage/ILZIBYW5/Lubbers - Writing Internet of Things applications with Task .pdf:application/pdf}
  53 }
  54
  55 @inproceedings{lubbers_interpreting_2019,
  56         address = {Singapore},
  57         title = {Interpreting {Task} {Oriented} {Programs} on {Tiny} {Computers}},
  58         copyright = {All rights reserved},
  59         language = {en},
  60         booktitle = {Proceedings of the 31th {Symposium} on the {Implementation} and {Application} of {Functional} {Programming} {Languages}},
  61         publisher = {ACM},
  62         author = {Lubbers, Mart and Koopman, Pieter and Plasmeijer, Rinus},
  63         year = {2019},
  64         pages = {12},
  65         file = {pre-conference-proceedings.pdf:/home/mrl/.local/share/zotero/storage/E4R53TGR/pre-conference-proceedings.pdf:application/pdf;Lubbers et al. - 2020 - Interpreting Task Oriented Programs on Tiny Comput.pdf:/home/mrl/.local/share/zotero/storage/8QXYMUIX/Lubbers et al. - 2020 - Interpreting Task Oriented Programs on Tiny Comput.pdf:application/pdf}
  66 }
  67
  68 @inproceedings{koopman_task-based_2018,
  69         address = {Vienna, Austria},
  70         title = {A {Task}-{Based} {DSL} for {Microcomputers}},
  71         copyright = {All rights reserved},
  72         isbn = {978-1-4503-6355-6},
  73         url = {http://dl.acm.org/citation.cfm?doid=3183895.3183902},
  74         doi = {10.1145/3183895.3183902},
  75         abstract = {The Internet of Things, IoT, makes small connected computing devices almost omnipresent. These devices have typically very limited computing power and severe memory restrictions to make them cheap and power efficient. These devices can interact with the environment via special sensors and actuators. Since each device controls several peripherals running interleaved, the control software is quite complicated and hard to maintain. Task Oriented Programming, TOP, offers lightweight communicating threads that can inspect each other’s intermediate results. This makes it well suited for the IoT. In this paper presents a functional task-based domain specific language for these IoT devices. We show that it yields concise control programs. By restricting the datatypes and using strict evaluation these programs fit within the restrictions of microcontrollers.},
  76         language = {en},
  77         urldate = {2019-01-14},
  78         booktitle = {Proceedings of the {Real} {World} {Domain} {Specific} {Languages} {Workshop} 2018 on   - {RWDSL2018}},
  79         publisher = {ACM Press},
  80         author = {Koopman, Pieter and Lubbers, Mart and Plasmeijer, Rinus},
  81         year = {2018},
  82         pages = {1--11},
  83         file = {a4-Koopman.pdf:/home/mrl/.local/share/zotero/storage/TXZD529C/a4-Koopman.pdf:application/pdf;Koopman et al. - 2018 - A Task-Based DSL for Microcomputers.pdf:/home/mrl/.local/share/zotero/storage/9ETMTMX2/Koopman et al. - 2018 - A Task-Based DSL for Microcomputers.pdf:application/pdf}
  84 }
  85
  86 @inproceedings{lubbers_tiered_2020,
  87         address = {Malmö},
  88         series = {{IoT} '20},
  89         title = {Tiered versus {Tierless} {IoT} {Stacks}: {Comparing} {Smart} {Campus} {Software} {Architectures}},
  90         isbn = {978-1-4503-8758-3},
  91         url = {https://doi.org/10.1145/3410992.3411002},
  92         doi = {10.1145/3410992.3411002},
  93         abstract = {Internet of Things (IoT) software stacks are notoriously complex, conventionally comprising multiple tiers/components and requiring that the developer not only uses multiple programming languages, but also correctly interoperate the components. A novel alternative is to use a single tierless language with a compiler that generates the code for each component, and for their correct interoperation.We report the first ever systematic comparison of tiered and tierless IoT software architectures. The comparison is based on two implementations of a non-trivial smart campus application. PRSS has a conventional tiered Python-based architecture, and Clean Wemos Super Sensors (CWSS) has a novel tierless architecture based on Clean and the iTask and mTask embedded DSLs. An operational comparison of CWSS and PRSS demonstrates that they have equivalent functionality, and that both meet the University of Glasgow (UoG) smart campus requirements.Crucially, the tierless CWSS stack requires 70\% less code than the tiered PRSS stack. We analyse the impact of the following three main factors. (1) Tierless developers need to manage less interoperation: CWSS uses two DSLs in a single paradigm where PRSS uses five languages and three paradigms. (2) Tierless developers benefit from automatically generated, and hence correct, communication. (3) Tierless developers can exploit the powerful high-level abstractions such as Task Oriented Programming (TOP) in CWSS. A far smaller and single paradigm codebase improves software quality, dramatically reduces development time, and improves the maintainability of tierless stacks.},
  94         booktitle = {Proceedings of the 10th {International} {Conference} on the {Internet} of {Things}},
  95         publisher = {Association for Computing Machinery},
  96         author = {Lubbers, Mart and Koopman, Pieter and Ramsingh, Adrian and Singer, Jeremy and Trinder, Phil},
  97         year = {2020},
  98         note = {event-place: Malmö, Sweden},
  99         keywords = {domain specific languages, internet of things, network reliability, software architectures},
 100         file = {Lubbers et al. - 2020 - Tiered versus Tierless IoT Stacks Comparing Smart.pdf:/home/mrl/.local/share/zotero/storage/YY3MJRZ6/Lubbers et al. - 2020 - Tiered versus Tierless IoT Stacks Comparing Smart.pdf:application/pdf}
 101 }
 102
 103 @misc{achten_clean_2007,
 104         title = {Clean for {Haskell98} {Programmers}},
 105         language = {en},
 106         author = {Achten, Peter},
 107         month = jul,
 108         year = {2007},
 109         file = {Achten - Clean for Haskell98 Programmers.pdf:/home/mrl/.local/share/zotero/storage/69WWSGLF/Achten - Clean for Haskell98 Programmers.pdf:application/pdf},
 110 }
 111
 112 @article{groningen_exchanging_2010,
 113         title = {Exchanging sources between {Clean} and {Haskell}: {A} double-edged front end for the {Clean} compiler},
 114         volume = {45},
 115         shorttitle = {Exchanging sources between {Clean} and {Haskell}},
 116         number = {11},
 117         journal = {ACM Sigplan Notices},
 118         author = {Groningen, John van and Noort, Thomas van and Achten, Peter and Koopman, Pieter and Plasmeijer, Rinus},
 119         year = {2010},
 120         pages = {49--60},
 121         file = {groj10-Haskell_front_end_Clean.pdf:/home/mrl/.local/share/zotero/storage/WVZWX8WT/groj10-Haskell_front_end_Clean.pdf:application/pdf},
 122 }
 123
 124 @techreport{plasmeijer_clean_2021,
 125         address = {Nijmegen},
 126         title = {Clean {Language} {Report} version 3.1},
 127         urldate = {2021-12-22},
 128         institution = {Institute for Computing and Information Sciences},
 129         author = {Plasmeijer, Rinus and van Eekelen, Marko and van Groningen, John},
 130         month = dec,
 131         year = {2021},
 132         pages = {127},
 133         file = {CleanLanguageReport.pdf:/home/mrl/.local/share/zotero/storage/I2SDRIH6/CleanLanguageReport.pdf:application/pdf},
 134 }
 135
 136 @inproceedings{brus_clean_1987,
 137         address = {Berlin, Heidelberg},
 138         title = {Clean — {A} language for functional graph rewriting},
 139         isbn = {978-3-540-47879-9},
 140         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.},
 141         booktitle = {Functional {Programming} {Languages} and {Computer} {Architecture}},
 142         publisher = {Springer Berlin Heidelberg},
 143         author = {Brus, T. H. and van Eekelen, M. C. J. D. and van Leer, M. O. and Plasmeijer, M. J.},
 144         editor = {Kahn, Gilles},
 145         year = {1987},
 146         pages = {364--384},
 147         file = {brut87-Clean.ps.gz:/home/mrl/.local/share/zotero/storage/T2QATWIE/brut87-Clean.ps.gz:application/gzip},
 148 }
 149
 150 @inproceedings{barendregt_towards_1987,
 151         title = {Towards an intermediate language for graph rewriting},
 152         volume = {1},
 153         booktitle = {{PARLE}, {Parallel} {Architectures} and {Languages} {Europe}},
 154         publisher = {Springer Verlag},
 155         author = {Barendregt, HP and van Eekelen, MCJD and Glauert, JRW and Kennaway, JR and Plasmeijer, MJ and Sleep, MR},
 156         year = {1987},
 157         pages = {159--174},
 158         file = {barh87-Lean.ps.gz:/home/mrl/.local/share/zotero/storage/63FBHND7/barh87-Lean.ps.gz:application/gzip},
 159 }
 160
 161 @inproceedings{nocker_concurrent_1991,
 162         address = {Berlin, Heidelberg},
 163         title = {Concurrent clean},
 164         isbn = {978-3-540-47472-2},
 165         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.},
 166         booktitle = {{PARLE} '91 {Parallel} {Architectures} and {Languages} {Europe}},
 167         publisher = {Springer Berlin Heidelberg},
 168         author = {Nöcker, E. G. J. M. H. and Smetsers, J. E. W. and van Eekelen, M. C. J. D. and Plasmeijer, M. J.},
 169         editor = {Aarts, Emile H. L. and van Leeuwen, Jan and Rem, Martin},
 170         year = {1991},
 171         pages = {202--219},
 172         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},
 173 }
 174
 175 @phdthesis{alimarine_generic_2005,
 176         address = {Nijmegen},
 177         type = {{PhD}},
 178         title = {Generic {Functional} {Programming}},
 179         language = {en},
 180         school = {Radboud University},
 181         author = {Alimarine, Artem},
 182         year = {2005},
 183         file = {Alimarine - Generic Functional Programming.pdf:/home/mrl/.local/share/zotero/storage/PDTS3SGX/Alimarine - Generic Functional Programming.pdf:application/pdf},
 184 }
 185
 186 @misc{ghc_team_ghc_2021,
 187         title = {{GHC} {User}’s {Guide} {Documentation}},
 188         url = {https://downloads.haskell.org/~ghc/latest/docs/users_guide.pdf},
 189         language = {English},
 190         urldate = {2021-02-24},
 191         publisher = {Release},
 192         author = {GHC Team},
 193         year = {2021},
 194 }
 195
 196 @inproceedings{cheney_lightweight_2002,
 197         title = {A lightweight implementation of generics and dynamics},
 198         url = {http://dl.acm.org/citation.cfm?id=581698},
 199         urldate = {2017-05-15},
 200         booktitle = {Proceedings of the 2002 {ACM} {SIGPLAN} workshop on {Haskell}},
 201         publisher = {ACM},
 202         author = {Cheney, James and Hinze, Ralf},
 203         year = {2002},
 204         keywords = {dynamic typing, generic programming, type representations},
 205         pages = {90--104},
 206         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},
 207 }
 208
 209 @incollection{hinze_fun_2003,
 210         address = {Palgrave},
 211         series = {Cornerstones of {Computing}},
 212         title = {Fun {With} {Phantom} {Types}},
 213         isbn = {978-0-333-99285-2},
 214         booktitle = {The {Fun} of {Programming}},
 215         publisher = {Bloomsbury Publishing},
 216         author = {Hinze, Ralf},
 217         editor = {Gibbons, Jeremy and de Moor, Oege},
 218         year = {2003},
 219         pages = {245--262},
 220 }
 221
 222 @inproceedings{jeuring_polytypic_1996,
 223         address = {Berlin, Heidelberg},
 224         title = {Polytypic programming},
 225         isbn = {978-3-540-70639-7},
 226         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.},
 227         booktitle = {Advanced {Functional} {Programming}},
 228         publisher = {Springer Berlin Heidelberg},
 229         author = {Jeuring, Johan and Jansson, Patrik},
 230         editor = {Launchbury, John and Meijer, Erik and Sheard, Tim},
 231         year = {1996},
 232         pages = {68--114},
 233         file = {Jeuring and Jansson - 1996 - Polytypic programming.pdf:/home/mrl/.local/share/zotero/storage/SLC4G2IT/Jeuring and Jansson - 1996 - Polytypic programming.pdf:application/pdf},
 234 }
 235 @techreport{cheney_first-class_2003,
 236         title = {First-class phantom types},
 237         url = {https://ecommons.cornell.edu/handle/1813/5614},
 238         urldate = {2017-05-15},
 239         institution = {Cornell University},
 240         author = {Cheney, James and Hinze, Ralf},
 241         year = {2003},
 242         file = {https\://ecommons.cornell.edu/bitstream/handle/1813/5614/?sequence=1:/home/mrl/.local/share/zotero/storage/R5IFMHTP/5614.pdf:application/pdf}
 243 }
 244 @incollection{mernik_extensible_2013,
 245         address = {Hershey, PA, USA},
 246         title = {Extensible {Languages}: {Blurring} the {Distinction} between {DSL} and {GPL}},
 247         isbn = {978-1-4666-2092-6},
 248         url = {https://services.igi-global.com/resolvedoi/resolve.aspx?doi=10.4018/978-1-4666-2092-6.ch001},
 249         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.},
 250         booktitle = {Formal and {Practical} {Aspects} of {Domain}-{Specific} {Languages}: {Recent} {Developments}},
 251         publisher = {IGI Global},
 252         author = {Verna, Didier},
 253         editor = {Mernik, Marjan},
 254         year = {2013},
 255         doi = {10.4018/978-1-4666-2092-6.ch001},
 256         pages = {1--31},
 257 }
 258
 259 @article{tratt_domain_2008,
 260         title = {Domain {Specific} {Language} {Implementation} via {Compile}-{Time} {Meta}-{Programming}},
 261         volume = {30},
 262         issn = {0164-0925},
 263         url = {https://doi.org/10.1145/1391956.1391958},
 264         doi = {10.1145/1391956.1391958},
 265         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.},
 266         number = {6},
 267         journal = {ACM Trans. Program. Lang. Syst.},
 268         author = {Tratt, Laurence},
 269         month = oct,
 270         year = {2008},
 271         note = {Place: New York, NY, USA
 272 Publisher: Association for Computing Machinery},
 273         keywords = {compile-time meta-programming, domain specific languages, Syntax extension},
 274         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},
 275 }
 276
 277 @inproceedings{sheard_accomplishments_2001,
 278         address = {Berlin, Heidelberg},
 279         title = {Accomplishments and {Research} {Challenges} in {Meta}-programming},
 280         isbn = {978-3-540-44806-8},
 281         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.},
 282         booktitle = {Semantics, {Applications}, and {Implementation} of {Program} {Generation}},
 283         publisher = {Springer Berlin Heidelberg},
 284         author = {Sheard, Tim},
 285         editor = {Taha, Walid},
 286         year = {2001},
 287         pages = {2--44},
 288         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},
 289 }
 290
 291 @incollection{gibbons_functional_2015,
 292         address = {Cham},
 293         title = {Functional {Programming} for {Domain}-{Specific} {Languages}},
 294         isbn = {978-3-319-15940-9},
 295         url = {https://doi.org/10.1007/978-3-319-15940-9_1},
 296         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.},
 297         booktitle = {Central {European} {Functional} {Programming} {School}: 5th {Summer} {School}, {CEFP} 2013, {Cluj}-{Napoca}, {Romania}, {July} 8-20, 2013, {Revised} {Selected} {Papers}},
 298         publisher = {Springer International Publishing},
 299         author = {Gibbons, Jeremy},
 300         editor = {Zsók, Viktória and Horváth, Zoltán and Csató, Lehel},
 301         year = {2015},
 302         doi = {10.1007/978-3-319-15940-9_1},
 303         pages = {1--28},
 304         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},
 305 }
 306
 307 @article{elliott_compiling_2003,
 308         title = {Compiling embedded languages},
 309         volume = {13},
 310         doi = {10.1017/S0956796802004574},
 311         number = {3},
 312         journal = {Journal of Functional Programming},
 313         author = {Elliott, Conal and Finne, Sigbjørn and de Moor, Oege},
 314         year = {2003},
 315         note = {Publisher: Cambridge University Press},
 316         pages = {455--481},
 317         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},
 318 }
 319
 320 @book{fowler_domain-specific_2010,
 321         title = {Domain-specific languages},
 322         publisher = {Pearson Education},
 323         author = {Fowler, Martin},
 324         year = {2010},
 325         file = {Fowler - 2010 - Domain-specific languages.pdf:/home/mrl/.local/share/zotero/storage/YYMYXTZ5/Fowler - 2010 - Domain-specific languages.pdf:application/pdf},
 326 }
 327
 328 @inproceedings{hudak_modular_1998,
 329         title = {Modular domain specific languages and tools},
 330         doi = {10.1109/ICSR.1998.685738},
 331         booktitle = {Proceedings. {Fifth} {International} {Conference} on {Software} {Reuse} ({Cat}. {No}.{98TB100203})},
 332         author = {Hudak, P.},
 333         year = {1998},
 334         pages = {134--142},
 335         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},
 336 }
 337
 338 @inproceedings{baccelli_reprogramming_2018,
 339         title = {Reprogramming {Low}-end {IoT} {Devices} from the {Cloud}},
 340         booktitle = {2018 3rd {Cloudification} of the {Internet} of {Things} ({CIoT})},
 341         publisher = {IEEE},
 342         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},
 343         year = {2018},
 344         pages = {1--6},
 345         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},
 346 }
 347
 348 @inproceedings{baccelli_scripting_2018,
 349         title = {Scripting {Over}-{The}-{Air}: {Towards} {Containers} on {Low}-end {Devices} in the {Internet} of {Things}},
 350         booktitle = {{IEEE} {PerCom} 2018},
 351         author = {Baccelli, Emmanuel and Doerr, Joerg and Kikuchi, Shinji and Padilla, Francisco and Schleiser, Kaspar and Thomas, Ian},
 352         year = {2018},
 353         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},
 354 }
 355
 356 @inproceedings{plasmeijer_task-oriented_2012,
 357         address = {New York, NY, USA},
 358         series = {{PPDP} '12},
 359         title = {Task-{Oriented} {Programming} in a {Pure} {Functional} {Language}},
 360         isbn = {978-1-4503-1522-7},
 361         url = {https://doi.org/10.1145/2370776.2370801},
 362         doi = {10.1145/2370776.2370801},
 363         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.},
 364         booktitle = {Proceedings of the 14th {Symposium} on {Principles} and {Practice} of {Declarative} {Programming}},
 365         publisher = {Association for Computing Machinery},
 366         author = {Plasmeijer, Rinus and Lijnse, Bas and Michels, Steffen and Achten, Peter and Koopman, Pieter},
 367         year = {2012},
 368         note = {event-place: Leuven, Belgium},
 369         keywords = {clean, task-oriented programming},
 370         pages = {195--206},
 371         file = {103802.pdf:/home/mrl/.local/share/zotero/storage/ZE6A65AW/103802.pdf:application/pdf},
 372 }
 373
 374 @incollection{wang_maintaining_2018,
 375         address = {Cham},
 376         title = {Maintaining {Separation} of {Concerns} {Through} {Task} {Oriented} {Software} {Development}},
 377         volume = {10788},
 378         isbn = {978-3-319-89718-9 978-3-319-89719-6},
 379         url = {http://link.springer.com/10.1007/978-3-319-89719-6_2},
 380         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.},
 381         language = {en},
 382         urldate = {2019-01-14},
 383         booktitle = {Trends in {Functional} {Programming}},
 384         publisher = {Springer International Publishing},
 385         author = {Stutterheim, Jurriën and Achten, Peter and Plasmeijer, Rinus},
 386         editor = {Wang, Meng and Owens, Scott},
 387         year = {2018},
 388         doi = {10.1007/978-3-319-89719-6},
 389         pages = {19--38},
 390         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},
 391 }