bib/self.bib

   1
   2 @inproceedings{lubbers_interpreting_2019,
   3         location = {New York, {NY}, {USA}},
   4         title = {Interpreting Task Oriented Programs on Tiny Computers},
   5         isbn = {978-1-4503-7562-7},
   6         doi = {10.1145/3412932.3412936},
   7         series = {{IFL} '19},
   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         eventtitle = {Symposium on Implementation and Application of Functional Languages},
  10         booktitle = {Proceedings of the 31st Symposium on Implementation and Application of Functional Languages},
  11         publisher = {{ACM}},
  12         author = {Lubbers, Mart and Koopman, Pieter and Plasmeijer, Rinus},
  13         editor = {Stutterheim, Jurriën and Chin, Wei Ngan},
  14         date = {2021},
  15         note = {event-place: Singapore, Singapore},
  16         keywords = {clean, distributed applications, functional programming, internet of things, task oriented programming},
  17         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},
  18 }
  19
  20 @incollection{lubbers_writing_2023,
  21         location = {Cham},
  22         title = {Writing Internet of Things Applications with Task Oriented Programming},
  23         series = {Lecture Notes in Computer Science},
  24         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}).},
  25         pages = {51},
  26         number = {11950},
  27         booktitle = {Composability, Comprehensibility and Correctness of Working Software, 8th Summer School, Budapest, Hungary, June 17–21, 2019, Revised Selected Papers},
  28         publisher = {Springer},
  29         author = {Lubbers, Mart and Koopman, Pieter and Plasmeijer, Rinus},
  30         date = {2023},
  31         langid = {english},
  32         note = {in-press. preprint at: https://arxiv.org/abs/2212.04193},
  33         file = {cefp.pdf:/home/mrl/.local/share/zotero/storage/VEWFI5DG/cefp.pdf:application/pdf},
  34 }
  35
  36 @inproceedings{lubbers_tiered_2020,
  37         location = {Malmö},
  38         title = {Tiered versus Tierless {IoT} Stacks: Comparing Smart Campus Software Architectures},
  39         isbn = {978-1-4503-8758-3},
  40         doi = {10.1145/3410992.3411002},
  41         series = {{IoT} '20},
  42         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.},
  43         eventtitle = {10th International Conference on the Internet of Things},
  44         booktitle = {Proceedings of the 10th International Conference on the Internet of Things},
  45         publisher = {{ACM}},
  46         author = {Lubbers, Mart and Koopman, Pieter and Ramsingh, Adrian and Singer, Jeremy and Trinder, Phil},
  47         date = {2020},
  48         note = {event-place: Malmö, Sweden},
  49         keywords = {internet of things, domain specific languages, network reliability, software architectures},
  50         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},
  51 }
  52
  53 @inproceedings{koopman_task-based_2018,
  54         location = {Vienna, Austria},
  55         title = {A Task-Based {DSL} for Microcomputers},
  56         rights = {All rights reserved},
  57         isbn = {978-1-4503-6355-6},
  58         doi = {10.1145/3183895.3183902},
  59         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.},
  60         eventtitle = {the Real World Domain Specific Languages Workshop 2018},
  61         pages = {1--11},
  62         booktitle = {Proceedings of the Real World Domain Specific Languages Workshop 2018 on   - {RWDSL}2018},
  63         publisher = {{ACM} Press},
  64         author = {Koopman, Pieter and Lubbers, Mart and Plasmeijer, Rinus},
  65         urldate = {2019-01-14},
  66         date = {2018},
  67         langid = {english},
  68         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},
  69 }
  70
  71 @inproceedings{lubbers_multitasking_2019,
  72         location = {Opatija, Croatia},
  73         title = {Multitasking on Microcontrollers using Task Oriented Programming},
  74         rights = {All rights reserved},
  75         doi = {10.23919/MIPRO.2019.8756711},
  76         shorttitle = {Multitasking on Microcontrollers using {TOP}},
  77         eventtitle = {{COnference} on {COmposability}, {COmprehensibility} and {COrrectness} of Working Software},
  78         pages = {1587--1592},
  79         booktitle = {2019 42nd International Convention on Information and Communication Technology, Electronics and Microelectronics ({MIPRO})},
  80         author = {Lubbers, M. and Koopman, P. and Plasmeijer, R.},
  81         date = {2019-05},
  82         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},
  83 }
  84
  85 @thesis{lubbers_adaptable_2015,
  86         location = {Nijmegen},
  87         title = {Adaptable crawler specification generation system for leisure activity {RSS} feeds},
  88         rights = {All rights reserved},
  89         url = {http://theses.ubn.ru.nl/handle/123456789/220},
  90         pagetotal = {33},
  91         institution = {Radboud University},
  92         type = {Bachelor's Thesis},
  93         author = {Lubbers, Mart},
  94         urldate = {2017-04-12},
  95         date = {2015},
  96         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},
  97 }
  98
  99 @inproceedings{lubbers_task_2018,
 100         location = {Lowell, {MA}},
 101         title = {Task Oriented Programming and the Internet of Things},
 102         isbn = {978-1-4503-7143-8},
 103         doi = {10.1145/3310232.3310239},
 104         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.},
 105         eventtitle = {International Symposium on Implementation and Application of Functional Languages},
 106         pages = {12},
 107         booktitle = {Proceedings of the 30th Symposium on the Implementation and Application of Functional Programming Languages},
 108         publisher = {{ACM}},
 109         author = {Lubbers, Mart and Koopman, Pieter and Plasmeijer, Rinus},
 110         date = {2018},
 111         langid = {english},
 112         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},
 113 }
 114
 115 @thesis{lubbers_task_2017,
 116         location = {Nijmegen},
 117         title = {Task Oriented Programming and the Internet of Things},
 118         rights = {All rights reserved},
 119         shorttitle = {{TOP} and the {IoT}},
 120         pagetotal = {69},
 121         institution = {Radboud University},
 122         type = {Master's Thesis},
 123         author = {Lubbers, Mart},
 124         date = {2017},
 125         file = {thesis.pdf:/home/mrl/.local/share/zotero/storage/M49MWHPX/thesis.pdf:application/pdf},
 126 }
 127
 128 @article{schuerman_praatalign:_2015,
 129         title = {Praatalign: Phonetic Alignment Made Easier For Psycholinguistic Data Processing},
 130         pages = {92},
 131         journaltitle = {Architectures and Mechanisms for Language Processing},
 132         author = {Schuerman, Will and Torreira, Francisco and Lubbers, Mart},
 133         date = {2015},
 134         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},
 135 }
 136
 137 @incollection{koopman_simulation_2023,
 138         location = {Cham},
 139         title = {Simulation of a Task-Based Embedded Domain Specific Language for the Internet of Things},
 140         series = {Lecture Notes in Computer Science},
 141         pages = {51},
 142         number = {11916},
 143         booktitle = {Composability, Comprehensibility and Correctness of Working Software, 7th Winter School, Kosice, Slovakia, January 22–26, 2018, Revised Selected Papers},
 144         publisher = {Springer},
 145         author = {Koopman, Pieter and Lubbers, Mart and Plasmeijer, Rinus},
 146         date = {2023},
 147         langid = {english},
 148         note = {in-press},
 149 }
 150
 151 @misc{koopman_sustrainable_2022,
 152         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},
 153         rights = {Creative Commons Attribution Non Commercial No Derivatives 4.0 International},
 154         publisher = {{arXiv}},
 155         author = {Koopman, Pieter and Lubbers, Mart and Fernandes, João Paulo},
 156         date = {2022},
 157         doi = {10.48550/ARXIV.2204.13993},
 158         keywords = {Computers and Society (cs.{CY}), {FOS}: Computer and information sciences, Software Engineering (cs.{SE})},
 159         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},
 160 }
 161
 162 @inproceedings{lubbers_first-class_2022,
 163         location = {New York, {NY}, {USA}},
 164         title = {First-Class Data Types in Shallow Embedded Domain-Specific Languages using Metaprogramming},
 165         isbn = {978-1-4503-9831-2},
 166         doi = {10.1145/3587216.3587219},
 167         series = {{IFL} '22},
 168         eventtitle = {Symposium on Implementation and Application of Functional Languages},
 169         booktitle = {Proceedings of the 34st Symposium on Implementation and Application of Functional Languages},
 170         publisher = {{ACM}},
 171         author = {Lubbers, Mart and Koopman, Pieter and Plasmeijer, Rinus},
 172         date = {2023},
 173         numpages = {12},
 174         note = {event-place: Copenhagen, Denmark. in-press},
 175         keywords = {clean, distributed applications, functional programming, internet of things, task oriented programming},
 176 }
 177 @book{lubbers_orchestrating_2023,
 178         location = {Nijmegen},
 179         title = {Orchestrating the Internet of Things using Task-Oriented Programming},
 180         shorttitle = {A Cocktail of Tools: {DSLs} for {TOSD}},
 181         publisher = {{UB} Nijmegen},
 182         author = {Lubbers, Mart},
 183         date = {2023},
 184 }
 185
 186 @incollection{lubbers_green_2022,
 187         location = {Cham},
 188         title = {Green Computing for the Internet of Things},
 189         pages = {1},
 190         booktitle = {{SusTrainable} Summer School 2022, Rijeka, Croatia, July 4–5, 2022, Revised Selected Papers},
 191         publisher = {Springer International Publishing},
 192         author = {Lubbers, Mart and Koopman, Pieter},
 193         date = {2022},
 194         langid = {english},
 195         note = {in-press},
 196 }
 197
 198 @inproceedings{koopman_strongly-typed_2022,
 199         location = {New York, {NY}, {USA}},
 200         title = {Strongly-Typed Multi-View Stack-Based Computations},
 201         series = {{IFL} '22},
 202         eventtitle = {Symposium on Implementation and Application of Functional Languages},
 203         booktitle = {Proceedings of the 34st Symposium on Implementation and Application of Functional Languages},
 204         publisher = {{ACM}},
 205         author = {Koopman, Pieter and Lubbers, Mart},
 206         date = {2022},
 207         note = {event-place: Kopenhagen, Denmark. under-review},
 208         keywords = {clean, distributed applications, functional programming, internet of things, task oriented programming},
 209 }
 210
 211 @inproceedings{lubbers_deep_2022,
 212         location = {Cham},
 213         title = {Deep Embedding with Class},
 214         isbn = {978-3-031-21314-4},
 215         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.},
 216         pages = {39--58},
 217         booktitle = {Trends in Functional Programming},
 218         publisher = {Springer International Publishing},
 219         author = {Lubbers, Mart},
 220         editor = {Swierstra, Wouter and Wu, Nicolas},
 221         date = {2022},
 222         file = {Lubbers - 2022 - Deep Embedding with Class.pdf:/home/mrl/.local/share/zotero/storage/KDFM73Z7/Lubbers - 2022 - Deep Embedding with Class.pdf:application/pdf},
 223 }
 224
 225 @inproceedings{crooijmans_reducing_2022,
 226         location = {Cham},
 227         title = {Reducing the Power Consumption of {IoT} with Task-Oriented Programming},
 228         isbn = {978-3-031-21314-4},
 229         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.},
 230         pages = {80--99},
 231         booktitle = {Trends in Functional Programming},
 232         publisher = {Springer International Publishing},
 233         author = {Crooijmans, Sjoerd and Lubbers, Mart and Koopman, Pieter},
 234         editor = {Swierstra, Wouter and Wu, Nicolas},
 235         date = {2022},
 236         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},
 237 }
 238
 239 @article{lubbers_could_2023,
 240         title = {Could Tierless Languages Reduce {IoT} Development Grief?},
 241         volume = {4},
 242         issn = {2691-1914},
 243         doi = {10.1145/3572901},
 244         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 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.},
 245         number = {1},
 246         journaltitle = {{ACM} Trans. Internet Things},
 247         author = {Lubbers, Mart and Koopman, Pieter and Ramsingh, Adrian and Singer, Jeremy and Trinder, Phil},
 248         date = {2023-02},
 249         note = {Place: New York, {NY}, {USA}
 250 Publisher: {ACM}},
 251         keywords = {access control, internet-of-things, {IoT} stacks, policy language, privilege escalation, Smart home system, Tierless languages},
 252 }