self.bib

   1
   2 @inproceedings{lubbers_interpreting_2019,
   3         address = {New York, NY, USA},
   4         series = {{IFL} '19},
   5         title = {Interpreting {Task} {Oriented} {Programs} on {Tiny} {Computers}},
   6         isbn = {978-1-4503-7562-7},
   7         doi = {10.1145/3412932.3412936},
   8         abstract = {Small Microcontroller Units (MCUs) drive the omnipresent Internet of Things (IoT). These devices are small, cheap, and energy efficient. However, they are not very powerful and lack an Operating System. Hence it is difficult to apply high level abstractions and write software that stays close to the design.Task Oriented Programming (TOP) is a paradigm for creating multi-user collaborative systems. A program consists of tasks—descriptions of what needs to be done. The tasks represent the actual work and a task value is observable during execution. Furthermore, tasks can be combined and transformed using combinators.mTask is an embedded Domain Specific Language (eDSL) to program MCUs following the TOP paradigm. Previous work has described the mTask language, a static C code generator, and how to integrate mTask with TOP servers. This paper shows that for dynamic IOT applications, tasks must be sent at runtime to the devices for interpretation. It describes in detail how to compile specialized IOT TOP tasks to bytecode and how to interpret them on devices with very little memory. These additions allow the creation of complete, dynamic IOT applications arising from a single source using a mix of iTasks and mTask tasks. Details such as serialization and communication are captured in simple abstractions.},
   9         booktitle = {Proceedings of the 31st {Symposium} on {Implementation} and {Application} of {Functional} {Languages}},
  10         publisher = {Association for Computing Machinery},
  11         author = {Lubbers, Mart and Koopman, Pieter and Plasmeijer, Rinus},
  12         editor = {Stutterheim, Jurriën and Chin, Wei Ngan},
  13         year = {2019},
  14         note = {event-place: Singapore, Singapore},
  15         keywords = {clean, distributed applications, functional programming, internet of things, task oriented programming},
  16         file = {Lubbers et al. - 2019 - Interpreting Task Oriented Programs on Tiny Comput.pdf:/home/mrl/.local/share/zotero/storage/ATYSJXJ3/Lubbers et al. - 2019 - Interpreting Task Oriented Programs on Tiny Comput.pdf:application/pdf},
  17 }
  18
  19 @incollection{lubbers_writing_2019,
  20         address = {Cham},
  21         title = {Writing {Internet} of {Things} applications with {Task} {Oriented} {Programming}},
  22         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).},
  23         language = {en},
  24         booktitle = {Central {European} {Functional} {Programming} {School}: 8th {Summer} {School}, {CEFP} 2019, {Budapest}, {Hungary}, {July} 17–21, 2019, {Revised} {Selected} {Papers}},
  25         publisher = {Springer International Publishing},
  26         author = {Lubbers, Mart and Koopman, Pieter and Plasmeijer, Rinus},
  27         year = {2019},
  28         note = {in-press. preprint at: https://arxiv.org/abs/2212.04193},
  29         pages = {51},
  30         file = {cefp.pdf:/home/mrl/.local/share/zotero/storage/VEWFI5DG/cefp.pdf:application/pdf},
  31 }
  32
  33 @inproceedings{lubbers_tiered_2020,
  34         address = {Malmö},
  35         series = {{IoT} '20},
  36         title = {Tiered versus {Tierless} {IoT} {Stacks}: {Comparing} {Smart} {Campus} {Software} {Architectures}},
  37         isbn = {978-1-4503-8758-3},
  38         doi = {10.1145/3410992.3411002},
  39         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.},
  40         booktitle = {Proceedings of the 10th {International} {Conference} on the {Internet} of {Things}},
  41         publisher = {Association for Computing Machinery},
  42         author = {Lubbers, Mart and Koopman, Pieter and Ramsingh, Adrian and Singer, Jeremy and Trinder, Phil},
  43         year = {2020},
  44         note = {event-place: Malmö, Sweden},
  45         keywords = {internet of things, domain specific languages, network reliability, software architectures},
  46         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},
  47 }
  48
  49 @inproceedings{koopman_task-based_2018,
  50         address = {Vienna, Austria},
  51         title = {A {Task}-{Based} {DSL} for {Microcomputers}},
  52         copyright = {All rights reserved},
  53         isbn = {978-1-4503-6355-6},
  54         doi = {10.1145/3183895.3183902},
  55         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.},
  56         language = {en},
  57         urldate = {2019-01-14},
  58         booktitle = {Proceedings of the {Real} {World} {Domain} {Specific} {Languages} {Workshop} 2018 on   - {RWDSL2018}},
  59         publisher = {ACM Press},
  60         author = {Koopman, Pieter and Lubbers, Mart and Plasmeijer, Rinus},
  61         year = {2018},
  62         pages = {1--11},
  63         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},
  64 }
  65
  66 @inproceedings{lubbers_multitasking_2019,
  67         address = {Opatija, Croatia},
  68         title = {Multitasking on {Microcontrollers} using {Task} {Oriented} {Programming}},
  69         copyright = {All rights reserved},
  70         shorttitle = {Multitasking on {Microcontrollers} using {TOP}},
  71         doi = {10.23919/MIPRO.2019.8756711},
  72         booktitle = {2019 42nd {International} {Convention} on {Information} and {Communication} {Technology}, {Electronics} and {Microelectronics} ({MIPRO})},
  73         author = {Lubbers, M. and Koopman, P. and Plasmeijer, R.},
  74         month = may,
  75         year = {2019},
  76         pages = {1587--1592},
  77         file = {03_4cows_5338.pdf:/home/mrl/.local/share/zotero/storage/3QJTF5HT/03_4cows_5338.pdf:application/pdf;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},
  78 }
  79
  80 @phdthesis{lubbers_adaptable_2015,
  81         address = {Nijmegen},
  82         type = {Bachelor's {Thesis}},
  83         title = {Adaptable crawler specification generation system for leisure activity {RSS} feeds},
  84         copyright = {All rights reserved},
  85         url = {http://theses.ubn.ru.nl/handle/123456789/220},
  86         urldate = {2017-04-12},
  87         school = {Radboud University},
  88         author = {Lubbers, Mart},
  89         year = {2015},
  90         file = {Adaptable crawler specification generation system for leisure activity RSS feeds - Lubbers,M._BA_Thesis_2015.pdf:/home/mrl/.local/share/zotero/storage/7SDHJ3KD/Lubbers,M._BA_Thesis_2015.pdf:application/pdf},
  91 }
  92
  93 @inproceedings{lubbers_task_2018,
  94         address = {Lowell, MA},
  95         title = {Task {Oriented} {Programming} and the {Internet} of {Things}},
  96         isbn = {978-1-4503-7143-8},
  97         doi = {10.1145/3310232.3310239},
  98         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.},
  99         language = {en},
 100         booktitle = {Proceedings of the 30th {Symposium} on the {Implementation} and {Application} of {Functional} {Programming} {Languages}},
 101         publisher = {ACM},
 102         author = {Lubbers, Mart and Koopman, Pieter and Plasmeijer, Rinus},
 103         year = {2018},
 104         pages = {12},
 105         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;Lubbers et al. - 2019 - Task Oriented Programming and the Internet of Thin.pdf:/home/mrl/.local/share/zotero/storage/R7TFJGVR/Lubbers et al. - 2019 - Task Oriented Programming and the Internet of Thin.pdf:application/pdf},
 106 }
 107
 108 @mastersthesis{lubbers_task_2017,
 109         address = {Nijmegen},
 110         title = {Task {Oriented} {Programming} and the {Internet} of {Things}},
 111         copyright = {All rights reserved},
 112         shorttitle = {{TOP} and the {IoT}},
 113         school = {Radboud University},
 114         author = {Lubbers, Mart},
 115         year = {2017},
 116         file = {thesis.pdf:/home/mrl/.local/share/zotero/storage/M49MWHPX/thesis.pdf:application/pdf},
 117 }
 118
 119 @article{schuerman_praatalign:_2015,
 120         title = {Praatalign: {Phonetic} {Alignment} {Made} {Easier} {For} {Psycholinguistic} {Data} {Processing}},
 121         journal = {Architectures and Mechanisms for Language Processing},
 122         author = {Schuerman, Will and Torreira, Francisco and Lubbers, Mart},
 123         year = {2015},
 124         pages = {92},
 125         file = {amlap2015.pdf:/home/mrl/.local/share/zotero/storage/H9WTW9TM/amlap2015.pdf:application/pdf;Will_Schuerman_AMLAP2015_Draft2.pdf:/home/mrl/.local/share/zotero/storage/BFBDDVIQ/Will_Schuerman_AMLAP2015_Draft2.pdf:application/pdf},
 126 }
 127
 128 @incollection{koopman_simulation_2018,
 129         address = {Cham},
 130         title = {Simulation of a {Task}-{Based} {Embedded} {Domain} {Specific} {Language} for the {Internet} of {Things}},
 131         language = {en},
 132         booktitle = {Central {European} {Functional} {Programming} {School}: 7th {Summer} {School}, {CEFP} 2018, {Košice}, {Slovakia}, {January} 22–26, 2018, {Revised} {Selected} {Papers}},
 133         publisher = {Springer International Publishing},
 134         author = {Koopman, Pieter and Lubbers, Mart and Plasmeijer, Rinus},
 135         year = {2018},
 136         note = {in-press},
 137         pages = {51},
 138 }
 139
 140 @misc{koopman_sustrainable_2022,
 141         title = {{SusTrainable}: {Promoting} {Sustainability} as a {Fundamental} {Driver} in {Software} {Development} {Training} and {Education}. {Teacher} {Training}, {November} 1-5, {Nijmegen}, {The} {Netherlands}. {Revised} lecture notes},
 142         copyright = {Creative Commons Attribution Non Commercial No Derivatives 4.0 International},
 143         publisher = {arXiv},
 144         author = {Koopman, Pieter and Lubbers, Mart and Fernandes, João Paulo},
 145         year = {2022},
 146         doi = {10.48550/ARXIV.2204.13993},
 147         keywords = {Computers and Society (cs.CY), FOS: Computer and information sciences, Software Engineering (cs.SE)},
 148         file = {Koopman et al. - 2022 - SusTrainable Promoting Sustainability as a Fundam.pdf:/home/mrl/.local/share/zotero/storage/5F9SRJQI/Koopman et al. - 2022 - SusTrainable Promoting Sustainability as a Fundam.pdf:application/pdf},
 149 }
 150
 151 @inproceedings{lubbers_first-class_2022,
 152         address = {New York, NY, USA},
 153         series = {{IFL} '22},
 154         title = {First-{Class} {Data} {Types} in {Shallow} {Embedded} {Domain}-{Specific} {Languages} using {Metaprogramming}},
 155         booktitle = {Proceedings of the 34st {Symposium} on {Implementation} and {Application} of {Functional} {Languages}},
 156         publisher = {Association for Computing Machinery},
 157         author = {Lubbers, Mart and Koopman, Pieter and Plasmeijer, Rinus},
 158         year = {2022},
 159         note = {event-place: Kopenhagen, Denmark. under-review},
 160         keywords = {clean, distributed applications, functional programming, internet of things, task oriented programming},
 161 }
 162
 163 @book{lubbers_orchestrating_2023,
 164         address = {Nijmegen},
 165         title = {Orchestrating the {Internet} of {Things} using {Task}-{Oriented} {Programming}},
 166         shorttitle = {A {Cocktail} of {Tools}: {DSLs} for {TOSD}},
 167         publisher = {UB Nijmegen},
 168         author = {Lubbers, Mart},
 169         year = {2023},
 170 }
 171
 172 @incollection{lubbers_green_2022,
 173         address = {Cham},
 174         title = {Green {Computing} for the {Internet} of {Things}},
 175         language = {en},
 176         booktitle = {{SusTrainable} {Summer} {School} 2022, {Rijeka}, {Croatia}, {July} 4–5, 2022, {Revised} {Selected} {Papers}},
 177         publisher = {Springer International Publishing},
 178         author = {Lubbers, Mart and Koopman, Pieter},
 179         year = {2022},
 180         note = {in-press},
 181         pages = {1},
 182 }
 183
 184 @article{lubbers_could_2022,
 185         title = {Could {Tierless} {Languages} {Reduce} {IoT} {Development} {Grief}?},
 186         issn = {2691-1914},
 187         doi = {10.1145/3572901},
 188         abstract = {Internet of Things (IoT) software is notoriously complex, conventionally comprising multiple tiers. Traditionally an IoT developer must use multiple programming languages and ensure that the components interoperate correctly. A novel alternative is to use a single tierless language with a compiler that generates the code for each component and ensures their correct interoperation. We report a systematic comparative evaluation of two tierless language technologies for IoT stacks: one for resource-rich sensor nodes (Clean with iTask), and one for resource-constrained sensor nodes (Clean with iTask and mTask). The evaluation is based on four implementations of a typical smart campus application: two tierless and two Python-based tiered. (1) We show that tierless languages have the potential to significantly reduce the development effort for IoT systems, requiring 70\% less code than the tiered implementations. Careful analysis attributes this code reduction to reduced interoperation (e.g. two embedded domain-specific languages (DSLs) and one paradigm versus seven languages and two paradigms), automatically generated distributed communication, and powerful IoT programming abstractions. (2) We show that tierless languages have the potential to significantly improve the reliability of IoT systems, describing how Clean iTask/mTask maintains type safety, provides higher order failure management, and simplifies maintainability. (3) We report the first comparison of a tierless IoT codebase for resource-rich sensor nodes with one for resource-constrained sensor nodes. The comparison shows that they have similar code size (within 7\%), and functional structure. (4) We present the first comparison of two tierless IoT languages, one for resource-rich sensor nodes, and the other for resource-constrained sensor nodes.},
 189         journal = {ACM Trans. Internet Things},
 190         author = {Lubbers, Mart and Koopman, Pieter and Ramsingh, Adrian and Singer, Jeremy and Trinder, Phil},
 191         month = nov,
 192         year = {2022},
 193         note = {Place: New York, NY, USA
 194 Publisher: Association for Computing Machinery},
 195         keywords = {access control, internet-of-things, policy language, privilege escalation, Smart home system, IoT stacks, Tierless languages},
 196 }
 197
 198 @inproceedings{koopman_strongly-typed_2022,
 199         address = {New York, NY, USA},
 200         series = {{IFL} '22},
 201         title = {Strongly-{Typed} {Multi}-{View} {Stack}-{Based} {Computations}},
 202         booktitle = {Proceedings of the 34st {Symposium} on {Implementation} and {Application} of {Functional} {Languages}},
 203         publisher = {Association for Computing Machinery},
 204         author = {Koopman, Pieter and Lubbers, Mart},
 205         year = {2022},
 206         note = {event-place: Kopenhagen, Denmark. under-review},
 207         keywords = {clean, distributed applications, functional programming, internet of things, task oriented programming},
 208 }
 209
 210 @inproceedings{lubbers_deep_2022,
 211         address = {Cham},
 212         title = {Deep {Embedding} with {Class}},
 213         isbn = {978-3-031-21314-4},
 214         abstract = {The two flavours of DSL embedding are shallow and deep embedding. In functional languages, shallow embedding models the language constructs as functions in which the semantics are embedded. Adding semantics is therefore cumbersome while adding constructs is a breeze. Upgrading the functions to type classes lifts this limitation to a certain extent.},
 215         booktitle = {Trends in {Functional} {Programming}},
 216         publisher = {Springer International Publishing},
 217         author = {Lubbers, Mart},
 218         editor = {Swierstra, Wouter and Wu, Nicolas},
 219         year = {2022},
 220         pages = {39--58},
 221         file = {Lubbers - 2022 - Deep Embedding with Class.pdf:/home/mrl/.local/share/zotero/storage/KDFM73Z7/Lubbers - 2022 - Deep Embedding with Class.pdf:application/pdf},
 222 }
 223
 224 @inproceedings{crooijmans_reducing_2022,
 225         address = {Cham},
 226         title = {Reducing the {Power} {Consumption} of {IoT} with {Task}-{Oriented} {Programming}},
 227         isbn = {978-3-031-21314-4},
 228         abstract = {Limiting the energy consumption of IoT nodes is a hot topic in green computing. For battery-powered devices this necessity is obvious, but the enormous growth of the number of IoT nodes makes energy efficiency important for every node in the IoT. In this paper, we show how we can automatically compute execution intervals for our task-oriented programs for the IoT. These intervals offer the possibility to save energy by bringing the microprocessor driving the IoT node into a low-power sleep mode until the task need to be executed. Furthermore, they offer an elegant way to add interrupts to the system. We do allow an arbitrary number of tasks on the IoT nodes and achieve significant reductions of the energy consumption by bringing the microprocessor in sleep mode as much as possible. We have seen energy reductions of an order of magnitude without imposing any constraints on the tasks to be executed on the IoT nodes.},
 229         booktitle = {Trends in {Functional} {Programming}},
 230         publisher = {Springer International Publishing},
 231         author = {Crooijmans, Sjoerd and Lubbers, Mart and Koopman, Pieter},
 232         editor = {Swierstra, Wouter and Wu, Nicolas},
 233         year = {2022},
 234         pages = {80--99},
 235         file = {Crooijmans et al. - 2022 - Reducing the Power Consumption of IoT with Task-Or.pdf:/home/mrl/.local/share/zotero/storage/6DPWZRNJ/Crooijmans et al. - 2022 - Reducing the Power Consumption of IoT with Task-Or.pdf:application/pdf},
 236 }